First release

node_modules/mpd-parser/src/errors.js

@@ -0,0 +1,9 @@
+export default {
+  INVALID_NUMBER_OF_PERIOD: 'INVALID_NUMBER_OF_PERIOD',
+  DASH_EMPTY_MANIFEST: 'DASH_EMPTY_MANIFEST',
+  DASH_INVALID_XML: 'DASH_INVALID_XML',
+  NO_BASE_URL: 'NO_BASE_URL',
+  MISSING_SEGMENT_INFORMATION: 'MISSING_SEGMENT_INFORMATION',
+  SEGMENT_TIME_UNSPECIFIED: 'SEGMENT_TIME_UNSPECIFIED',
+  UNSUPPORTED_UTC_TIMING_SCHEME: 'UNSUPPORTED_UTC_TIMING_SCHEME'
+};

node_modules/mpd-parser/src/index.js

@@ -0,0 +1,39 @@
+import { version } from '../package.json';
+import { toM3u8, generateSidxKey } from './toM3u8';
+import { toPlaylists } from './toPlaylists';
+import { inheritAttributes } from './inheritAttributes';
+import { stringToMpdXml } from './stringToMpdXml';
+import { parseUTCTimingScheme } from './parseUTCTimingScheme';
+import {addSidxSegmentsToPlaylist} from './segment/segmentBase.js';
+
+const VERSION = version;
+
+const parse = (manifestString, options = {}) => {
+  const parsedManifestInfo = inheritAttributes(stringToMpdXml(manifestString), options);
+  const playlists = toPlaylists(parsedManifestInfo.representationInfo);
+
+  return toM3u8(playlists, parsedManifestInfo.locations, options.sidxMapping);
+};
+
+/**
+ * Parses the manifest for a UTCTiming node, returning the nodes attributes if found
+ *
+ * @param {string} manifestString
+ *        XML string of the MPD manifest
+ * @return {Object|null}
+ *         Attributes of UTCTiming node specified in the manifest. Null if none found
+ */
+const parseUTCTiming = (manifestString) =>
+  parseUTCTimingScheme(stringToMpdXml(manifestString));
+
+export {
+  VERSION,
+  parse,
+  parseUTCTiming,
+  stringToMpdXml,
+  inheritAttributes,
+  toPlaylists,
+  toM3u8,
+  addSidxSegmentsToPlaylist,
+  generateSidxKey
+};

node_modules/mpd-parser/src/inheritAttributes.js

@@ -0,0 +1,436 @@
+import window from 'global/window';
+import { flatten } from './utils/list';
+import { merge } from './utils/object';
+import { findChildren, getContent } from './utils/xml';
+import { parseAttributes } from './parseAttributes';
+import errors from './errors';
+import resolveUrl from '@videojs/vhs-utils/es/resolve-url';
+import decodeB64ToUint8Array from '@videojs/vhs-utils/es/decode-b64-to-uint8-array';
+
+const keySystemsMap = {
+  'urn:uuid:1077efec-c0b2-4d02-ace3-3c1e52e2fb4b': 'org.w3.clearkey',
+  'urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed': 'com.widevine.alpha',
+  'urn:uuid:9a04f079-9840-4286-ab92-e65be0885f95': 'com.microsoft.playready',
+  'urn:uuid:f239e769-efa3-4850-9c16-a903c6932efb': 'com.adobe.primetime'
+};
+
+/**
+ * Builds a list of urls that is the product of the reference urls and BaseURL values
+ *
+ * @param {string[]} referenceUrls
+ *        List of reference urls to resolve to
+ * @param {Node[]} baseUrlElements
+ *        List of BaseURL nodes from the mpd
+ * @return {string[]}
+ *         List of resolved urls
+ */
+export const buildBaseUrls = (referenceUrls, baseUrlElements) => {
+  if (!baseUrlElements.length) {
+    return referenceUrls;
+  }
+
+  return flatten(referenceUrls.map(function(reference) {
+    return baseUrlElements.map(function(baseUrlElement) {
+      return resolveUrl(reference, getContent(baseUrlElement));
+    });
+  }));
+};
+
+/**
+ * Contains all Segment information for its containing AdaptationSet
+ *
+ * @typedef {Object} SegmentInformation
+ * @property {Object|undefined} template
+ *           Contains the attributes for the SegmentTemplate node
+ * @property {Object[]|undefined} timeline
+ *           Contains a list of atrributes for each S node within the SegmentTimeline node
+ * @property {Object|undefined} list
+ *           Contains the attributes for the SegmentList node
+ * @property {Object|undefined} base
+ *           Contains the attributes for the SegmentBase node
+ */
+
+/**
+ * Returns all available Segment information contained within the AdaptationSet node
+ *
+ * @param {Node} adaptationSet
+ *        The AdaptationSet node to get Segment information from
+ * @return {SegmentInformation}
+ *         The Segment information contained within the provided AdaptationSet
+ */
+export const getSegmentInformation = (adaptationSet) => {
+  const segmentTemplate = findChildren(adaptationSet, 'SegmentTemplate')[0];
+  const segmentList = findChildren(adaptationSet, 'SegmentList')[0];
+  const segmentUrls = segmentList && findChildren(segmentList, 'SegmentURL')
+    .map(s => merge({ tag: 'SegmentURL' }, parseAttributes(s)));
+  const segmentBase = findChildren(adaptationSet, 'SegmentBase')[0];
+  const segmentTimelineParentNode = segmentList || segmentTemplate;
+  const segmentTimeline = segmentTimelineParentNode &&
+    findChildren(segmentTimelineParentNode, 'SegmentTimeline')[0];
+  const segmentInitializationParentNode = segmentList || segmentBase || segmentTemplate;
+  const segmentInitialization = segmentInitializationParentNode &&
+    findChildren(segmentInitializationParentNode, 'Initialization')[0];
+
+  // SegmentTemplate is handled slightly differently, since it can have both
+  // @initialization and an <Initialization> node.  @initialization can be templated,
+  // while the node can have a url and range specified.  If the <SegmentTemplate> has
+  // both @initialization and an <Initialization> subelement we opt to override with
+  // the node, as this interaction is not defined in the spec.
+  const template = segmentTemplate && parseAttributes(segmentTemplate);
+
+  if (template && segmentInitialization) {
+    template.initialization =
+      (segmentInitialization && parseAttributes(segmentInitialization));
+  } else if (template && template.initialization) {
+    // If it is @initialization we convert it to an object since this is the format that
+    // later functions will rely on for the initialization segment.  This is only valid
+    // for <SegmentTemplate>
+    template.initialization = { sourceURL: template.initialization };
+  }
+
+  const segmentInfo = {
+    template,
+    timeline: segmentTimeline &&
+      findChildren(segmentTimeline, 'S').map(s => parseAttributes(s)),
+    list: segmentList && merge(
+      parseAttributes(segmentList),
+      {
+        segmentUrls,
+        initialization: parseAttributes(segmentInitialization)
+      }
+    ),
+    base: segmentBase && merge(parseAttributes(segmentBase), {
+      initialization: parseAttributes(segmentInitialization)
+    })
+  };
+
+  Object.keys(segmentInfo).forEach(key => {
+    if (!segmentInfo[key]) {
+      delete segmentInfo[key];
+    }
+  });
+
+  return segmentInfo;
+};
+
+/**
+ * Contains Segment information and attributes needed to construct a Playlist object
+ * from a Representation
+ *
+ * @typedef {Object} RepresentationInformation
+ * @property {SegmentInformation} segmentInfo
+ *           Segment information for this Representation
+ * @property {Object} attributes
+ *           Inherited attributes for this Representation
+ */
+
+/**
+ * Maps a Representation node to an object containing Segment information and attributes
+ *
+ * @name inheritBaseUrlsCallback
+ * @function
+ * @param {Node} representation
+ *        Representation node from the mpd
+ * @return {RepresentationInformation}
+ *         Representation information needed to construct a Playlist object
+ */
+
+/**
+ * Returns a callback for Array.prototype.map for mapping Representation nodes to
+ * Segment information and attributes using inherited BaseURL nodes.
+ *
+ * @param {Object} adaptationSetAttributes
+ *        Contains attributes inherited by the AdaptationSet
+ * @param {string[]} adaptationSetBaseUrls
+ *        Contains list of resolved base urls inherited by the AdaptationSet
+ * @param {SegmentInformation} adaptationSetSegmentInfo
+ *        Contains Segment information for the AdaptationSet
+ * @return {inheritBaseUrlsCallback}
+ *         Callback map function
+ */
+export const inheritBaseUrls =
+(adaptationSetAttributes, adaptationSetBaseUrls, adaptationSetSegmentInfo) =>
+  (representation) => {
+    const repBaseUrlElements = findChildren(representation, 'BaseURL');
+    const repBaseUrls = buildBaseUrls(adaptationSetBaseUrls, repBaseUrlElements);
+    const attributes = merge(adaptationSetAttributes, parseAttributes(representation));
+    const representationSegmentInfo = getSegmentInformation(representation);
+
+    return repBaseUrls.map(baseUrl => {
+      return {
+        segmentInfo: merge(adaptationSetSegmentInfo, representationSegmentInfo),
+        attributes: merge(attributes, { baseUrl })
+      };
+    });
+  };
+
+/**
+ * Tranforms a series of content protection nodes to
+ * an object containing pssh data by key system
+ *
+ * @param {Node[]} contentProtectionNodes
+ *        Content protection nodes
+ * @return {Object}
+ *        Object containing pssh data by key system
+ */
+const generateKeySystemInformation = (contentProtectionNodes) => {
+  return contentProtectionNodes.reduce((acc, node) => {
+    const attributes = parseAttributes(node);
+    const keySystem = keySystemsMap[attributes.schemeIdUri];
+
+    if (keySystem) {
+      acc[keySystem] = { attributes };
+
+      const psshNode = findChildren(node, 'cenc:pssh')[0];
+
+      if (psshNode) {
+        const pssh = getContent(psshNode);
+        const psshBuffer = pssh && decodeB64ToUint8Array(pssh);
+
+        acc[keySystem].pssh = psshBuffer;
+      }
+    }
+
+    return acc;
+  }, {});
+};
+
+// defined in ANSI_SCTE 214-1 2016
+export const parseCaptionServiceMetadata = (service) => {
+  // 608 captions
+  if (service.schemeIdUri === 'urn:scte:dash:cc:cea-608:2015') {
+    const values = service.value.split(';');
+
+    return values.map((value) => {
+      let channel;
+      let language;
+
+      // default language to value
+      language = value;
+
+      if (/^CC\d=/.test(value)) {
+        [channel, language] = value.split('=');
+      } else if (/^CC\d$/.test(value)) {
+        channel = value;
+      }
+
+      return {channel, language};
+    });
+  } else if (service.schemeIdUri === 'urn:scte:dash:cc:cea-708:2015') {
+    const values = service.value.split(';');
+
+    return values.map((value) => {
+      const flags = {
+        // service or channel number 1-63
+        'channel': undefined,
+
+        // language is a 3ALPHA per ISO 639.2/B
+        // field is required
+        'language': undefined,
+
+        // BIT 1/0 or ?
+        // default value is 1, meaning 16:9 aspect ratio, 0 is 4:3, ? is unknown
+        'aspectRatio': 1,
+
+        // BIT 1/0
+        // easy reader flag indicated the text is tailed to the needs of beginning readers
+        // default 0, or off
+        'easyReader': 0,
+
+        // BIT 1/0
+        // If 3d metadata is present (CEA-708.1) then 1
+        // default 0
+        '3D': 0
+      };
+
+      if (/=/.test(value)) {
+
+        const [channel, opts = ''] = value.split('=');
+
+        flags.channel = channel;
+        flags.language = value;
+
+        opts.split(',').forEach((opt) => {
+          const [name, val] = opt.split(':');
+
+          if (name === 'lang') {
+            flags.language = val;
+
+          // er for easyReadery
+          } else if (name === 'er') {
+            flags.easyReader = Number(val);
+
+          // war for wide aspect ratio
+          } else if (name === 'war') {
+            flags.aspectRatio = Number(val);
+
+          } else if (name === '3D') {
+            flags['3D'] = Number(val);
+          }
+        });
+      } else {
+        flags.language = value;
+      }
+
+      if (flags.channel) {
+        flags.channel = 'SERVICE' + flags.channel;
+      }
+
+      return flags;
+    });
+  }
+};
+
+/**
+ * Maps an AdaptationSet node to a list of Representation information objects
+ *
+ * @name toRepresentationsCallback
+ * @function
+ * @param {Node} adaptationSet
+ *        AdaptationSet node from the mpd
+ * @return {RepresentationInformation[]}
+ *         List of objects containing Representaion information
+ */
+
+/**
+ * Returns a callback for Array.prototype.map for mapping AdaptationSet nodes to a list of
+ * Representation information objects
+ *
+ * @param {Object} periodAttributes
+ *        Contains attributes inherited by the Period
+ * @param {string[]} periodBaseUrls
+ *        Contains list of resolved base urls inherited by the Period
+ * @param {string[]} periodSegmentInfo
+ *        Contains Segment Information at the period level
+ * @return {toRepresentationsCallback}
+ *         Callback map function
+ */
+export const toRepresentations =
+(periodAttributes, periodBaseUrls, periodSegmentInfo) => (adaptationSet) => {
+  const adaptationSetAttributes = parseAttributes(adaptationSet);
+  const adaptationSetBaseUrls = buildBaseUrls(
+    periodBaseUrls,
+    findChildren(adaptationSet, 'BaseURL')
+  );
+  const role = findChildren(adaptationSet, 'Role')[0];
+  const roleAttributes = { role: parseAttributes(role) };
+
+  let attrs = merge(
+    periodAttributes,
+    adaptationSetAttributes,
+    roleAttributes,
+  );
+
+  const accessibility = findChildren(adaptationSet, 'Accessibility')[0];
+  const captionServices = parseCaptionServiceMetadata(parseAttributes(accessibility));
+
+  if (captionServices) {
+    attrs = merge(attrs, { captionServices });
+  }
+
+  const label = findChildren(adaptationSet, 'Label')[0];
+
+  if (label && label.childNodes.length) {
+    const labelVal = label.childNodes[0].nodeValue.trim();
+
+    attrs = merge(attrs, { label: labelVal });
+  }
+
+  const contentProtection = generateKeySystemInformation(findChildren(adaptationSet, 'ContentProtection'));
+
+  if (Object.keys(contentProtection).length) {
+    attrs = merge(attrs, { contentProtection });
+  }
+
+  const segmentInfo = getSegmentInformation(adaptationSet);
+  const representations = findChildren(adaptationSet, 'Representation');
+  const adaptationSetSegmentInfo = merge(periodSegmentInfo, segmentInfo);
+
+  return flatten(representations.map(inheritBaseUrls(attrs, adaptationSetBaseUrls, adaptationSetSegmentInfo)));
+};
+
+/**
+ * Maps an Period node to a list of Representation inforamtion objects for all
+ * AdaptationSet nodes contained within the Period
+ *
+ * @name toAdaptationSetsCallback
+ * @function
+ * @param {Node} period
+ *        Period node from the mpd
+ * @param {number} periodIndex
+ *        Index of the Period within the mpd
+ * @return {RepresentationInformation[]}
+ *         List of objects containing Representaion information
+ */
+
+/**
+ * Returns a callback for Array.prototype.map for mapping Period nodes to a list of
+ * Representation information objects
+ *
+ * @param {Object} mpdAttributes
+ *        Contains attributes inherited by the mpd
+ * @param {string[]} mpdBaseUrls
+ *        Contains list of resolved base urls inherited by the mpd
+ * @return {toAdaptationSetsCallback}
+ *         Callback map function
+ */
+export const toAdaptationSets = (mpdAttributes, mpdBaseUrls) => (period, index) => {
+  const periodBaseUrls = buildBaseUrls(mpdBaseUrls, findChildren(period, 'BaseURL'));
+  const periodAtt = parseAttributes(period);
+  const parsedPeriodId = parseInt(periodAtt.id, 10);
+  // fallback to mapping index if Period@id is not a number
+  const periodIndex = window.isNaN(parsedPeriodId) ? index : parsedPeriodId;
+  const periodAttributes = merge(mpdAttributes, { periodIndex });
+  const adaptationSets = findChildren(period, 'AdaptationSet');
+  const periodSegmentInfo = getSegmentInformation(period);
+
+  return flatten(adaptationSets.map(toRepresentations(periodAttributes, periodBaseUrls, periodSegmentInfo)));
+};
+
+/**
+ * Traverses the mpd xml tree to generate a list of Representation information objects
+ * that have inherited attributes from parent nodes
+ *
+ * @param {Node} mpd
+ *        The root node of the mpd
+ * @param {Object} options
+ *        Available options for inheritAttributes
+ * @param {string} options.manifestUri
+ *        The uri source of the mpd
+ * @param {number} options.NOW
+ *        Current time per DASH IOP.  Default is current time in ms since epoch
+ * @param {number} options.clientOffset
+ *        Client time difference from NOW (in milliseconds)
+ * @return {RepresentationInformation[]}
+ *         List of objects containing Representation information
+ */
+export const inheritAttributes = (mpd, options = {}) => {
+  const {
+    manifestUri = '',
+    NOW = Date.now(),
+    clientOffset = 0
+  } = options;
+  const periods = findChildren(mpd, 'Period');
+
+  if (!periods.length) {
+    throw new Error(errors.INVALID_NUMBER_OF_PERIOD);
+  }
+
+  const locations = findChildren(mpd, 'Location');
+
+  const mpdAttributes = parseAttributes(mpd);
+  const mpdBaseUrls = buildBaseUrls([ manifestUri ], findChildren(mpd, 'BaseURL'));
+
+  mpdAttributes.sourceDuration = mpdAttributes.mediaPresentationDuration || 0;
+  mpdAttributes.NOW = NOW;
+  mpdAttributes.clientOffset = clientOffset;
+
+  if (locations.length) {
+    mpdAttributes.locations = locations.map(getContent);
+  }
+
+  return {
+    locations: mpdAttributes.locations,
+    representationInfo: flatten(periods.map(toAdaptationSets(mpdAttributes, mpdBaseUrls)))
+  };
+};

node_modules/mpd-parser/src/parseAttributes.js

@@ -0,0 +1,267 @@
+import { from } from './utils/list';
+import { parseDuration, parseDate } from './utils/time';
+
+// TODO: maybe order these in some way that makes it easy to find specific attributes
+export const parsers = {
+  /**
+   * Specifies the duration of the entire Media Presentation. Format is a duration string
+   * as specified in ISO 8601
+   *
+   * @param {string} value
+   *        value of attribute as a string
+   * @return {number}
+   *         The duration in seconds
+   */
+  mediaPresentationDuration(value) {
+    return parseDuration(value);
+  },
+
+  /**
+   * Specifies the Segment availability start time for all Segments referred to in this
+   * MPD. For a dynamic manifest, it specifies the anchor for the earliest availability
+   * time. Format is a date string as specified in ISO 8601
+   *
+   * @param {string} value
+   *        value of attribute as a string
+   * @return {number}
+   *         The date as seconds from unix epoch
+   */
+  availabilityStartTime(value) {
+    return parseDate(value) / 1000;
+  },
+
+  /**
+   * Specifies the smallest period between potential changes to the MPD. Format is a
+   * duration string as specified in ISO 8601
+   *
+   * @param {string} value
+   *        value of attribute as a string
+   * @return {number}
+   *         The duration in seconds
+   */
+  minimumUpdatePeriod(value) {
+    return parseDuration(value);
+  },
+
+  /**
+   * Specifies the suggested presentation delay. Format is a
+   * duration string as specified in ISO 8601
+   *
+   * @param {string} value
+   *        value of attribute as a string
+   * @return {number}
+   *         The duration in seconds
+   */
+  suggestedPresentationDelay(value) {
+    return parseDuration(value);
+  },
+
+  /**
+   * specifices the type of mpd. Can be either "static" or "dynamic"
+   *
+   * @param {string} value
+   *        value of attribute as a string
+   *
+   * @return {string}
+   *         The type as a string
+   */
+  type(value) {
+    return value;
+  },
+
+  /**
+   * Specifies the duration of the smallest time shifting buffer for any Representation
+   * in the MPD. Format is a duration string as specified in ISO 8601
+   *
+   * @param {string} value
+   *        value of attribute as a string
+   * @return {number}
+   *         The duration in seconds
+   */
+  timeShiftBufferDepth(value) {
+    return parseDuration(value);
+  },
+
+  /**
+   * Specifies the PeriodStart time of the Period relative to the availabilityStarttime.
+   * Format is a duration string as specified in ISO 8601
+   *
+   * @param {string} value
+   *        value of attribute as a string
+   * @return {number}
+   *         The duration in seconds
+   */
+  start(value) {
+    return parseDuration(value);
+  },
+
+  /**
+   * Specifies the width of the visual presentation
+   *
+   * @param {string} value
+   *        value of attribute as a string
+   * @return {number}
+   *         The parsed width
+   */
+  width(value) {
+    return parseInt(value, 10);
+  },
+
+  /**
+   * Specifies the height of the visual presentation
+   *
+   * @param {string} value
+   *        value of attribute as a string
+   * @return {number}
+   *         The parsed height
+   */
+  height(value) {
+    return parseInt(value, 10);
+  },
+
+  /**
+   * Specifies the bitrate of the representation
+   *
+   * @param {string} value
+   *        value of attribute as a string
+   * @return {number}
+   *         The parsed bandwidth
+   */
+  bandwidth(value) {
+    return parseInt(value, 10);
+  },
+
+  /**
+   * Specifies the number of the first Media Segment in this Representation in the Period
+   *
+   * @param {string} value
+   *        value of attribute as a string
+   * @return {number}
+   *         The parsed number
+   */
+  startNumber(value) {
+    return parseInt(value, 10);
+  },
+
+  /**
+   * Specifies the timescale in units per seconds
+   *
+   * @param {string} value
+   *        value of attribute as a string
+   * @return {number}
+   *         The parsed timescale
+   */
+  timescale(value) {
+    return parseInt(value, 10);
+  },
+
+  /**
+   * Specifies the presentationTimeOffset.
+   *
+   * @param {string} value
+   *        value of the attribute as a string
+   *
+   * @return {number}
+   *         The parsed presentationTimeOffset
+   */
+  presentationTimeOffset(value) {
+    return parseInt(value, 10);
+  },
+
+  /**
+   * Specifies the constant approximate Segment duration
+   * NOTE: The <Period> element also contains an @duration attribute. This duration
+   *       specifies the duration of the Period. This attribute is currently not
+   *       supported by the rest of the parser, however we still check for it to prevent
+   *       errors.
+   *
+   * @param {string} value
+   *        value of attribute as a string
+   * @return {number}
+   *         The parsed duration
+   */
+  duration(value) {
+    const parsedValue = parseInt(value, 10);
+
+    if (isNaN(parsedValue)) {
+      return parseDuration(value);
+    }
+
+    return parsedValue;
+  },
+
+  /**
+   * Specifies the Segment duration, in units of the value of the @timescale.
+   *
+   * @param {string} value
+   *        value of attribute as a string
+   * @return {number}
+   *         The parsed duration
+   */
+  d(value) {
+    return parseInt(value, 10);
+  },
+
+  /**
+   * Specifies the MPD start time, in @timescale units, the first Segment in the series
+   * starts relative to the beginning of the Period
+   *
+   * @param {string} value
+   *        value of attribute as a string
+   * @return {number}
+   *         The parsed time
+   */
+  t(value) {
+    return parseInt(value, 10);
+  },
+
+  /**
+   * Specifies the repeat count of the number of following contiguous Segments with the
+   * same duration expressed by the value of @d
+   *
+   * @param {string} value
+   *        value of attribute as a string
+   * @return {number}
+   *         The parsed number
+   */
+  r(value) {
+    return parseInt(value, 10);
+  },
+
+  /**
+   * Default parser for all other attributes. Acts as a no-op and just returns the value
+   * as a string
+   *
+   * @param {string} value
+   *        value of attribute as a string
+   * @return {string}
+   *         Unparsed value
+   */
+  DEFAULT(value) {
+    return value;
+  }
+};
+
+/**
+ * Gets all the attributes and values of the provided node, parses attributes with known
+ * types, and returns an object with attribute names mapped to values.
+ *
+ * @param {Node} el
+ *        The node to parse attributes from
+ * @return {Object}
+ *         Object with all attributes of el parsed
+ */
+export const parseAttributes = (el) => {
+  if (!(el && el.attributes)) {
+    return {};
+  }
+
+  return from(el.attributes)
+    .reduce((a, e) => {
+      const parseFn = parsers[e.name] || parsers.DEFAULT;
+
+      a[e.name] = parseFn(e.value);
+
+      return a;
+    }, {});
+};

node_modules/mpd-parser/src/parseUTCTimingScheme.js

@@ -0,0 +1,46 @@
+import { findChildren } from './utils/xml';
+import { parseAttributes } from './parseAttributes';
+import errors from './errors';
+
+/**
+ * Parses the manifest for a UTCTiming node, returning the nodes attributes if found
+ *
+ * @param {string} mpd
+ *        XML string of the MPD manifest
+ * @return {Object|null}
+ *         Attributes of UTCTiming node specified in the manifest. Null if none found
+ */
+export const parseUTCTimingScheme = (mpd) => {
+  const UTCTimingNode = findChildren(mpd, 'UTCTiming')[0];
+
+  if (!UTCTimingNode) {
+    return null;
+  }
+
+  const attributes = parseAttributes(UTCTimingNode);
+
+  switch (attributes.schemeIdUri) {
+  case 'urn:mpeg:dash:utc:http-head:2014':
+  case 'urn:mpeg:dash:utc:http-head:2012':
+    attributes.method = 'HEAD';
+    break;
+  case 'urn:mpeg:dash:utc:http-xsdate:2014':
+  case 'urn:mpeg:dash:utc:http-iso:2014':
+  case 'urn:mpeg:dash:utc:http-xsdate:2012':
+  case 'urn:mpeg:dash:utc:http-iso:2012':
+    attributes.method = 'GET';
+    break;
+  case 'urn:mpeg:dash:utc:direct:2014':
+  case 'urn:mpeg:dash:utc:direct:2012':
+    attributes.method = 'DIRECT';
+    attributes.value = Date.parse(attributes.value);
+    break;
+  case 'urn:mpeg:dash:utc:http-ntp:2014':
+  case 'urn:mpeg:dash:utc:ntp:2014':
+  case 'urn:mpeg:dash:utc:sntp:2014':
+  default:
+    throw new Error(errors.UNSUPPORTED_UTC_TIMING_SCHEME);
+  }
+
+  return attributes;
+};

node_modules/mpd-parser/src/segment/durationTimeParser.js

@@ -0,0 +1,156 @@
+import { range } from '../utils/list';
+
+/**
+ * parse the end number attribue that can be a string
+ * number, or undefined.
+ *
+ * @param {string|number|undefined} endNumber
+ *        The end number attribute.
+ *
+ * @return {number|null}
+ *          The result of parsing the end number.
+ */
+const parseEndNumber = (endNumber) => {
+  if (endNumber && typeof endNumber !== 'number') {
+    endNumber = parseInt(endNumber, 10);
+  }
+
+  if (isNaN(endNumber)) {
+    return null;
+  }
+
+  return endNumber;
+};
+
+/**
+ * Functions for calculating the range of available segments in static and dynamic
+ * manifests.
+ */
+export const segmentRange = {
+  /**
+   * Returns the entire range of available segments for a static MPD
+   *
+   * @param {Object} attributes
+   *        Inheritied MPD attributes
+   * @return {{ start: number, end: number }}
+   *         The start and end numbers for available segments
+   */
+  static(attributes) {
+    const {
+      duration,
+      timescale = 1,
+      sourceDuration
+    } = attributes;
+    const endNumber = parseEndNumber(attributes.endNumber);
+
+    return {
+      start: 0,
+      end: typeof endNumber === 'number' ? endNumber : Math.ceil(sourceDuration / (duration / timescale))
+    };
+  },
+
+  /**
+   * Returns the current live window range of available segments for a dynamic MPD
+   *
+   * @param {Object} attributes
+   *        Inheritied MPD attributes
+   * @return {{ start: number, end: number }}
+   *         The start and end numbers for available segments
+   */
+  dynamic(attributes) {
+    const {
+      NOW,
+      clientOffset,
+      availabilityStartTime,
+      timescale = 1,
+      duration,
+      start = 0,
+      minimumUpdatePeriod = 0,
+      timeShiftBufferDepth = Infinity
+    } = attributes;
+    const endNumber = parseEndNumber(attributes.endNumber);
+    const now = (NOW + clientOffset) / 1000;
+    const periodStartWC = availabilityStartTime + start;
+    const periodEndWC = now + minimumUpdatePeriod;
+    const periodDuration = periodEndWC - periodStartWC;
+    const segmentCount = Math.ceil(periodDuration * timescale / duration);
+    const availableStart =
+      Math.floor((now - periodStartWC - timeShiftBufferDepth) * timescale / duration);
+    const availableEnd = Math.floor((now - periodStartWC) * timescale / duration);
+
+    return {
+      start: Math.max(0, availableStart),
+      end: typeof endNumber === 'number' ? endNumber : Math.min(segmentCount, availableEnd)
+    };
+  }
+};
+
+/**
+ * Maps a range of numbers to objects with information needed to build the corresponding
+ * segment list
+ *
+ * @name toSegmentsCallback
+ * @function
+ * @param {number} number
+ *        Number of the segment
+ * @param {number} index
+ *        Index of the number in the range list
+ * @return {{ number: Number, duration: Number, timeline: Number, time: Number }}
+ *         Object with segment timing and duration info
+ */
+
+/**
+ * Returns a callback for Array.prototype.map for mapping a range of numbers to
+ * information needed to build the segment list.
+ *
+ * @param {Object} attributes
+ *        Inherited MPD attributes
+ * @return {toSegmentsCallback}
+ *         Callback map function
+ */
+export const toSegments = (attributes) => (number, index) => {
+  const {
+    duration,
+    timescale = 1,
+    periodIndex,
+    startNumber = 1
+  } = attributes;
+
+  return {
+    number: startNumber + number,
+    duration: duration / timescale,
+    timeline: periodIndex,
+    time: index * duration
+  };
+};
+
+/**
+ * Returns a list of objects containing segment timing and duration info used for
+ * building the list of segments. This uses the @duration attribute specified
+ * in the MPD manifest to derive the range of segments.
+ *
+ * @param {Object} attributes
+ *        Inherited MPD attributes
+ * @return {{number: number, duration: number, time: number, timeline: number}[]}
+ *         List of Objects with segment timing and duration info
+ */
+export const parseByDuration = (attributes) => {
+  const {
+    type = 'static',
+    duration,
+    timescale = 1,
+    sourceDuration
+  } = attributes;
+
+  const { start, end } = segmentRange[type](attributes);
+  const segments = range(start, end).map(toSegments(attributes));
+
+  if (type === 'static') {
+    const index = segments.length - 1;
+
+    // final segment may be less than full segment duration
+    segments[index].duration = sourceDuration - (duration / timescale * index);
+  }
+
+  return segments;
+};

node_modules/mpd-parser/src/segment/segmentBase.js

@@ -0,0 +1,123 @@
+import errors from '../errors';
+import urlTypeConverter from './urlType';
+import { parseByDuration } from './durationTimeParser';
+
+/**
+ * Translates SegmentBase into a set of segments.
+ * (DASH SPEC Section 5.3.9.3.2) contains a set of <SegmentURL> nodes.  Each
+ * node should be translated into segment.
+ *
+ * @param {Object} attributes
+ *   Object containing all inherited attributes from parent elements with attribute
+ *   names as keys
+ * @return {Object.<Array>} list of segments
+ */
+export const segmentsFromBase = (attributes) => {
+  const {
+    baseUrl,
+    initialization = {},
+    sourceDuration,
+    indexRange = '',
+    duration
+  } = attributes;
+
+  // base url is required for SegmentBase to work, per spec (Section 5.3.9.2.1)
+  if (!baseUrl) {
+    throw new Error(errors.NO_BASE_URL);
+  }
+
+  const initSegment = urlTypeConverter({
+    baseUrl,
+    source: initialization.sourceURL,
+    range: initialization.range
+  });
+
+  const segment = urlTypeConverter({ baseUrl, source: baseUrl, indexRange });
+
+  segment.map = initSegment;
+
+  // If there is a duration, use it, otherwise use the given duration of the source
+  // (since SegmentBase is only for one total segment)
+  if (duration) {
+    const segmentTimeInfo = parseByDuration(attributes);
+
+    if (segmentTimeInfo.length) {
+      segment.duration = segmentTimeInfo[0].duration;
+      segment.timeline = segmentTimeInfo[0].timeline;
+    }
+  } else if (sourceDuration) {
+    segment.duration = sourceDuration;
+    segment.timeline = 0;
+  }
+
+  // This is used for mediaSequence
+  segment.number = 0;
+
+  return [segment];
+};
+
+/**
+ * Given a playlist, a sidx box, and a baseUrl, update the segment list of the playlist
+ * according to the sidx information given.
+ *
+ * playlist.sidx has metadadata about the sidx where-as the sidx param
+ * is the parsed sidx box itself.
+ *
+ * @param {Object} playlist the playlist to update the sidx information for
+ * @param {Object} sidx the parsed sidx box
+ * @return {Object} the playlist object with the updated sidx information
+ */
+export const addSidxSegmentsToPlaylist = (playlist, sidx, baseUrl) => {
+  // Retain init segment information
+  const initSegment = playlist.sidx.map ? playlist.sidx.map : null;
+  // Retain source duration from initial master manifest parsing
+  const sourceDuration = playlist.sidx.duration;
+  // Retain source timeline
+  const timeline = playlist.timeline || 0;
+  const sidxByteRange = playlist.sidx.byterange;
+  const sidxEnd = sidxByteRange.offset + sidxByteRange.length;
+  // Retain timescale of the parsed sidx
+  const timescale = sidx.timescale;
+  // referenceType 1 refers to other sidx boxes
+  const mediaReferences = sidx.references.filter(r => r.referenceType !== 1);
+  const segments = [];
+
+  // firstOffset is the offset from the end of the sidx box
+  let startIndex = sidxEnd + sidx.firstOffset;
+
+  for (let i = 0; i < mediaReferences.length; i++) {
+    const reference = sidx.references[i];
+    // size of the referenced (sub)segment
+    const size = reference.referencedSize;
+    // duration of the referenced (sub)segment, in  the  timescale
+    // this will be converted to seconds when generating segments
+    const duration = reference.subsegmentDuration;
+    // should be an inclusive range
+    const endIndex = startIndex + size - 1;
+    const indexRange = `${startIndex}-${endIndex}`;
+
+    const attributes = {
+      baseUrl,
+      timescale,
+      timeline,
+      // this is used in parseByDuration
+      periodIndex: timeline,
+      duration,
+      sourceDuration,
+      indexRange
+    };
+
+    const segment = segmentsFromBase(attributes)[0];
+
+    if (initSegment) {
+      segment.map = initSegment;
+    }
+
+    segments.push(segment);
+    startIndex += size;
+  }
+
+  playlist.segments = segments;
+
+  return playlist;
+};

node_modules/mpd-parser/src/segment/segmentList.js

@@ -0,0 +1,90 @@
+import { parseByTimeline } from './timelineTimeParser';
+import { parseByDuration } from './durationTimeParser';
+import urlTypeConverter from './urlType';
+import errors from '../errors';
+
+/**
+ * Converts a <SegmentUrl> (of type URLType from the DASH spec 5.3.9.2 Table 14)
+ * to an object that matches the output of a segment in videojs/mpd-parser
+ *
+ * @param {Object} attributes
+ *   Object containing all inherited attributes from parent elements with attribute
+ *   names as keys
+ * @param {Object} segmentUrl
+ *   <SegmentURL> node to translate into a segment object
+ * @return {Object} translated segment object
+ */
+const SegmentURLToSegmentObject = (attributes, segmentUrl) => {
+  const { baseUrl, initialization = {} } = attributes;
+
+  const initSegment = urlTypeConverter({
+    baseUrl,
+    source: initialization.sourceURL,
+    range: initialization.range
+  });
+
+  const segment = urlTypeConverter({
+    baseUrl,
+    source: segmentUrl.media,
+    range: segmentUrl.mediaRange
+  });
+
+  segment.map = initSegment;
+
+  return segment;
+};
+
+/**
+ * Generates a list of segments using information provided by the SegmentList element
+ * SegmentList (DASH SPEC Section 5.3.9.3.2) contains a set of <SegmentURL> nodes.  Each
+ * node should be translated into segment.
+ *
+ * @param {Object} attributes
+ *   Object containing all inherited attributes from parent elements with attribute
+ *   names as keys
+ * @param {Object[]|undefined} segmentTimeline
+ *        List of objects representing the attributes of each S element contained within
+ *        the SegmentTimeline element
+ * @return {Object.<Array>} list of segments
+ */
+export const segmentsFromList = (attributes, segmentTimeline) => {
+  const {
+    duration,
+    segmentUrls = []
+  } = attributes;
+
+  // Per spec (5.3.9.2.1) no way to determine segment duration OR
+  // if both SegmentTimeline and @duration are defined, it is outside of spec.
+  if ((!duration && !segmentTimeline) ||
+      (duration && segmentTimeline)) {
+    throw new Error(errors.SEGMENT_TIME_UNSPECIFIED);
+  }
+
+  const segmentUrlMap = segmentUrls.map(segmentUrlObject =>
+    SegmentURLToSegmentObject(attributes, segmentUrlObject));
+  let segmentTimeInfo;
+
+  if (duration) {
+    segmentTimeInfo = parseByDuration(attributes);
+  }
+
+  if (segmentTimeline) {
+    segmentTimeInfo = parseByTimeline(attributes, segmentTimeline);
+  }
+
+  const segments = segmentTimeInfo.map((segmentTime, index) => {
+    if (segmentUrlMap[index]) {
+      const segment = segmentUrlMap[index];
+
+      segment.timeline = segmentTime.timeline;
+      segment.duration = segmentTime.duration;
+      segment.number = segmentTime.number;
+      return segment;
+    }
+    // Since we're mapping we should get rid of any blank segments (in case
+    // the given SegmentTimeline is handling for more elements than we have
+    // SegmentURLs for).
+  }).filter(segment => segment);
+
+  return segments;
+};

node_modules/mpd-parser/src/segment/segmentTemplate.js

@@ -0,0 +1,176 @@
+import resolveUrl from '@videojs/vhs-utils/es/resolve-url';
+import urlTypeToSegment from './urlType';
+import { parseByTimeline } from './timelineTimeParser';
+import { parseByDuration } from './durationTimeParser';
+
+const identifierPattern = /\$([A-z]*)(?:(%0)([0-9]+)d)?\$/g;
+
+/**
+ * Replaces template identifiers with corresponding values. To be used as the callback
+ * for String.prototype.replace
+ *
+ * @name replaceCallback
+ * @function
+ * @param {string} match
+ *        Entire match of identifier
+ * @param {string} identifier
+ *        Name of matched identifier
+ * @param {string} format
+ *        Format tag string. Its presence indicates that padding is expected
+ * @param {string} width
+ *        Desired length of the replaced value. Values less than this width shall be left
+ *        zero padded
+ * @return {string}
+ *         Replacement for the matched identifier
+ */
+
+/**
+ * Returns a function to be used as a callback for String.prototype.replace to replace
+ * template identifiers
+ *
+ * @param {Obect} values
+ *        Object containing values that shall be used to replace known identifiers
+ * @param {number} values.RepresentationID
+ *        Value of the Representation@id attribute
+ * @param {number} values.Number
+ *        Number of the corresponding segment
+ * @param {number} values.Bandwidth
+ *        Value of the Representation@bandwidth attribute.
+ * @param {number} values.Time
+ *        Timestamp value of the corresponding segment
+ * @return {replaceCallback}
+ *         Callback to be used with String.prototype.replace to replace identifiers
+ */
+export const identifierReplacement = (values) => (match, identifier, format, width) => {
+  if (match === '$$') {
+    // escape sequence
+    return '$';
+  }
+
+  if (typeof values[identifier] === 'undefined') {
+    return match;
+  }
+
+  const value = '' + values[identifier];
+
+  if (identifier === 'RepresentationID') {
+    // Format tag shall not be present with RepresentationID
+    return value;
+  }
+
+  if (!format) {
+    width = 1;
+  } else {
+    width = parseInt(width, 10);
+  }
+
+  if (value.length >= width) {
+    return value;
+  }
+
+  return `${(new Array(width - value.length + 1)).join('0')}${value}`;
+};
+
+/**
+ * Constructs a segment url from a template string
+ *
+ * @param {string} url
+ *        Template string to construct url from
+ * @param {Obect} values
+ *        Object containing values that shall be used to replace known identifiers
+ * @param {number} values.RepresentationID
+ *        Value of the Representation@id attribute
+ * @param {number} values.Number
+ *        Number of the corresponding segment
+ * @param {number} values.Bandwidth
+ *        Value of the Representation@bandwidth attribute.
+ * @param {number} values.Time
+ *        Timestamp value of the corresponding segment
+ * @return {string}
+ *         Segment url with identifiers replaced
+ */
+export const constructTemplateUrl = (url, values) =>
+  url.replace(identifierPattern, identifierReplacement(values));
+
+/**
+ * Generates a list of objects containing timing and duration information about each
+ * segment needed to generate segment uris and the complete segment object
+ *
+ * @param {Object} attributes
+ *        Object containing all inherited attributes from parent elements with attribute
+ *        names as keys
+ * @param {Object[]|undefined} segmentTimeline
+ *        List of objects representing the attributes of each S element contained within
+ *        the SegmentTimeline element
+ * @return {{number: number, duration: number, time: number, timeline: number}[]}
+ *         List of Objects with segment timing and duration info
+ */
+export const parseTemplateInfo = (attributes, segmentTimeline) => {
+  if (!attributes.duration && !segmentTimeline) {
+    // if neither @duration or SegmentTimeline are present, then there shall be exactly
+    // one media segment
+    return [{
+      number: attributes.startNumber || 1,
+      duration: attributes.sourceDuration,
+      time: 0,
+      timeline: attributes.periodIndex
+    }];
+  }
+
+  if (attributes.duration) {
+    return parseByDuration(attributes);
+  }
+
+  return parseByTimeline(attributes, segmentTimeline);
+};
+
+/**
+ * Generates a list of segments using information provided by the SegmentTemplate element
+ *
+ * @param {Object} attributes
+ *        Object containing all inherited attributes from parent elements with attribute
+ *        names as keys
+ * @param {Object[]|undefined} segmentTimeline
+ *        List of objects representing the attributes of each S element contained within
+ *        the SegmentTimeline element
+ * @return {Object[]}
+ *         List of segment objects
+ */
+export const segmentsFromTemplate = (attributes, segmentTimeline) => {
+  const templateValues = {
+    RepresentationID: attributes.id,
+    Bandwidth: attributes.bandwidth || 0
+  };
+
+  const { initialization = { sourceURL: '', range: '' } } = attributes;
+
+  const mapSegment = urlTypeToSegment({
+    baseUrl: attributes.baseUrl,
+    source: constructTemplateUrl(initialization.sourceURL, templateValues),
+    range: initialization.range
+  });
+
+  const segments = parseTemplateInfo(attributes, segmentTimeline);
+
+  return segments.map(segment => {
+    templateValues.Number = segment.number;
+    templateValues.Time = segment.time;
+
+    const uri = constructTemplateUrl(attributes.media || '', templateValues);
+
+    const map = {
+      uri,
+      timeline: segment.timeline,
+      duration: segment.duration,
+      resolvedUri: resolveUrl(attributes.baseUrl || '', uri),
+      map: mapSegment,
+      number: segment.number
+    };
+
+    if (attributes.presentationTimeOffset) {
+      map.presentationTimeOffset = attributes.presentationTimeOffset;
+    }
+
+    return map;
+  });
+};

node_modules/mpd-parser/src/segment/timelineTimeParser.js

@@ -0,0 +1,129 @@
+/**
+ * Calculates the R (repetition) value for a live stream (for the final segment
+ * in a manifest where the r value is negative 1)
+ *
+ * @param {Object} attributes
+ *        Object containing all inherited attributes from parent elements with attribute
+ *        names as keys
+ * @param {number} time
+ *        current time (typically the total time up until the final segment)
+ * @param {number} duration
+ *        duration property for the given <S />
+ *
+ * @return {number}
+ *        R value to reach the end of the given period
+ */
+const getLiveRValue = (attributes, time, duration) => {
+  const {
+    NOW,
+    clientOffset,
+    availabilityStartTime,
+    timescale = 1,
+    start = 0,
+    minimumUpdatePeriod = 0
+  } = attributes;
+  const now = (NOW + clientOffset) / 1000;
+  const periodStartWC = availabilityStartTime + start;
+  const periodEndWC = now + minimumUpdatePeriod;
+  const periodDuration = periodEndWC - periodStartWC;
+
+  return Math.ceil(((periodDuration * timescale) - time) / duration);
+};
+
+/**
+ * Uses information provided by SegmentTemplate.SegmentTimeline to determine segment
+ * timing and duration
+ *
+ * @param {Object} attributes
+ *        Object containing all inherited attributes from parent elements with attribute
+ *        names as keys
+ * @param {Object[]} segmentTimeline
+ *        List of objects representing the attributes of each S element contained within
+ *
+ * @return {{number: number, duration: number, time: number, timeline: number}[]}
+ *         List of Objects with segment timing and duration info
+ */
+export const parseByTimeline = (attributes, segmentTimeline) => {
+  const {
+    type = 'static',
+    minimumUpdatePeriod = 0,
+    media = '',
+    sourceDuration,
+    timescale = 1,
+    startNumber = 1,
+    periodIndex: timeline
+  } = attributes;
+  const segments = [];
+  let time = -1;
+
+  for (let sIndex = 0; sIndex < segmentTimeline.length; sIndex++) {
+    const S = segmentTimeline[sIndex];
+    const duration = S.d;
+    const repeat = S.r || 0;
+    const segmentTime = S.t || 0;
+
+    if (time < 0) {
+      // first segment
+      time = segmentTime;
+    }
+
+    if (segmentTime && segmentTime > time) {
+      // discontinuity
+
+      // TODO: How to handle this type of discontinuity
+      // timeline++ here would treat it like HLS discontuity and content would
+      // get appended without gap
+      // E.G.
+      //  <S t="0" d="1" />
+      //  <S d="1" />
+      //  <S d="1" />
+      //  <S t="5" d="1" />
+      // would have $Time$ values of [0, 1, 2, 5]
+      // should this be appened at time positions [0, 1, 2, 3],(#EXT-X-DISCONTINUITY)
+      // or [0, 1, 2, gap, gap, 5]? (#EXT-X-GAP)
+      // does the value of sourceDuration consider this when calculating arbitrary
+      // negative @r repeat value?
+      // E.G. Same elements as above with this added at the end
+      //  <S d="1" r="-1" />
+      //  with a sourceDuration of 10
+      // Would the 2 gaps be included in the time duration calculations resulting in
+      // 8 segments with $Time$ values of [0, 1, 2, 5, 6, 7, 8, 9] or 10 segments
+      // with $Time$ values of [0, 1, 2, 5, 6, 7, 8, 9, 10, 11] ?
+
+      time = segmentTime;
+    }
+
+    let count;
+
+    if (repeat < 0) {
+      const nextS = sIndex + 1;
+
+      if (nextS === segmentTimeline.length) {
+        // last segment
+        if (type === 'dynamic' &&
+            minimumUpdatePeriod > 0 &&
+            media.indexOf('$Number$') > 0) {
+          count = getLiveRValue(attributes, time, duration);
+        } else {
+          // TODO: This may be incorrect depending on conclusion of TODO above
+          count = ((sourceDuration * timescale) - time) / duration;
+        }
+      } else {
+        count = (segmentTimeline[nextS].t - time) / duration;
+      }
+    } else {
+      count = repeat + 1;
+    }
+
+    const end = startNumber + segments.length + count;
+    let number = startNumber + segments.length;
+
+    while (number < end) {
+      segments.push({ number, duration: duration / timescale, time, timeline });
+      time += duration;
+      number++;
+    }
+  }
+
+  return segments;
+};

node_modules/mpd-parser/src/segment/urlType.js

@@ -0,0 +1,59 @@
+import resolveUrl from '@videojs/vhs-utils/es/resolve-url';
+
+/**
+ * @typedef {Object} SingleUri
+ * @property {string} uri - relative location of segment
+ * @property {string} resolvedUri - resolved location of segment
+ * @property {Object} byterange - Object containing information on how to make byte range
+ *   requests following byte-range-spec per RFC2616.
+ * @property {String} byterange.length - length of range request
+ * @property {String} byterange.offset - byte offset of range request
+ *
+ * @see https://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.35.1
+ */
+
+/**
+ * Converts a URLType node (5.3.9.2.3 Table 13) to a segment object
+ * that conforms to how m3u8-parser is structured
+ *
+ * @see https://github.com/videojs/m3u8-parser
+ *
+ * @param {string} baseUrl - baseUrl provided by <BaseUrl> nodes
+ * @param {string} source - source url for segment
+ * @param {string} range - optional range used for range calls,
+ *   follows  RFC 2616, Clause 14.35.1
+ * @return {SingleUri} full segment information transformed into a format similar
+ *   to m3u8-parser
+ */
+export const urlTypeToSegment = ({ baseUrl = '', source = '', range = '', indexRange = '' }) => {
+  const segment = {
+    uri: source,
+    resolvedUri: resolveUrl(baseUrl || '', source)
+  };
+
+  if (range || indexRange) {
+    const rangeStr = range ? range : indexRange;
+    const ranges = rangeStr.split('-');
+    const startRange = parseInt(ranges[0], 10);
+    const endRange = parseInt(ranges[1], 10);
+
+    // byterange should be inclusive according to
+    // RFC 2616, Clause 14.35.1
+    segment.byterange = {
+      length: endRange - startRange + 1,
+      offset: startRange
+    };
+  }
+
+  return segment;
+};
+
+export const byteRangeToString = (byterange) => {
+  // `endRange` is one less than `offset + length` because the HTTP range
+  // header uses inclusive ranges
+  const endRange = byterange.offset + byterange.length - 1;
+
+  return `${byterange.offset}-${endRange}`;
+};
+
+export default urlTypeToSegment;

node_modules/mpd-parser/src/stringToMpdXml.js

@@ -0,0 +1,27 @@
+import {DOMParser} from 'xmldom';
+import errors from './errors';
+
+export const stringToMpdXml = (manifestString) => {
+  if (manifestString === '') {
+    throw new Error(errors.DASH_EMPTY_MANIFEST);
+  }
+
+  const parser = new DOMParser();
+  let xml;
+  let mpd;
+
+  try {
+    xml = parser.parseFromString(manifestString, 'application/xml');
+    mpd = xml && xml.documentElement.tagName === 'MPD' ?
+      xml.documentElement : null;
+  } catch (e) {
+    // ie 11 throwsw on invalid xml
+  }
+
+  if (!mpd || mpd &&
+      mpd.getElementsByTagName('parsererror').length > 0) {
+    throw new Error(errors.DASH_INVALID_XML);
+  }
+
+  return mpd;
+};

node_modules/mpd-parser/src/toM3u8.js

@@ -0,0 +1,339 @@
+import { values } from './utils/object';
+import { findIndexes } from './utils/list';
+import { addSidxSegmentsToPlaylist as addSidxSegmentsToPlaylist_ } from './segment/segmentBase';
+import { byteRangeToString } from './segment/urlType';
+
+export const generateSidxKey = (sidx) => sidx &&
+  sidx.uri + '-' + byteRangeToString(sidx.byterange);
+
+const mergeDiscontiguousPlaylists = playlists => {
+  const mergedPlaylists = values(playlists.reduce((acc, playlist) => {
+    // assuming playlist IDs are the same across periods
+    // TODO: handle multiperiod where representation sets are not the same
+    // across periods
+    const name = playlist.attributes.id + (playlist.attributes.lang || '');
+
+    // Periods after first
+    if (acc[name]) {
+      // first segment of subsequent periods signal a discontinuity
+      if (playlist.segments[0]) {
+        playlist.segments[0].discontinuity = true;
+      }
+      acc[name].segments.push(...playlist.segments);
+
+      // bubble up contentProtection, this assumes all DRM content
+      // has the same contentProtection
+      if (playlist.attributes.contentProtection) {
+        acc[name].attributes.contentProtection =
+          playlist.attributes.contentProtection;
+      }
+    } else {
+      // first Period
+      acc[name] = playlist;
+    }
+
+    return acc;
+  }, {}));
+
+  return mergedPlaylists.map(playlist => {
+    playlist.discontinuityStarts =
+        findIndexes(playlist.segments, 'discontinuity');
+
+    return playlist;
+  });
+};
+
+export const addSidxSegmentsToPlaylist = (playlist, sidxMapping) => {
+  const sidxKey = generateSidxKey(playlist.sidx);
+  const sidxMatch = sidxKey && sidxMapping[sidxKey] && sidxMapping[sidxKey].sidx;
+
+  if (sidxMatch) {
+    addSidxSegmentsToPlaylist_(playlist, sidxMatch, playlist.sidx.resolvedUri);
+  }
+
+  return playlist;
+};
+
+export const addSidxSegmentsToPlaylists = (playlists, sidxMapping = {}) => {
+  if (!Object.keys(sidxMapping).length) {
+    return playlists;
+  }
+
+  for (const i in playlists) {
+    playlists[i] = addSidxSegmentsToPlaylist(playlists[i], sidxMapping);
+  }
+
+  return playlists;
+};
+
+export const formatAudioPlaylist = ({ attributes, segments, sidx }, isAudioOnly) => {
+  const playlist = {
+    attributes: {
+      NAME: attributes.id,
+      BANDWIDTH: attributes.bandwidth,
+      CODECS: attributes.codecs,
+      ['PROGRAM-ID']: 1
+    },
+    uri: '',
+    endList: (attributes.type || 'static') === 'static',
+    timeline: attributes.periodIndex,
+    resolvedUri: '',
+    targetDuration: attributes.duration,
+    segments,
+    mediaSequence: segments.length ? segments[0].number : 1
+  };
+
+  if (attributes.contentProtection) {
+    playlist.contentProtection = attributes.contentProtection;
+  }
+
+  if (sidx) {
+    playlist.sidx = sidx;
+  }
+
+  if (isAudioOnly) {
+    playlist.attributes.AUDIO = 'audio';
+    playlist.attributes.SUBTITLES = 'subs';
+  }
+
+  return playlist;
+};
+
+export const formatVttPlaylist = ({ attributes, segments }) => {
+  if (typeof segments === 'undefined') {
+    // vtt tracks may use single file in BaseURL
+    segments = [{
+      uri: attributes.baseUrl,
+      timeline: attributes.periodIndex,
+      resolvedUri: attributes.baseUrl || '',
+      duration: attributes.sourceDuration,
+      number: 0
+    }];
+    // targetDuration should be the same duration as the only segment
+    attributes.duration = attributes.sourceDuration;
+  }
+
+  const m3u8Attributes = {
+    NAME: attributes.id,
+    BANDWIDTH: attributes.bandwidth,
+    ['PROGRAM-ID']: 1
+  };
+
+  if (attributes.codecs) {
+    m3u8Attributes.CODECS = attributes.codecs;
+  }
+  return {
+    attributes: m3u8Attributes,
+    uri: '',
+    endList: (attributes.type || 'static') === 'static',
+    timeline: attributes.periodIndex,
+    resolvedUri: attributes.baseUrl || '',
+    targetDuration: attributes.duration,
+    segments,
+    mediaSequence: segments.length ? segments[0].number : 1
+  };
+};
+
+export const organizeAudioPlaylists = (playlists, sidxMapping = {}, isAudioOnly = false) => {
+  let mainPlaylist;
+
+  const formattedPlaylists = playlists.reduce((a, playlist) => {
+    const role = playlist.attributes.role &&
+      playlist.attributes.role.value || '';
+    const language = playlist.attributes.lang || '';
+
+    let label = playlist.attributes.label || 'main';
+
+    if (language && !playlist.attributes.label) {
+      const roleLabel = role ? ` (${role})` : '';
+
+      label = `${playlist.attributes.lang}${roleLabel}`;
+    }
+
+    if (!a[label]) {
+      a[label] = {
+        language,
+        autoselect: true,
+        default: role === 'main',
+        playlists: [],
+        uri: ''
+      };
+    }
+
+    const formatted = addSidxSegmentsToPlaylist(formatAudioPlaylist(playlist, isAudioOnly), sidxMapping);
+
+    a[label].playlists.push(formatted);
+
+    if (typeof mainPlaylist === 'undefined' && role === 'main') {
+      mainPlaylist = playlist;
+      mainPlaylist.default = true;
+    }
+
+    return a;
+  }, {});
+
+  // if no playlists have role "main", mark the first as main
+  if (!mainPlaylist) {
+    const firstLabel = Object.keys(formattedPlaylists)[0];
+
+    formattedPlaylists[firstLabel].default = true;
+  }
+
+  return formattedPlaylists;
+};
+
+export const organizeVttPlaylists = (playlists, sidxMapping = {}) => {
+  return playlists.reduce((a, playlist) => {
+    const label = playlist.attributes.lang || 'text';
+
+    if (!a[label]) {
+      a[label] = {
+        language: label,
+        default: false,
+        autoselect: false,
+        playlists: [],
+        uri: ''
+      };
+    }
+    a[label].playlists.push(addSidxSegmentsToPlaylist(formatVttPlaylist(playlist), sidxMapping));
+
+    return a;
+  }, {});
+};
+
+const organizeCaptionServices = (captionServices) => captionServices.reduce((svcObj, svc) => {
+  if (!svc) {
+    return svcObj;
+  }
+
+  svc.forEach((service) => {
+    const {
+      channel,
+      language
+    } = service;
+
+    svcObj[language] = {
+      autoselect: false,
+      default: false,
+      instreamId: channel,
+      language
+    };
+
+    if (service.hasOwnProperty('aspectRatio')) {
+      svcObj[language].aspectRatio = service.aspectRatio;
+    }
+    if (service.hasOwnProperty('easyReader')) {
+      svcObj[language].easyReader = service.easyReader;
+    }
+    if (service.hasOwnProperty('3D')) {
+      svcObj[language]['3D'] = service['3D'];
+    }
+
+  });
+
+  return svcObj;
+}, {});
+
+export const formatVideoPlaylist = ({ attributes, segments, sidx }) => {
+  const playlist = {
+    attributes: {
+      NAME: attributes.id,
+      AUDIO: 'audio',
+      SUBTITLES: 'subs',
+      RESOLUTION: {
+        width: attributes.width,
+        height: attributes.height
+      },
+      CODECS: attributes.codecs,
+      BANDWIDTH: attributes.bandwidth,
+      ['PROGRAM-ID']: 1
+    },
+    uri: '',
+    endList: (attributes.type || 'static') === 'static',
+    timeline: attributes.periodIndex,
+    resolvedUri: '',
+    targetDuration: attributes.duration,
+    segments,
+    mediaSequence: segments.length ? segments[0].number : 1
+  };
+
+  if (attributes.contentProtection) {
+    playlist.contentProtection = attributes.contentProtection;
+  }
+
+  if (sidx) {
+    playlist.sidx = sidx;
+  }
+
+  return playlist;
+};
+
+const videoOnly = ({ attributes }) =>
+  attributes.mimeType === 'video/mp4' || attributes.mimeType === 'video/webm' || attributes.contentType === 'video';
+const audioOnly = ({ attributes }) =>
+  attributes.mimeType === 'audio/mp4' || attributes.mimeType === 'audio/webm' || attributes.contentType === 'audio';
+const vttOnly = ({ attributes }) =>
+  attributes.mimeType === 'text/vtt' || attributes.contentType === 'text';
+
+export const toM3u8 = (dashPlaylists, locations, sidxMapping = {}) => {
+  if (!dashPlaylists.length) {
+    return {};
+  }
+
+  // grab all master attributes
+  const {
+    sourceDuration: duration,
+    type = 'static',
+    suggestedPresentationDelay,
+    minimumUpdatePeriod
+  } = dashPlaylists[0].attributes;
+
+  const videoPlaylists = mergeDiscontiguousPlaylists(dashPlaylists.filter(videoOnly)).map(formatVideoPlaylist);
+  const audioPlaylists = mergeDiscontiguousPlaylists(dashPlaylists.filter(audioOnly));
+  const vttPlaylists = dashPlaylists.filter(vttOnly);
+  const captions = dashPlaylists.map((playlist) => playlist.attributes.captionServices).filter(Boolean);
+
+  const master = {
+    allowCache: true,
+    discontinuityStarts: [],
+    segments: [],
+    endList: true,
+    mediaGroups: {
+      AUDIO: {},
+      VIDEO: {},
+      ['CLOSED-CAPTIONS']: {},
+      SUBTITLES: {}
+    },
+    uri: '',
+    duration,
+    playlists: addSidxSegmentsToPlaylists(videoPlaylists, sidxMapping)
+  };
+
+  if (minimumUpdatePeriod >= 0) {
+    master.minimumUpdatePeriod = minimumUpdatePeriod * 1000;
+  }
+
+  if (locations) {
+    master.locations = locations;
+  }
+
+  if (type === 'dynamic') {
+    master.suggestedPresentationDelay = suggestedPresentationDelay;
+  }
+
+  const isAudioOnly = master.playlists.length === 0;
+
+  if (audioPlaylists.length) {
+    master.mediaGroups.AUDIO.audio = organizeAudioPlaylists(audioPlaylists, sidxMapping, isAudioOnly);
+  }
+
+  if (vttPlaylists.length) {
+    master.mediaGroups.SUBTITLES.subs = organizeVttPlaylists(vttPlaylists, sidxMapping);
+  }
+
+  if (captions.length) {
+    master.mediaGroups['CLOSED-CAPTIONS'].cc = organizeCaptionServices(captions);
+  }
+
+  return master;
+};

node_modules/mpd-parser/src/toPlaylists.js

@@ -0,0 +1,66 @@
+import { merge } from './utils/object';
+import { segmentsFromTemplate } from './segment/segmentTemplate';
+import { segmentsFromList } from './segment/segmentList';
+import { segmentsFromBase } from './segment/segmentBase';
+
+export const generateSegments = ({ attributes, segmentInfo }) => {
+  let segmentAttributes;
+  let segmentsFn;
+
+  if (segmentInfo.template) {
+    segmentsFn = segmentsFromTemplate;
+    segmentAttributes = merge(attributes, segmentInfo.template);
+
+    if (segmentInfo.template.presentationTimeOffset) {
+      segmentAttributes.presentationTimeOffset =
+        segmentInfo.template.presentationTimeOffset / segmentInfo.template.timescale;
+    }
+
+  } else if (segmentInfo.base) {
+    segmentsFn = segmentsFromBase;
+    segmentAttributes = merge(attributes, segmentInfo.base);
+  } else if (segmentInfo.list) {
+    segmentsFn = segmentsFromList;
+    segmentAttributes = merge(attributes, segmentInfo.list);
+  }
+
+  const segmentsInfo = {
+    attributes
+  };
+
+  if (!segmentsFn) {
+    return segmentsInfo;
+  }
+
+  const segments = segmentsFn(segmentAttributes, segmentInfo.timeline);
+
+  // The @duration attribute will be used to determin the playlist's targetDuration which
+  // must be in seconds. Since we've generated the segment list, we no longer need
+  // @duration to be in @timescale units, so we can convert it here.
+  if (segmentAttributes.duration) {
+    const { duration, timescale = 1 } = segmentAttributes;
+
+    segmentAttributes.duration = duration / timescale;
+  } else if (segments.length) {
+    // if there is no @duration attribute, use the largest segment duration as
+    // as target duration
+    segmentAttributes.duration = segments.reduce((max, segment) => {
+      return Math.max(max, Math.ceil(segment.duration));
+    }, 0);
+  } else {
+    segmentAttributes.duration = 0;
+  }
+
+  segmentsInfo.attributes = segmentAttributes;
+  segmentsInfo.segments = segments;
+
+  // This is a sidx box without actual segment information
+  if (segmentInfo.base && segmentAttributes.indexRange) {
+    segmentsInfo.sidx = segments[0];
+    segmentsInfo.segments = [];
+  }
+
+  return segmentsInfo;
+};
+
+export const toPlaylists = (representations) => representations.map(generateSegments);

node_modules/mpd-parser/src/utils/list.js

@@ -0,0 +1,33 @@
+export const range = (start, end) => {
+  const result = [];
+
+  for (let i = start; i < end; i++) {
+    result.push(i);
+  }
+
+  return result;
+};
+
+export const flatten = lists => lists.reduce((x, y) => x.concat(y), []);
+
+export const from = list => {
+  if (!list.length) {
+    return [];
+  }
+
+  const result = [];
+
+  for (let i = 0; i < list.length; i++) {
+    result.push(list[i]);
+  }
+
+  return result;
+};
+
+export const findIndexes = (l, key) => l.reduce((a, e, i) => {
+  if (e[key]) {
+    a.push(i);
+  }
+
+  return a;
+}, []);

node_modules/mpd-parser/src/utils/object.js

@@ -0,0 +1,27 @@
+const isObject = (obj) => {
+  return !!obj && typeof obj === 'object';
+};
+
+export const merge = (...objects) => {
+
+  return objects.reduce((result, source) => {
+
+    if (typeof source !== 'object') {
+      return result;
+    }
+
+    Object.keys(source).forEach(key => {
+
+      if (Array.isArray(result[key]) && Array.isArray(source[key])) {
+        result[key] = result[key].concat(source[key]);
+      } else if (isObject(result[key]) && isObject(source[key])) {
+        result[key] = merge(result[key], source[key]);
+      } else {
+        result[key] = source[key];
+      }
+    });
+    return result;
+  }, {});
+};
+
+export const values = o => Object.keys(o).map(k => o[k]);

node_modules/mpd-parser/src/utils/time.js

@@ -0,0 +1,39 @@
+export const parseDuration = (str) => {
+  const SECONDS_IN_YEAR = 365 * 24 * 60 * 60;
+  const SECONDS_IN_MONTH = 30 * 24 * 60 * 60;
+  const SECONDS_IN_DAY = 24 * 60 * 60;
+  const SECONDS_IN_HOUR = 60 * 60;
+  const SECONDS_IN_MIN = 60;
+
+  // P10Y10M10DT10H10M10.1S
+  const durationRegex =
+    /P(?:(\d*)Y)?(?:(\d*)M)?(?:(\d*)D)?(?:T(?:(\d*)H)?(?:(\d*)M)?(?:([\d.]*)S)?)?/;
+  const match = durationRegex.exec(str);
+
+  if (!match) {
+    return 0;
+  }
+
+  const [year, month, day, hour, minute, second] = match.slice(1);
+
+  return (parseFloat(year || 0) * SECONDS_IN_YEAR +
+    parseFloat(month || 0) * SECONDS_IN_MONTH +
+    parseFloat(day || 0) * SECONDS_IN_DAY +
+    parseFloat(hour || 0) * SECONDS_IN_HOUR +
+    parseFloat(minute || 0) * SECONDS_IN_MIN +
+    parseFloat(second || 0));
+};
+
+export const parseDate = (str) => {
+  // Date format without timezone according to ISO 8601
+  // YYY-MM-DDThh:mm:ss.ssssss
+  const dateRegex = /^\d+-\d+-\d+T\d+:\d+:\d+(\.\d+)?$/;
+
+  // If the date string does not specifiy a timezone, we must specifiy UTC. This is
+  // expressed by ending with 'Z'
+  if (dateRegex.test(str)) {
+    str += 'Z';
+  }
+
+  return Date.parse(str);
+};

node_modules/mpd-parser/src/utils/xml.js

@@ -0,0 +1,6 @@
+import { from } from './list';
+
+export const findChildren = (element, name) =>
+  from(element.childNodes).filter(({tagName}) => tagName === name);
+
+export const getContent = element => element.textContent.trim();