@amazon/vinyl-mpd-parser 1.0.0

package/dist/index.cjs

@@ -0,0 +1,583 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CENC_NAMESPACE_URI: () => CENC_NAMESPACE_URI,
+  ContentProtectionScheme: () => ContentProtectionScheme,
+  PLAY_READY_NAMESPACE_URI: () => PLAY_READY_NAMESPACE_URI,
+  cencXmlRules: () => cencXmlRules,
+  createDashProtectionXmlRules: () => createDashProtectionXmlRules,
+  dashManifestXmlRules: () => dashManifestXmlRules,
+  dashNamespaceUri: () => dashNamespaceUri,
+  parseByteRange: () => parseByteRange,
+  parseConditionalUint: () => parseConditionalUint,
+  parseDashManifest: () => parseDashManifest,
+  parseDuration: () => parseDuration,
+  parseFrameRate: () => parseFrameRate,
+  parseIntVector: () => parseIntVector,
+  parsePresentationTypeType: () => parsePresentationTypeType,
+  parseProfiles: () => parseProfiles,
+  parseRatio: () => parseRatio,
+  parseSap: () => parseSap,
+  parseStringVector: () => parseStringVector,
+  parseSwitchingTypeType: () => parseSwitchingTypeType,
+  parseVideoScan: () => parseVideoScan,
+  playreadyXmlRules: () => playreadyXmlRules,
+  stringifyByteRange: () => stringifyByteRange,
+  stringifyDashManifest: () => stringifyDashManifest,
+  stringifyDuration: () => stringifyDuration,
+  stringifyFrameRate: () => stringifyFrameRate,
+  stringifyIntVector: () => stringifyIntVector,
+  stringifyProfiles: () => stringifyProfiles,
+  stringifyRatio: () => stringifyRatio,
+  stringifyStringVector: () => stringifyStringVector,
+  throwParsingError: () => throwParsingError
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/xmlns/mpeg/cenc/2013.ts
+var CENC_NAMESPACE_URI = "urn:mpeg:cenc:2013";
+
+// src/xmlns/microsoft/playready.ts
+var PLAY_READY_NAMESPACE_URI = "urn:microsoft:playready";
+
+// src/error/parsingError.ts
+var import_vinyl_util = require("@amazon/vinyl-util");
+function throwParsingError(message) {
+  throw new import_vinyl_util.ValidationError(message, import_vinyl_util.ErrorOrigin.PARSING);
+}
+
+// src/media/ratio.ts
+var ratioRegExp = /^([0-9]*):([0-9]*)$/;
+function parseRatio(str) {
+  const match = str ? ratioRegExp.exec(str) : null;
+  if (!match) throwParsingError(`invalid ratio format: ${str}`);
+  return [parseInt(match[1] || "1"), parseInt(match[2] || "1")];
+}
+function stringifyRatio(value) {
+  return `${value[0]}:${value[1]}`;
+}
+
+// src/media/frameRate.ts
+var framerateRegexp = /^(\d+)(?:\/(\d+))?$/;
+function parseFrameRate(str) {
+  const match = str ? framerateRegexp.exec(str) : null;
+  if (!match) throwParsingError(`invalid frame rate: '${str}'`);
+  return [parseInt(match[1]), parseInt(match[2] || "1")];
+}
+function stringifyFrameRate(value) {
+  return value[1] === 1 ? value[0].toString() : `${value[0]}/${value[1]}`;
+}
+
+// src/media/byteRange.ts
+var import_vinyl_util2 = require("@amazon/vinyl-util");
+var byteRangeExp = /^(-?[0-9]+)-(-?[0-9]*)$/;
+function parseByteRange(str) {
+  const match = str ? byteRangeExp.exec(str) : null;
+  if (!match) throwParsingError(`invalid byte range: '${str}'`);
+  let start = parseInt(match[1]);
+  if (start < 0) start >>>= 0;
+  let end = (0, import_vinyl_util2.parseIntSafe)(match[2]);
+  if (end != null && end < 0) end = end >>> 0;
+  return [start, end];
+}
+function stringifyByteRange(value) {
+  const end = value[1];
+  return `${value[0]}-${end == null ? "" : end}`;
+}
+
+// src/manifest/dashParser.ts
+var import_vinyl_xml5 = require("@amazon/vinyl-xml");
+
+// src/manifest/dashManifestXmlRules.ts
+var import_vinyl_xml = require("@amazon/vinyl-xml");
+var import_vinyl_util4 = require("@amazon/vinyl-util");
+var import_vinyl_validation = require("@amazon/vinyl-validation");
+
+// src/duration/duration.ts
+var import_vinyl_util3 = require("@amazon/vinyl-util");
+var I = 60;
+var H = 3600;
+var D = 86400;
+var M = 2592e3;
+var Y = 31536e3;
+var iso8601Duration = /^(-?)P?(\d+(?:\.\d*)?Y)?(\d+(?:\.\d*)?M)?(\d+(?:\.\d*)?D)?T?(\d+(?:\.\d*)?H)?(\d+(?:\.\d*)?M)?(\d+(?:\.\d*)?S?)?$/i;
+function parseDuration(value) {
+  const match = iso8601Duration.exec(value);
+  if (match == null)
+    throw new import_vinyl_util3.ValidationError(
+      `Unexpected duration: '${value}', should be in iso 8601 format`,
+      import_vinyl_util3.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"));
+}
+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 += `${(0, import_vinyl_util3.roundToNearest)(seconds, 1e-3)}S`;
+  return isoString;
+}
+
+// src/manifest/dashManifestXmlRules.ts
+var dashNamespaceUri = "urn:mpeg:dash:schema:mpd:2011";
+function dashManifestXmlRules() {
+  const attrActuateType = (0, import_vinyl_xml.attr)(import_vinyl_xml.assertActuateEnum, import_vinyl_util4.stringify, {
+    default: "onRequest"
+  });
+  const descriptorType = {
+    id: import_vinyl_xml.attrString,
+    schemeIdUri: (0, import_vinyl_xml.attrString)({ required: true }),
+    value: import_vinyl_xml.attrString
+  };
+  const baseURLType = {
+    availabilityTimeComplete: import_vinyl_xml.attrBoolean,
+    availabilityTimeOffset: import_vinyl_xml.attrFloat,
+    byteRange: import_vinyl_xml.attrString,
+    serviceLocation: import_vinyl_xml.attrString,
+    _content: import_vinyl_xml.charactersString
+  };
+  const contentComponentType = {
+    contentType: import_vinyl_xml.attrString,
+    id: import_vinyl_xml.attrInt,
+    lang: import_vinyl_xml.attrString,
+    par: (0, import_vinyl_xml.attr)(parseRatio, stringifyRatio),
+    Accessibility: (0, import_vinyl_xml.elements)(descriptorType),
+    Rating: (0, import_vinyl_xml.elements)(descriptorType),
+    Role: (0, import_vinyl_xml.elements)(descriptorType),
+    Viewpoint: (0, import_vinyl_xml.elements)(descriptorType)
+  };
+  const urlType = {
+    range: (0, import_vinyl_xml.attr)(parseByteRange, stringifyByteRange),
+    sourceURL: import_vinyl_xml.attrString
+  };
+  const uriType = { _content: import_vinyl_xml.charactersString };
+  const segmentBaseType = {
+    Initialization: (0, import_vinyl_xml.element)(urlType),
+    RepresentationIndex: (0, import_vinyl_xml.element)(urlType),
+    availabilityTimeComplete: import_vinyl_xml.attrBoolean,
+    availabilityTimeOffset: import_vinyl_xml.attrInt,
+    indexRange: (0, import_vinyl_xml.attr)(parseByteRange, stringifyByteRange),
+    indexRangeExact: (0, import_vinyl_xml.attrBoolean)({ default: false }),
+    presentationTimeOffset: import_vinyl_xml.attrFloat,
+    timescale: import_vinyl_xml.attrInt
+  };
+  const segmentTimelineTypeSType = {
+    d: (0, import_vinyl_xml.attrInt)({ required: true }),
+    n: import_vinyl_xml.attrInt,
+    r: (0, import_vinyl_xml.attrInt)({ default: 0 }),
+    t: import_vinyl_xml.attrInt
+  };
+  const segmentTimelineType = {
+    S: (0, import_vinyl_xml.elements)(segmentTimelineTypeSType)
+  };
+  const multipleSegmentBaseType = __spreadProps(__spreadValues({}, segmentBaseType), {
+    SegmentTimeline: (0, import_vinyl_xml.element)(segmentTimelineType),
+    BitstreamSwitching: (0, import_vinyl_xml.element)(urlType),
+    duration: import_vinyl_xml.attrInt,
+    startNumber: import_vinyl_xml.attrInt
+  });
+  const segmentURLType = {
+    index: import_vinyl_xml.attrString,
+    indexRange: (0, import_vinyl_xml.attr)(parseByteRange, stringifyByteRange),
+    media: import_vinyl_xml.attrString,
+    mediaRange: (0, import_vinyl_xml.attr)(parseByteRange, stringifyByteRange)
+  };
+  const segmentListType = __spreadProps(__spreadValues({}, multipleSegmentBaseType), {
+    actuate: attrActuateType,
+    href: import_vinyl_xml.attrString,
+    SegmentURL: (0, import_vinyl_xml.elements)(segmentURLType)
+  });
+  const segmentTemplateType = __spreadProps(__spreadValues({}, multipleSegmentBaseType), {
+    bitstreamSwitching: import_vinyl_xml.attrString,
+    index: import_vinyl_xml.attrString,
+    initialization: import_vinyl_xml.attrString,
+    media: import_vinyl_xml.attrString
+  });
+  const subsetType = {
+    contains: (0, import_vinyl_xml.attr)(parseIntVector, stringifyIntVector, { required: true }),
+    id: import_vinyl_xml.attrString
+  };
+  const eventType = {
+    duration: import_vinyl_xml.attrInt,
+    id: import_vinyl_xml.attrInt,
+    messageData: import_vinyl_xml.attrString,
+    presentationTime: (0, import_vinyl_xml.attrInt)({ default: 0 })
+  };
+  const eventStreamType = {
+    Event: (0, import_vinyl_xml.elements)(eventType),
+    actuate: attrActuateType,
+    href: import_vinyl_xml.attrString,
+    messageData: import_vinyl_xml.attrString,
+    schemeIdUri: (0, import_vinyl_xml.attrString)({ required: true }),
+    timescale: import_vinyl_xml.attrInt,
+    value: import_vinyl_xml.attrString
+  };
+  const switchingType = {
+    interval: (0, import_vinyl_xml.attrInt)({ required: true }),
+    type: (0, import_vinyl_xml.attr)(parseSwitchingTypeType, import_vinyl_util4.stringify)
+  };
+  const representationBaseType = {
+    FramePacking: (0, import_vinyl_xml.elements)(descriptorType),
+    AudioChannelConfiguration: (0, import_vinyl_xml.elements)(descriptorType),
+    ContentProtection: (0, import_vinyl_xml.elements)(descriptorType),
+    EssentialProperty: (0, import_vinyl_xml.elements)(descriptorType),
+    SupplementalProperty: (0, import_vinyl_xml.elements)(descriptorType),
+    InbandEventStream: (0, import_vinyl_xml.elements)(eventStreamType),
+    Switching: (0, import_vinyl_xml.elements)(switchingType),
+    audioSamplingRate: (0, import_vinyl_xml.attr)(parseIntVector, stringifyIntVector),
+    codecs: import_vinyl_xml.attrString,
+    codingDependency: import_vinyl_xml.attrBoolean,
+    frameRate: (0, import_vinyl_xml.attr)(parseFrameRate, stringifyFrameRate),
+    height: import_vinyl_xml.attrInt,
+    maximumSAPPeriod: import_vinyl_xml.attrInt,
+    maxPlayoutRate: import_vinyl_xml.attrInt,
+    mimeType: import_vinyl_xml.attrString,
+    profiles: (0, import_vinyl_xml.attr)(parseProfiles, stringifyProfiles),
+    sar: (0, import_vinyl_xml.attr)(parseRatio, stringifyRatio),
+    scanType: (0, import_vinyl_xml.attr)(parseVideoScan, import_vinyl_util4.stringify),
+    segmentProfiles: import_vinyl_xml.attrString,
+    startWithSAP: (0, import_vinyl_xml.attr)(parseSap, import_vinyl_util4.stringify),
+    width: import_vinyl_xml.attrInt
+  };
+  const subRepresentationType = __spreadProps(__spreadValues({}, representationBaseType), {
+    bandwidth: import_vinyl_xml.attrInt,
+    contentComponent: (0, import_vinyl_xml.attr)(parseStringVector, stringifyStringVector),
+    dependencyLevel: (0, import_vinyl_xml.attr)(parseIntVector, stringifyIntVector),
+    level: import_vinyl_xml.attrInt
+  });
+  const representationType = __spreadProps(__spreadValues({}, representationBaseType), {
+    bandwidth: (0, import_vinyl_xml.attrInt)({ required: true }),
+    bitrate: import_vinyl_xml.attrInt,
+    dependencyId: (0, import_vinyl_xml.attr)(parseStringVector, stringifyStringVector),
+    id: (0, import_vinyl_xml.attrString)({ required: true }),
+    mediaStreamStructureId: (0, import_vinyl_xml.attr)(parseStringVector, stringifyStringVector),
+    qualityRanking: import_vinyl_xml.attrInt,
+    BaseURL: (0, import_vinyl_xml.elements)(baseURLType),
+    SegmentBase: (0, import_vinyl_xml.element)(segmentBaseType),
+    SegmentList: (0, import_vinyl_xml.element)(segmentListType),
+    SegmentTemplate: (0, import_vinyl_xml.element)(segmentTemplateType),
+    SubRepresentation: (0, import_vinyl_xml.elements)(subRepresentationType)
+  });
+  const adaptationSetType = __spreadProps(__spreadValues({}, representationBaseType), {
+    Accessibility: (0, import_vinyl_xml.elements)(descriptorType),
+    Role: (0, import_vinyl_xml.elements)(descriptorType),
+    Rating: (0, import_vinyl_xml.elements)(descriptorType),
+    Viewpoint: (0, import_vinyl_xml.elements)(descriptorType),
+    ContentComponent: (0, import_vinyl_xml.elements)(contentComponentType),
+    BaseURL: (0, import_vinyl_xml.elements)(baseURLType),
+    SegmentBase: (0, import_vinyl_xml.element)(segmentBaseType),
+    SegmentList: (0, import_vinyl_xml.element)(segmentListType),
+    SegmentTemplate: (0, import_vinyl_xml.element)(segmentTemplateType),
+    Representation: (0, import_vinyl_xml.elements)(representationType),
+    actuate: attrActuateType,
+    bitstreamSwitching: import_vinyl_xml.attrBoolean,
+    contentType: import_vinyl_xml.attrString,
+    group: import_vinyl_xml.attrInt,
+    href: import_vinyl_xml.attrString,
+    id: import_vinyl_xml.attrInt,
+    lang: import_vinyl_xml.attrString,
+    maxBandwidth: import_vinyl_xml.attrInt,
+    maxFrameRate: (0, import_vinyl_xml.attr)(parseFrameRate, stringifyFrameRate),
+    maxHeight: import_vinyl_xml.attrInt,
+    maxWidth: import_vinyl_xml.attrInt,
+    minBandwidth: import_vinyl_xml.attrInt,
+    minFrameRate: (0, import_vinyl_xml.attr)(parseFrameRate, stringifyFrameRate),
+    minHeight: import_vinyl_xml.attrInt,
+    minWidth: import_vinyl_xml.attrInt,
+    par: (0, import_vinyl_xml.attr)(parseRatio, stringifyRatio),
+    segmentAlignment: (0, import_vinyl_xml.attr)(parseConditionalUint, import_vinyl_util4.stringify, {
+      default: false
+    }),
+    selectionPriority: (0, import_vinyl_xml.attrInt)({
+      default: 1
+    }),
+    subsegmentAlignment: (0, import_vinyl_xml.attr)(parseConditionalUint, import_vinyl_util4.stringify, {
+      default: false
+    }),
+    subsegmentStartsWithSAP: (0, import_vinyl_xml.attr)(parseSap, import_vinyl_util4.stringify, { default: 0 })
+  });
+  const rangeType = {
+    duration: (0, import_vinyl_xml.attr)(parseDuration, stringifyDuration),
+    starttime: (0, import_vinyl_xml.attr)(parseDuration, stringifyDuration)
+  };
+  const metricsType = {
+    metrics: (0, import_vinyl_xml.attrString)({ required: true }),
+    Range: (0, import_vinyl_xml.elements)(rangeType),
+    Reporting: (0, import_vinyl_xml.elements)(descriptorType, { minOccurs: 1 })
+  };
+  const periodType = {
+    BaseURL: (0, import_vinyl_xml.elements)(baseURLType),
+    SegmentBase: (0, import_vinyl_xml.element)(segmentBaseType),
+    SegmentList: (0, import_vinyl_xml.element)(segmentListType),
+    SegmentTemplate: (0, import_vinyl_xml.element)(segmentTemplateType),
+    AssetIdentifier: (0, import_vinyl_xml.element)(descriptorType),
+    EventStream: (0, import_vinyl_xml.elements)(eventStreamType),
+    AdaptationSet: (0, import_vinyl_xml.elements)(adaptationSetType),
+    Subset: (0, import_vinyl_xml.elements)(subsetType),
+    SupplementalProperty: (0, import_vinyl_xml.elements)(descriptorType),
+    actuate: attrActuateType,
+    bitstreamSwitching: (0, import_vinyl_xml.attrBoolean)({ default: false }),
+    duration: (0, import_vinyl_xml.attr)(parseDuration, stringifyDuration),
+    href: import_vinyl_xml.attrString,
+    id: import_vinyl_xml.attrString,
+    start: (0, import_vinyl_xml.attr)(parseDuration, stringifyDuration)
+  };
+  const programInformationType = {
+    lang: import_vinyl_xml.attrString,
+    moreInformationURL: import_vinyl_xml.attrString,
+    Copyright: import_vinyl_xml.attrString,
+    Source: import_vinyl_xml.attrString,
+    Title: import_vinyl_xml.attrString
+  };
+  const mpdType = {
+    ProgramInformation: (0, import_vinyl_xml.elements)(programInformationType),
+    BaseURL: (0, import_vinyl_xml.elements)(baseURLType),
+    Location: (0, import_vinyl_xml.elements)(uriType),
+    Period: (0, import_vinyl_xml.elements)(periodType, { minOccurs: 1 }),
+    Metrics: (0, import_vinyl_xml.elements)(metricsType),
+    EssentialProperty: (0, import_vinyl_xml.elements)(descriptorType),
+    SupplementalProperty: (0, import_vinyl_xml.elements)(descriptorType),
+    UTCTiming: (0, import_vinyl_xml.elements)(descriptorType),
+    availabilityEndTime: import_vinyl_xml.attrDateTime,
+    availabilityStartTime: import_vinyl_xml.attrDateTime,
+    id: import_vinyl_xml.attrString,
+    maxSegmentDuration: (0, import_vinyl_xml.attr)(parseDuration, stringifyDuration),
+    maxSubsegmentDuration: (0, import_vinyl_xml.attr)(parseDuration, stringifyDuration),
+    mediaPresentationDuration: (0, import_vinyl_xml.attr)(parseDuration, stringifyDuration),
+    minBufferTime: (0, import_vinyl_xml.attr)(parseDuration, stringifyDuration, {
+      required: true
+    }),
+    minimumUpdatePeriod: (0, import_vinyl_xml.attr)(parseDuration, stringifyDuration),
+    profiles: (0, import_vinyl_xml.attr)(parseProfiles, stringifyProfiles, { required: true }),
+    publishTime: import_vinyl_xml.attrDateTime,
+    suggestedPresentationDelay: (0, import_vinyl_xml.attr)(parseDuration, stringifyDuration),
+    timeShiftBufferDepth: (0, import_vinyl_xml.attr)(parseDuration, stringifyDuration),
+    type: (0, import_vinyl_xml.attr)(parsePresentationTypeType, import_vinyl_util4.stringify, {
+      default: "static"
+    })
+  };
+  return {
+    MPD: (0, import_vinyl_xml.element)(mpdType, {
+      required: true,
+      namespaceUri: dashNamespaceUri
+    })
+  };
+}
+function parseProfiles(str) {
+  return str.split(",");
+}
+function stringifyProfiles(value) {
+  return value.join(",");
+}
+var videoScanTypeValidator = /* @__PURE__ */ (0, import_vinyl_validation.isOneOf)(
+  "progressive",
+  "interlaced",
+  "unknown"
+);
+function parseVideoScan(str) {
+  videoScanTypeValidator.assert(str, import_vinyl_util4.ErrorOrigin.PARSING);
+  return str;
+}
+var switchingTypeTypeValidator = /* @__PURE__ */ (0, import_vinyl_validation.isOneOf)(
+  "media",
+  "bitstream"
+);
+function parseSwitchingTypeType(str) {
+  switchingTypeTypeValidator.assert(str, import_vinyl_util4.ErrorOrigin.PARSING);
+  return str;
+}
+var validateSap = /* @__PURE__ */ (0, import_vinyl_validation.number)().within(0, 6);
+function parseSap(str) {
+  const number2 = parseInt(str);
+  validateSap.assert(number2, import_vinyl_util4.ErrorOrigin.PARSING);
+  return number2;
+}
+function parseStringVector(str) {
+  return str.split(/\s+/);
+}
+function stringifyStringVector(value) {
+  return value.join(" ");
+}
+function parseIntVector(str) {
+  return str.split(/\s+/).map((subStr) => parseInt(subStr));
+}
+function stringifyIntVector(value) {
+  return value.join(" ");
+}
+var presentationTypeValidator = /* @__PURE__ */ (0, import_vinyl_validation.isOneOf)(
+  "static",
+  "dynamic"
+);
+function parsePresentationTypeType(str) {
+  presentationTypeValidator.assert(str, import_vinyl_util4.ErrorOrigin.PARSING);
+  return str;
+}
+function parseConditionalUint(str) {
+  const lower = str.toLowerCase();
+  switch (lower) {
+    case "true":
+      return true;
+    case "false":
+      return false;
+    default:
+      return parseInt(str);
+  }
+}
+
+// src/manifest/ext/drm/cencXmlRules.ts
+var import_vinyl_xml2 = require("@amazon/vinyl-xml");
+var cencXmlRules = {
+  default_KID: /* @__PURE__ */ (0, import_vinyl_xml2.attr)(parseStringVector, stringifyStringVector, {
+    namespaceUri: CENC_NAMESPACE_URI
+  }),
+  pssh: /* @__PURE__ */ (0, import_vinyl_xml2.element)(
+    {
+      _content: import_vinyl_xml2.charactersString
+    },
+    {
+      namespaceUri: CENC_NAMESPACE_URI
+    }
+  )
+};
+
+// src/manifest/ext/drm/contentProtection.ts
+var import_vinyl_xml3 = require("@amazon/vinyl-xml");
+function createDashProtectionXmlRules(contentProtectionRules) {
+  const withProtections = {
+    ContentProtection: (0, import_vinyl_xml3.elements)(contentProtectionRules)
+  };
+  return {
+    MPD: (0, import_vinyl_xml3.element)(
+      {
+        Period: (0, import_vinyl_xml3.elements)(
+          {
+            AdaptationSet: (0, import_vinyl_xml3.elements)(__spreadProps(__spreadValues({}, withProtections), {
+              Representation: (0, import_vinyl_xml3.elements)(__spreadProps(__spreadValues({}, withProtections), {
+                SubRepresentation: (0, import_vinyl_xml3.elements)(
+                  withProtections
+                )
+              }))
+            }))
+          },
+          {
+            minOccurs: 1
+          }
+        )
+      },
+      { required: true, namespaceUri: dashNamespaceUri }
+    )
+  };
+}
+
+// src/manifest/ext/drm/playreadyXmlRules.ts
+var import_vinyl_xml4 = require("@amazon/vinyl-xml");
+var playreadyXmlRules = {
+  pro: /* @__PURE__ */ (0, import_vinyl_xml4.element)(
+    {
+      _content: import_vinyl_xml4.charactersString
+    },
+    {
+      namespaceUri: PLAY_READY_NAMESPACE_URI
+    }
+  )
+};
+
+// src/manifest/dashParser.ts
+var dashDrmRules = /* @__PURE__ */ (0, import_vinyl_xml5.mergeXmlRules)(
+  /* @__PURE__ */ dashManifestXmlRules(),
+  /* @__PURE__ */ createDashProtectionXmlRules(cencXmlRules),
+  /* @__PURE__ */ createDashProtectionXmlRules(playreadyXmlRules)
+);
+var dashDrmRulesMapped = /* @__PURE__ */ (0, import_vinyl_xml5.mapXmlRules)(dashDrmRules);
+function dashManifestHandler() {
+  return new import_vinyl_xml5.ParseXmlHandlerImpl(dashDrmRulesMapped);
+}
+function parseDashManifest(manifest) {
+  return (0, import_vinyl_xml5.parseXml)(manifest, dashManifestHandler());
+}
+function stringifyDashManifest(manifest) {
+  return (0, import_vinyl_xml5.stringifyXml)(manifest, dashDrmRulesMapped);
+}
+
+// src/manifest/ext/drm/ContentProtectionScheme.ts
+var ContentProtectionScheme = {
+  /**
+   * CENC protection scheme. (Should not be used to create a key session)
+   */
+  CENC: "urn:mpeg:dash:mp4protection:2011",
+  /**
+   * A simple, unencrypted content protection scheme. Not a full DRM solution.
+   */
+  CLEAR_KEY: "urn:uuid:e2719d58-a985-b3c9-781a-b030af78d30e",
+  /**
+   * Apple's FairPlay.
+   */
+  FAIR_PLAY: "urn:uuid:94ce86fb-07ff-4f43-adb8-93d2fa968ca2",
+  /**
+   * Open-standards community initiative by Marlin Developer Community.
+   */
+  MARLIN: "urn:uuid:5e629af5-38da-4063-8977-97ffbd9902d4",
+  /**
+   * Microsoft's PlayReady.
+   */
+  PLAY_READY: "urn:uuid:9a04f079-9840-4286-ab92-e65be0885f95",
+  /**
+   * An old, unused PlayReady scheme id.
+   */
+  PLAY_READY_DEPRECATED: "urn:uuid:79f0049a-4098-8642-ab92-e65be0885f95",
+  /**
+   * Google's Widevine.
+   */
+  WIDEVINE: "urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed"
+};
+//# sourceMappingURL=index.cjs.map