@amazon/vinyl-mpd-parser 1.0.0

package/dist/types/current/duration/duration.d.ts

@@ -0,0 +1,34 @@
+/**
+ * A duration, in seconds. (This may be negative)
+ */
+export type Duration = number;
+/**
+ * Parses an ISO 8601 duration into seconds.
+ * The accepted format is P(n)Y(n)M(n)DT(n)H(n)M(n)S
+ *
+ * All units shall have a fixed size.
+ *
+ * P - Period designator, precedes all durations.
+ * 1Y (Year) = 365 * 24 * 60 * 60 Seconds
+ * 1M (Month) = 30 * 24 * 60 * 60 Seconds
+ * 1D (Day) = 24 * 60 * 60 Seconds
+ *
+ * T - Time designator, precedes all time components.
+ * 1H (Hour) = 60 * 60 Seconds
+ * 1M (Minute) = 60 Seconds
+ * 1S (Second)
+ *
+ *
+ * @param value
+ * @return Returns the duration in seconds or throws an {@link ValidationError}
+ * if not properly formatted.
+ * @see https://www.w3.org/TR/xmlschema-2/#duration
+ */
+export declare function parseDuration(value: string): Duration;
+/**
+ * Returns the iso 8601 string representation of a duration value.
+ *
+ * @param value A duration value, in seconds.
+ */
+export declare function stringifyDuration(value: Duration): string;
+//# sourceMappingURL=duration.d.ts.map

package/dist/types/current/duration/duration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duration.d.ts","sourceRoot":"","sources":["../../../../src/duration/duration.ts"],"names":[],"mappings":"AAoBA;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAA;AAQ7B;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,QAAQ,CAkBrD;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM,CAoBzD"}

package/dist/types/current/duration/duration.js

@@ -0,0 +1,83 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ErrorOrigin, roundToNearest, ValidationError, } from '@amazon/vinyl-util';
+// ESBuild (https://github.com/evanw/esbuild/issues/3988) considers multiplication and division
+// to have a side effect and will inhibit tree shaking.
+// E.g. H = 60 * 60 will not be removed when not referenced.
+const I = 60;
+const H = 3600;
+const D = 86400;
+const M = 2592000;
+const Y = 31536000;
+/**
+ * https://www.w3.org/TR/xmlschema-2/#duration
+ */
+const iso8601Duration = /^(-?)P?(\d+(?:\.\d*)?Y)?(\d+(?:\.\d*)?M)?(\d+(?:\.\d*)?D)?T?(\d+(?:\.\d*)?H)?(\d+(?:\.\d*)?M)?(\d+(?:\.\d*)?S?)?$/i;
+/**
+ * Parses an ISO 8601 duration into seconds.
+ * The accepted format is P(n)Y(n)M(n)DT(n)H(n)M(n)S
+ *
+ * All units shall have a fixed size.
+ *
+ * P - Period designator, precedes all durations.
+ * 1Y (Year) = 365 * 24 * 60 * 60 Seconds
+ * 1M (Month) = 30 * 24 * 60 * 60 Seconds
+ * 1D (Day) = 24 * 60 * 60 Seconds
+ *
+ * T - Time designator, precedes all time components.
+ * 1H (Hour) = 60 * 60 Seconds
+ * 1M (Minute) = 60 Seconds
+ * 1S (Second)
+ *
+ *
+ * @param value
+ * @return Returns the duration in seconds or throws an {@link ValidationError}
+ * if not properly formatted.
+ * @see https://www.w3.org/TR/xmlschema-2/#duration
+ */
+export function parseDuration(value) {
+    const match = iso8601Duration.exec(value);
+    if (match == null)
+        throw new ValidationError(`Unexpected duration: '${value}', should be in iso 8601 format`, ErrorOrigin.PARSING);
+    const sign = match[1] === '-' ? -1 : 1;
+    return (sign *
+        (parseFloat(match[2] || '0') * Y +
+            parseFloat(match[3] || '0') * M +
+            parseFloat(match[4] || '0') * D +
+            parseFloat(match[5] || '0') * H +
+            parseFloat(match[6] || '0') * I +
+            parseFloat(match[7] || '0')));
+}
+/**
+ * Returns the iso 8601 string representation of a duration value.
+ *
+ * @param value A duration value, in seconds.
+ */
+export function stringifyDuration(value) {
+    const sign = value < 0 ? '-' : '';
+    let abs = Math.abs(value);
+    const years = Math.floor(abs / Y);
+    abs -= years * Y;
+    const months = Math.floor((abs % Y) / M);
+    const days = Math.floor((abs % M) / D);
+    const hours = Math.floor((abs % D) / H);
+    const minutes = Math.floor((abs % H) / I);
+    const seconds = abs % I;
+    let isoString = `${sign}P`;
+    if (years > 0)
+        isoString += `${years}Y`;
+    if (months > 0)
+        isoString += `${months}M`;
+    if (days > 0)
+        isoString += `${days}D`;
+    isoString += 'T';
+    if (hours > 0)
+        isoString += `${hours}H`;
+    if (minutes > 0)
+        isoString += `${minutes}M`;
+    if (seconds > 0 || !value)
+        isoString += `${roundToNearest(seconds, 0.001)}S`;
+    return isoString;
+}

package/dist/types/current/error/parsingError.d.ts

@@ -0,0 +1,2 @@
+export declare function throwParsingError(message: string): never;
+//# sourceMappingURL=parsingError.d.ts.map

package/dist/types/current/error/parsingError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parsingError.d.ts","sourceRoot":"","sources":["../../../../src/error/parsingError.ts"],"names":[],"mappings":"AAOA,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,CAExD"}

package/dist/types/current/error/parsingError.js

@@ -0,0 +1,8 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ErrorOrigin, ValidationError } from '@amazon/vinyl-util';
+export function throwParsingError(message) {
+    throw new ValidationError(message, ErrorOrigin.PARSING);
+}

package/dist/types/current/index.d.ts

@@ -0,0 +1,16 @@
+/** Auto-generated from build scripts */
+export * from './xmlns/mpeg/dash/schema/mpd/2011';
+export * from './xmlns/mpeg/cenc/2013';
+export * from './xmlns/microsoft/playready';
+export * from './media/ratio';
+export * from './media/frameRate';
+export * from './media/byteRange';
+export * from './manifest/dashParser';
+export * from './manifest/dashManifestXmlRules';
+export * from './manifest/ext/drm/playreadyXmlRules';
+export * from './manifest/ext/drm/contentProtection';
+export * from './manifest/ext/drm/cencXmlRules';
+export * from './manifest/ext/drm/ContentProtectionScheme';
+export * from './error/parsingError';
+export * from './duration/duration';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/current/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAAA,wCAAwC;AACxC,cAAc,mCAAmC,CAAA;AACjD,cAAc,wBAAwB,CAAA;AACtC,cAAc,6BAA6B,CAAA;AAC3C,cAAc,eAAe,CAAA;AAC7B,cAAc,mBAAmB,CAAA;AACjC,cAAc,mBAAmB,CAAA;AACjC,cAAc,uBAAuB,CAAA;AACrC,cAAc,iCAAiC,CAAA;AAC/C,cAAc,sCAAsC,CAAA;AACpD,cAAc,sCAAsC,CAAA;AACpD,cAAc,iCAAiC,CAAA;AAC/C,cAAc,4CAA4C,CAAA;AAC1D,cAAc,sBAAsB,CAAA;AACpC,cAAc,qBAAqB,CAAA"}

package/dist/types/current/index.js

@@ -0,0 +1,15 @@
+/** Auto-generated from build scripts */
+export * from './xmlns/mpeg/dash/schema/mpd/2011';
+export * from './xmlns/mpeg/cenc/2013';
+export * from './xmlns/microsoft/playready';
+export * from './media/ratio';
+export * from './media/frameRate';
+export * from './media/byteRange';
+export * from './manifest/dashParser';
+export * from './manifest/dashManifestXmlRules';
+export * from './manifest/ext/drm/playreadyXmlRules';
+export * from './manifest/ext/drm/contentProtection';
+export * from './manifest/ext/drm/cencXmlRules';
+export * from './manifest/ext/drm/ContentProtectionScheme';
+export * from './error/parsingError';
+export * from './duration/duration';

package/dist/types/current/manifest/dashManifestXmlRules.d.ts

@@ -0,0 +1,65 @@
+import { type XmlRules } from '@amazon/vinyl-xml';
+import type { ConditionalUintType, DashManifest, PresentationType, SwitchingTypeType, VideoScanType } from '../xmlns/mpeg/dash/schema/mpd/2011';
+export declare const dashNamespaceUri = "urn:mpeg:dash:schema:mpd:2011";
+export declare function dashManifestXmlRules(): XmlRules<DashManifest>;
+/**
+ * Parses a comma delimited list of profiles.
+ * Profile values are not whitespace trimmed.
+ *
+ * @param str
+ */
+export declare function parseProfiles(str: string): readonly string[];
+/**
+ * Returns the string representation of a {@link FrameRate} value.
+ *
+ * @param value
+ */
+export declare function stringifyProfiles(value: readonly string[]): string;
+/**
+ * @private
+ */
+export declare function parseVideoScan(str: string): VideoScanType;
+/**
+ * @private
+ */
+export declare function parseSwitchingTypeType(str: string): SwitchingTypeType;
+/**
+ * @private
+ */
+export declare function parseSap(str: string): number;
+/**
+ * Splits a string by whitespace.
+ *
+ * @private
+ */
+export declare function parseStringVector(str: string): readonly string[];
+/**
+ * Returns the string representation of a string vector value.
+ *
+ * @param value
+ */
+export declare function stringifyStringVector(value: readonly string[]): string;
+/**
+ * Splits a string by whitespace and parses as int.
+ *
+ * @private
+ */
+export declare function parseIntVector(str: string): readonly number[];
+/**
+ * Returns the string representation of an int vector value.
+ *
+ * @param value
+ */
+export declare function stringifyIntVector(value: readonly number[]): string;
+/**
+ * Asserts that the given string is one of the {@link PresentationType} enumerated values.
+ * @param str
+ */
+export declare function parsePresentationTypeType(str: string): PresentationType;
+/**
+ * Parses a string into true, false, or a number.
+ *
+ * @private
+ */
+export declare function parseConditionalUint(str: string): ConditionalUintType;
+//# sourceMappingURL=dashManifestXmlRules.d.ts.map

package/dist/types/current/manifest/dashManifestXmlRules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dashManifestXmlRules.d.ts","sourceRoot":"","sources":["../../../../src/manifest/dashManifestXmlRules.ts"],"names":[],"mappings":"AAaA,OAAO,EAWH,KAAK,QAAQ,EAChB,MAAM,mBAAmB,CAAA;AAO1B,OAAO,KAAK,EAGR,mBAAmB,EAEnB,YAAY,EAQZ,gBAAgB,EAchB,iBAAiB,EAEjB,aAAa,EAChB,MAAM,mCAAmC,CAAA;AAE1C,eAAO,MAAM,gBAAgB,kCAAkC,CAAA;AAE/D,wBAAgB,oBAAoB,IAAI,QAAQ,CAAC,YAAY,CAAC,CAkR7D;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAE5D;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAElE;AAQD;;GAEG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,aAAa,CAGzD;AAOD;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG,iBAAiB,CAGrE;AAID;;GAEG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAI5C;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAEhE;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAEtE;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAE7D;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAEnE;AAOD;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,MAAM,GAAG,gBAAgB,CAGvE;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,mBAAmB,CAUrE"}

package/dist/types/current/manifest/dashManifestXmlRules.js

@@ -0,0 +1,360 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { assertActuateEnum, attr, attrBoolean, attrDateTime, attrFloat, attrInt, attrString, charactersString, element, elements, } from '@amazon/vinyl-xml';
+import { ErrorOrigin, stringify } from '@amazon/vinyl-util';
+import { isOneOf, number } from '@amazon/vinyl-validation';
+import { parseDuration, stringifyDuration } from '../duration/duration';
+import { parseByteRange, stringifyByteRange } from '../media/byteRange';
+import { parseRatio, stringifyRatio } from '../media/ratio';
+import { parseFrameRate, stringifyFrameRate } from '../media/frameRate';
+export const dashNamespaceUri = 'urn:mpeg:dash:schema:mpd:2011';
+export function dashManifestXmlRules() {
+    const attrActuateType = attr(assertActuateEnum, stringify, {
+        default: 'onRequest',
+    });
+    const descriptorType = {
+        id: attrString,
+        schemeIdUri: attrString({ required: true }),
+        value: attrString,
+    };
+    const baseURLType = {
+        availabilityTimeComplete: attrBoolean,
+        availabilityTimeOffset: attrFloat,
+        byteRange: attrString,
+        serviceLocation: attrString,
+        _content: charactersString,
+    };
+    const contentComponentType = {
+        contentType: attrString,
+        id: attrInt,
+        lang: attrString,
+        par: attr(parseRatio, stringifyRatio),
+        Accessibility: elements(descriptorType),
+        Rating: elements(descriptorType),
+        Role: elements(descriptorType),
+        Viewpoint: elements(descriptorType),
+    };
+    const urlType = {
+        range: attr(parseByteRange, stringifyByteRange),
+        sourceURL: attrString,
+    };
+    const uriType = { _content: charactersString };
+    const segmentBaseType = {
+        Initialization: element(urlType),
+        RepresentationIndex: element(urlType),
+        availabilityTimeComplete: attrBoolean,
+        availabilityTimeOffset: attrInt,
+        indexRange: attr(parseByteRange, stringifyByteRange),
+        indexRangeExact: attrBoolean({ default: false }),
+        presentationTimeOffset: attrFloat,
+        timescale: attrInt,
+    };
+    const segmentTimelineTypeSType = {
+        d: attrInt({ required: true }),
+        n: attrInt,
+        r: attrInt({ default: 0 }),
+        t: attrInt,
+    };
+    const segmentTimelineType = {
+        S: elements(segmentTimelineTypeSType),
+    };
+    const multipleSegmentBaseType = {
+        ...segmentBaseType,
+        SegmentTimeline: element(segmentTimelineType),
+        BitstreamSwitching: element(urlType),
+        duration: attrInt,
+        startNumber: attrInt,
+    };
+    const segmentURLType = {
+        index: attrString,
+        indexRange: attr(parseByteRange, stringifyByteRange),
+        media: attrString,
+        mediaRange: attr(parseByteRange, stringifyByteRange),
+    };
+    const segmentListType = {
+        ...multipleSegmentBaseType,
+        actuate: attrActuateType,
+        href: attrString,
+        SegmentURL: elements(segmentURLType),
+    };
+    const segmentTemplateType = {
+        ...multipleSegmentBaseType,
+        bitstreamSwitching: attrString,
+        index: attrString,
+        initialization: attrString,
+        media: attrString,
+    };
+    const subsetType = {
+        contains: attr(parseIntVector, stringifyIntVector, { required: true }),
+        id: attrString,
+    };
+    const eventType = {
+        duration: attrInt,
+        id: attrInt,
+        messageData: attrString,
+        presentationTime: attrInt({ default: 0 }),
+    };
+    const eventStreamType = {
+        Event: elements(eventType),
+        actuate: attrActuateType,
+        href: attrString,
+        messageData: attrString,
+        schemeIdUri: attrString({ required: true }),
+        timescale: attrInt,
+        value: attrString,
+    };
+    const switchingType = {
+        interval: attrInt({ required: true }),
+        type: attr(parseSwitchingTypeType, stringify),
+    };
+    const representationBaseType = {
+        FramePacking: elements(descriptorType),
+        AudioChannelConfiguration: elements(descriptorType),
+        ContentProtection: elements(descriptorType),
+        EssentialProperty: elements(descriptorType),
+        SupplementalProperty: elements(descriptorType),
+        InbandEventStream: elements(eventStreamType),
+        Switching: elements(switchingType),
+        audioSamplingRate: attr(parseIntVector, stringifyIntVector),
+        codecs: attrString,
+        codingDependency: attrBoolean,
+        frameRate: attr(parseFrameRate, stringifyFrameRate),
+        height: attrInt,
+        maximumSAPPeriod: attrInt,
+        maxPlayoutRate: attrInt,
+        mimeType: attrString,
+        profiles: attr(parseProfiles, stringifyProfiles),
+        sar: attr(parseRatio, stringifyRatio),
+        scanType: attr(parseVideoScan, stringify),
+        segmentProfiles: attrString,
+        startWithSAP: attr(parseSap, stringify),
+        width: attrInt,
+    };
+    const subRepresentationType = {
+        ...representationBaseType,
+        bandwidth: attrInt,
+        contentComponent: attr(parseStringVector, stringifyStringVector),
+        dependencyLevel: attr(parseIntVector, stringifyIntVector),
+        level: attrInt,
+    };
+    const representationType = {
+        ...representationBaseType,
+        bandwidth: attrInt({ required: true }),
+        bitrate: attrInt,
+        dependencyId: attr(parseStringVector, stringifyStringVector),
+        id: attrString({ required: true }),
+        mediaStreamStructureId: attr(parseStringVector, stringifyStringVector),
+        qualityRanking: attrInt,
+        BaseURL: elements(baseURLType),
+        SegmentBase: element(segmentBaseType),
+        SegmentList: element(segmentListType),
+        SegmentTemplate: element(segmentTemplateType),
+        SubRepresentation: elements(subRepresentationType),
+    };
+    const adaptationSetType = {
+        ...representationBaseType,
+        Accessibility: elements(descriptorType),
+        Role: elements(descriptorType),
+        Rating: elements(descriptorType),
+        Viewpoint: elements(descriptorType),
+        ContentComponent: elements(contentComponentType),
+        BaseURL: elements(baseURLType),
+        SegmentBase: element(segmentBaseType),
+        SegmentList: element(segmentListType),
+        SegmentTemplate: element(segmentTemplateType),
+        Representation: elements(representationType),
+        actuate: attrActuateType,
+        bitstreamSwitching: attrBoolean,
+        contentType: attrString,
+        group: attrInt,
+        href: attrString,
+        id: attrInt,
+        lang: attrString,
+        maxBandwidth: attrInt,
+        maxFrameRate: attr(parseFrameRate, stringifyFrameRate),
+        maxHeight: attrInt,
+        maxWidth: attrInt,
+        minBandwidth: attrInt,
+        minFrameRate: attr(parseFrameRate, stringifyFrameRate),
+        minHeight: attrInt,
+        minWidth: attrInt,
+        par: attr(parseRatio, stringifyRatio),
+        segmentAlignment: attr(parseConditionalUint, stringify, {
+            default: false,
+        }),
+        selectionPriority: attrInt({
+            default: 1,
+        }),
+        subsegmentAlignment: attr(parseConditionalUint, stringify, {
+            default: false,
+        }),
+        subsegmentStartsWithSAP: attr(parseSap, stringify, { default: 0 }),
+    };
+    const rangeType = {
+        duration: attr(parseDuration, stringifyDuration),
+        starttime: attr(parseDuration, stringifyDuration),
+    };
+    const metricsType = {
+        metrics: attrString({ required: true }),
+        Range: elements(rangeType),
+        Reporting: elements(descriptorType, { minOccurs: 1 }),
+    };
+    const periodType = {
+        BaseURL: elements(baseURLType),
+        SegmentBase: element(segmentBaseType),
+        SegmentList: element(segmentListType),
+        SegmentTemplate: element(segmentTemplateType),
+        AssetIdentifier: element(descriptorType),
+        EventStream: elements(eventStreamType),
+        AdaptationSet: elements(adaptationSetType),
+        Subset: elements(subsetType),
+        SupplementalProperty: elements(descriptorType),
+        actuate: attrActuateType,
+        bitstreamSwitching: attrBoolean({ default: false }),
+        duration: attr(parseDuration, stringifyDuration),
+        href: attrString,
+        id: attrString,
+        start: attr(parseDuration, stringifyDuration),
+    };
+    const programInformationType = {
+        lang: attrString,
+        moreInformationURL: attrString,
+        Copyright: attrString,
+        Source: attrString,
+        Title: attrString,
+    };
+    const mpdType = {
+        ProgramInformation: elements(programInformationType),
+        BaseURL: elements(baseURLType),
+        Location: elements(uriType),
+        Period: elements(periodType, { minOccurs: 1 }),
+        Metrics: elements(metricsType),
+        EssentialProperty: elements(descriptorType),
+        SupplementalProperty: elements(descriptorType),
+        UTCTiming: elements(descriptorType),
+        availabilityEndTime: attrDateTime,
+        availabilityStartTime: attrDateTime,
+        id: attrString,
+        maxSegmentDuration: attr(parseDuration, stringifyDuration),
+        maxSubsegmentDuration: attr(parseDuration, stringifyDuration),
+        mediaPresentationDuration: attr(parseDuration, stringifyDuration),
+        minBufferTime: attr(parseDuration, stringifyDuration, {
+            required: true,
+        }),
+        minimumUpdatePeriod: attr(parseDuration, stringifyDuration),
+        profiles: attr(parseProfiles, stringifyProfiles, { required: true }),
+        publishTime: attrDateTime,
+        suggestedPresentationDelay: attr(parseDuration, stringifyDuration),
+        timeShiftBufferDepth: attr(parseDuration, stringifyDuration),
+        type: attr(parsePresentationTypeType, stringify, {
+            default: 'static',
+        }),
+    };
+    return {
+        MPD: element(mpdType, {
+            required: true,
+            namespaceUri: dashNamespaceUri,
+        }),
+    };
+}
+/**
+ * Parses a comma delimited list of profiles.
+ * Profile values are not whitespace trimmed.
+ *
+ * @param str
+ */
+export function parseProfiles(str) {
+    return str.split(',');
+}
+/**
+ * Returns the string representation of a {@link FrameRate} value.
+ *
+ * @param value
+ */
+export function stringifyProfiles(value) {
+    return value.join(',');
+}
+const videoScanTypeValidator = isOneOf('progressive', 'interlaced', 'unknown');
+/**
+ * @private
+ */
+export function parseVideoScan(str) {
+    videoScanTypeValidator.assert(str, ErrorOrigin.PARSING);
+    return str;
+}
+const switchingTypeTypeValidator = isOneOf('media', 'bitstream');
+/**
+ * @private
+ */
+export function parseSwitchingTypeType(str) {
+    switchingTypeTypeValidator.assert(str, ErrorOrigin.PARSING);
+    return str;
+}
+const validateSap = number().within(0, 6);
+/**
+ * @private
+ */
+export function parseSap(str) {
+    const number = parseInt(str);
+    validateSap.assert(number, ErrorOrigin.PARSING);
+    return number;
+}
+/**
+ * Splits a string by whitespace.
+ *
+ * @private
+ */
+export function parseStringVector(str) {
+    return str.split(/\s+/);
+}
+/**
+ * Returns the string representation of a string vector value.
+ *
+ * @param value
+ */
+export function stringifyStringVector(value) {
+    return value.join(' ');
+}
+/**
+ * Splits a string by whitespace and parses as int.
+ *
+ * @private
+ */
+export function parseIntVector(str) {
+    return str.split(/\s+/).map((subStr) => parseInt(subStr));
+}
+/**
+ * Returns the string representation of an int vector value.
+ *
+ * @param value
+ */
+export function stringifyIntVector(value) {
+    return value.join(' ');
+}
+const presentationTypeValidator = isOneOf('static', 'dynamic');
+/**
+ * Asserts that the given string is one of the {@link PresentationType} enumerated values.
+ * @param str
+ */
+export function parsePresentationTypeType(str) {
+    presentationTypeValidator.assert(str, ErrorOrigin.PARSING);
+    return str;
+}
+/**
+ * Parses a string into true, false, or a number.
+ *
+ * @private
+ */
+export function parseConditionalUint(str) {
+    const lower = str.toLowerCase();
+    switch (lower) {
+        case 'true':
+            return true;
+        case 'false':
+            return false;
+        default:
+            return parseInt(str);
+    }
+}

package/dist/types/current/manifest/dashParser.d.ts

@@ -0,0 +1,23 @@
+import type { ReservedXmlRuleKeys } from '@amazon/vinyl-xml';
+import { type Merged } from '@amazon/vinyl-xml';
+import type { PlayreadyContentProtection } from '../xmlns/microsoft/playready';
+import type { CencContentProtection } from '../xmlns/mpeg/cenc/2013';
+import type { DashManifest, DescriptorType } from '../xmlns/mpeg/dash/schema/mpd/2011';
+import type { DashProtections } from './ext/drm/contentProtection';
+import type { OptionalDeep } from '@amazon/vinyl-util';
+/**
+ * Creates a Dash Manifest parser with supported extensions.
+ *
+ * @module
+ */
+export type DashDrmManifest = Merged<DashManifest & DashProtections<ContentProtection>>;
+export interface ContentProtection extends DescriptorType, CencContentProtection, PlayreadyContentProtection {
+}
+/**
+ * Parses a Dash Manifest, according to the mpd:2011 schema.
+ * @see https://raw.githubusercontent.com/Dash-Industry-Forum/MPEG-Conformance-and-reference-source/master/conformance/MPDValidator/schemas/DASH-MPD.xsd
+ * @param manifest
+ */
+export declare function parseDashManifest(manifest: string): DashDrmManifest;
+export declare function stringifyDashManifest(manifest: OptionalDeep<DashDrmManifest, ReservedXmlRuleKeys>): string;
+//# sourceMappingURL=dashParser.d.ts.map

package/dist/types/current/manifest/dashParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dashParser.d.ts","sourceRoot":"","sources":["../../../../src/manifest/dashParser.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAA;AAC5D,OAAO,EAEH,KAAK,MAAM,EAKd,MAAM,mBAAmB,CAAA;AAC1B,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,6BAA6B,CAAA;AAC7E,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAA;AACnE,OAAO,KAAK,EACR,YAAY,EACZ,cAAc,EACjB,MAAM,mCAAmC,CAAA;AAG1C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAA;AAGlE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAEtD;;;;GAIG;AAEH,MAAM,MAAM,eAAe,GAAG,MAAM,CAChC,YAAY,GAAG,eAAe,CAAC,iBAAiB,CAAC,CACpD,CAAA;AAED,MAAM,WAAW,iBACb,SAAQ,cAAc,EAAE,qBAAqB,EAAE,0BAA0B;CAAG;AAiBhF;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,eAAe,CAEnE;AAED,wBAAgB,qBAAqB,CACjC,QAAQ,EAAE,YAAY,CAAC,eAAe,EAAE,mBAAmB,CAAC,GAC7D,MAAM,CAER"}

package/dist/types/current/manifest/dashParser.js

@@ -0,0 +1,28 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { mapXmlRules, mergeXmlRules, parseXml, ParseXmlHandlerImpl, stringifyXml, } from '@amazon/vinyl-xml';
+import { dashManifestXmlRules } from './dashManifestXmlRules';
+import { cencXmlRules } from './ext/drm/cencXmlRules';
+import { createDashProtectionXmlRules } from './ext/drm/contentProtection';
+import { playreadyXmlRules } from './ext/drm/playreadyXmlRules';
+const dashDrmRules = mergeXmlRules(dashManifestXmlRules(), createDashProtectionXmlRules(cencXmlRules), createDashProtectionXmlRules(playreadyXmlRules));
+const dashDrmRulesMapped = mapXmlRules(dashDrmRules);
+/**
+ * A Content handler for a dash manifest.
+ */
+function dashManifestHandler() {
+    return new ParseXmlHandlerImpl(dashDrmRulesMapped);
+}
+/**
+ * Parses a Dash Manifest, according to the mpd:2011 schema.
+ * @see https://raw.githubusercontent.com/Dash-Industry-Forum/MPEG-Conformance-and-reference-source/master/conformance/MPDValidator/schemas/DASH-MPD.xsd
+ * @param manifest
+ */
+export function parseDashManifest(manifest) {
+    return parseXml(manifest, dashManifestHandler());
+}
+export function stringifyDashManifest(manifest) {
+    return stringifyXml(manifest, dashDrmRulesMapped);
+}