dasha 2.3.6 → 3.0.0

package/lib/xml.js

@@ -1,132 +1,300 @@
-'use strict';
-
-const PREFIX_LINE_PATTERN = /\s*(<\/?[^>]+>)/;
-const TAG_ATTR_PATTERN = /\s*(?:<\/?([^\s>]+))?\s*([^>]+)*(?:\/?>)?/;
-const ATTR_PAIR_PATTERN = /\s*([^=]+)="([^"]+)"/g;
-
-const getTagList = (xmlString) => {
-  const list = xmlString.split(PREFIX_LINE_PATTERN).filter(Boolean);
-  if (list[0].startsWith(`<?xml`)) list.splice(0, 1);
-  return list;
-};
-
-const parseTag = (tagString) => {
-  const match = tagString.match(TAG_ATTR_PATTERN);
-  if (!match) return null;
-
-  const tagNameWithBrackets = match[0];
-  const tagName = match[1];
-  const tagAttributes = match[2];
-
-  const isClosedTag = /^<\//.test(tagNameWithBrackets);
-  const isNormalTag = /^</.test(tagNameWithBrackets);
-  const isCommentTag = /^<!/.test(tagNameWithBrackets);
-  if (isCommentTag) return;
-
-  // const formattedTagName = formatTagName(tagName);
-
-  const tag = {
-    tagName,
-  };
-
-  // <TagName xx=xx xxx=xxx>
-  // <TagName xx=xxx xx=xxx />
-  if (tagName && tagAttributes) {
-    const isSelfClosed = /\/$/.test(tagAttributes);
-    const attrs = {};
-    let currentAttribute = ATTR_PAIR_PATTERN.exec(tagAttributes);
-    while (currentAttribute !== null) {
-      const [rawAttribute, attributeName, attributeValue] = currentAttribute;
-      attrs[attributeName] = attributeValue;
-      currentAttribute = ATTR_PAIR_PATTERN.exec(tagAttributes);
-    }
-    tag.attrs = attrs;
-    tag.closed = isSelfClosed;
-    return tag;
-  }
+function parse(text, options = {}) {
+  var pos = options.pos || 0;
+  var keepComments = !!options.keepComments;
+  var keepWhitespace = !!options.keepWhitespace;
+
+  var openBracket = '<';
+  var openBracketCC = '<'.charCodeAt(0);
+  var closeBracket = '>';
+  var closeBracketCC = '>'.charCodeAt(0);
+  var minusCC = '-'.charCodeAt(0);
+  var slashCC = '/'.charCodeAt(0);
+  var exclamationCC = '!'.charCodeAt(0);
+  var singleQuoteCC = "'".charCodeAt(0);
+  var doubleQuoteCC = '"'.charCodeAt(0);
+  var openCornerBracketCC = '['.charCodeAt(0);
+  var closeCornerBracketCC = ']'.charCodeAt(0);
+
+  /**
+   * parsing a list of entries
+   */
+  function parseChildren(tagName) {
+    var children = [];
+    while (text[pos]) {
+      if (text.charCodeAt(pos) == openBracketCC) {
+        if (text.charCodeAt(pos + 1) === slashCC) {
+          var closeStart = pos + 2;
+          pos = text.indexOf(closeBracket, pos);
+
+          var closeTag = text.substring(closeStart, pos);
+          if (closeTag.indexOf(tagName) == -1) {
+            var parsedText = text.substring(0, pos).split('\n');
+            throw new Error(
+              'Unexpected close tag\nLine: ' +
+                (parsedText.length - 1) +
+                '\nColumn: ' +
+                (parsedText[parsedText.length - 1].length + 1) +
+                '\nChar: ' +
+                text[pos]
+            );
+          }
 
-  // </TagName>
-  if (isClosedTag) {
-    tag.closed = true;
-    return tag;
+          if (pos + 1) pos += 1;
+
+          return children;
+        } else if (text.charCodeAt(pos + 1) === exclamationCC) {
+          if (text.charCodeAt(pos + 2) == minusCC) {
+            //comment support
+            const startCommentPos = pos;
+            while (
+              pos !== -1 &&
+              !(
+                text.charCodeAt(pos) === closeBracketCC &&
+                text.charCodeAt(pos - 1) == minusCC &&
+                text.charCodeAt(pos - 2) == minusCC &&
+                pos != -1
+              )
+            ) {
+              pos = text.indexOf(closeBracket, pos + 1);
+            }
+            if (pos === -1) {
+              pos = text.length;
+            }
+            if (keepComments) {
+              children.push(text.substring(startCommentPos, pos + 1));
+            }
+          } else if (
+            text.charCodeAt(pos + 2) === openCornerBracketCC &&
+            text.charCodeAt(pos + 8) === openCornerBracketCC &&
+            text.substr(pos + 3, 5).toLowerCase() === 'cdata'
+          ) {
+            // cdata
+            var cdataEndIndex = text.indexOf(']]>', pos);
+            if (cdataEndIndex == -1) {
+              children.push(text.substr(pos + 9));
+              pos = text.length;
+            } else {
+              children.push(text.substring(pos + 9, cdataEndIndex));
+              pos = cdataEndIndex + 3;
+            }
+            continue;
+          } else {
+            // doctypesupport
+            const startDoctype = pos + 1;
+            pos += 2;
+            var encapsuled = false;
+            while ((text.charCodeAt(pos) !== closeBracketCC || encapsuled === true) && text[pos]) {
+              if (text.charCodeAt(pos) === openCornerBracketCC) {
+                encapsuled = true;
+              } else if (encapsuled === true && text.charCodeAt(pos) === closeCornerBracketCC) {
+                encapsuled = false;
+              }
+              pos++;
+            }
+            children.push(text.substring(startDoctype, pos));
+          }
+          pos++;
+          continue;
+        }
+        var node = parseNode();
+        children.push(node);
+        if (node.tagName[0] === '?') {
+          children.push(...node.children);
+          node.children = [];
+        }
+      } else {
+        var parsedText = parseText();
+        if (keepWhitespace) {
+          if (parsedText.length > 0) {
+            children.push(parsedText);
+          }
+        } else {
+          var trimmed = parsedText.trim();
+          if (trimmed.length > 0) {
+            children.push(trimmed);
+          }
+        }
+        pos++;
+      }
+    }
+    return children;
   }
 
-  // <TagName>
-  if (isNormalTag) {
-    tag.attrs = {};
-    return tag;
+  /**
+   *    returns the text outside of texts until the first '<'
+   */
+  function parseText() {
+    var start = pos;
+    pos = text.indexOf(openBracket, pos) - 1;
+    if (pos === -2) pos = text.length;
+    return text.slice(start, pos + 1);
   }
+  /**
+   *    returns text until the first nonAlphabetic letter
+   */
+  var nameSpacer = '\r\n\t>/= ';
 
-  // pure value
-  tag.tagName = 'pureValue';
-  tag.attrs = { value: tagAttributes };
-  tag.closed = true;
-  return tag;
-};
-
-const mergeTags = (tagList) => {
-  const stack = [];
-  let last;
-  let lastPre;
-
-  for (const tag of tagList) {
-    // start tag
-    if (!tag.closed) {
-      stack.push(tag);
-      continue;
+  function parseName() {
+    var start = pos;
+    while (nameSpacer.indexOf(text[pos]) === -1 && text[pos]) {
+      pos++;
     }
+    return text.slice(start, pos);
+  }
+  /**
+   *    is parsing a node, including tagName, Attributes and its children,
+   * to parse children it uses the parseChildren again, that makes the parsing recursive
+   */
+  var NoChildNodes = options.noChildNodes || ['img', 'br', 'input', 'meta', 'link', 'hr'];
 
-    last = stack.pop();
+  function parseNode() {
+    pos++;
+    const tagName = parseName();
+    const attributes = {};
+    let children = [];
 
-    if (tag.tagName === 'pureValue') {
-      last.attrs ? (last.attrs.value = tag.attrs.value) : (last.attrs = tag.attrs);
-      stack.push(last);
-      continue;
+    // parsing attributes
+    while (text.charCodeAt(pos) !== closeBracketCC && text[pos]) {
+      var c = text.charCodeAt(pos);
+      if ((c > 64 && c < 91) || (c > 96 && c < 123)) {
+        //if('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'.indexOf(S[pos])!==-1 ){
+        var name = parseName();
+        // search beginning of the string
+        var code = text.charCodeAt(pos);
+        while (
+          code &&
+          code !== singleQuoteCC &&
+          code !== doubleQuoteCC &&
+          !((code > 64 && code < 91) || (code > 96 && code < 123)) &&
+          code !== closeBracketCC
+        ) {
+          pos++;
+          code = text.charCodeAt(pos);
+        }
+        if (code === singleQuoteCC || code === doubleQuoteCC) {
+          var value = parseString();
+          if (pos === -1) {
+            return {
+              tagName,
+              attributes,
+              children,
+            };
+          }
+        } else {
+          value = null;
+          pos--;
+        }
+        attributes[name] = value;
+      }
+      pos++;
     }
-
-    if (last && last.tagName === tag.tagName) {
-      lastPre = stack.pop();
+    // optional parsing of children
+    if (text.charCodeAt(pos - 1) !== slashCC) {
+      if (tagName == 'script') {
+        var start = pos + 1;
+        pos = text.indexOf('</script>', pos);
+        children = [text.slice(start, pos)];
+        pos += 9;
+      } else if (tagName == 'style') {
+        var start = pos + 1;
+        pos = text.indexOf('</style>', pos);
+        children = [text.slice(start, pos)];
+        pos += 8;
+      } else if (NoChildNodes.indexOf(tagName) === -1) {
+        pos++;
+        children = parseChildren(tagName);
+      } else {
+        pos++;
+      }
     } else {
-      // self closed tag
-      lastPre = last;
-      last = tag;
+      pos++;
     }
+    return {
+      tagName,
+      attributes,
+      children,
+    };
+  }
 
-    if (!lastPre) {
-      stack.push(last);
-      break;
-    }
+  /**
+   *    is parsing a string, that starts with a char and with the same usually  ' or "
+   */
 
-    const { tagName } = last;
-    let { attrs } = last;
-    const prop = lastPre.attrs[tagName];
+  function parseString() {
+    var startChar = text[pos];
+    var startpos = pos + 1;
+    pos = text.indexOf(startChar, startpos);
+    return text.slice(startpos, pos);
+  }
 
-    if (prop) {
-      lastPre.attrs[tagName] = Array.isArray(prop) ? prop.concat(attrs) : [prop, attrs];
+  /**
+   *
+   */
+  function findElements() {
+    var r = new RegExp('\\s' + options.attrName + '\\s*=[\'"]' + options.attrValue + '[\'"]').exec(
+      text
+    );
+    if (r) {
+      return r.index;
     } else {
-      lastPre.attrs[tagName] = attrs;
+      return -1;
     }
-    stack.push(lastPre);
   }
 
-  const firstTag = stack[0];
+  var out = null;
+  if (options.attrValue !== undefined) {
+    options.attrName = options.attrName || 'id';
+    var out = [];
+
+    while ((pos = findElements()) !== -1) {
+      pos = text.lastIndexOf('<', pos);
+      if (pos !== -1) {
+        out.push(parseNode());
+      }
+      text = text.substr(pos);
+      pos = 0;
+    }
+  } else if (options.parseNode) {
+    out = parseNode();
+  } else {
+    out = parseChildren('');
+  }
 
-  if (!firstTag) return null;
-  if (firstTag.tagName !== undefined) return { [firstTag.tagName]: firstTag.attrs };
+  if (options.filter) {
+    out = filter(out, options.filter);
+  }
 
-  return firstTag.tagName;
-};
+  if (options.simplify) {
+    return simplify(Array.isArray(out) ? out : [out]);
+  }
 
-const parseXml = (text) => {
-  if (!text) return { error: 1, message: 'invalid input' };
-  try {
-    const rawTags = getTagList(text);
-    const parsedTags = rawTags.map((tag) => parseTag(tag)).filter(Boolean);
-    const mergedTags = mergeTags(parsedTags);
-    return mergedTags;
-  } catch (e) {
-    return { error: 1, message: e.message };
+  if (options.setPos) {
+    out.pos = pos;
   }
-};
 
-module.exports = { parseXml };
+  return out;
+}
+
+/**
+ * behaves the same way as Array.filter, if the filter method return true, the element is in the resultList
+ * @params children{Array} the children of a node
+ * @param f{function} the filter method
+ */
+function filter(children, f, dept = 0, path = '') {
+  var out = [];
+  children.forEach(function (child, i) {
+    if (typeof child === 'object' && f(child, i, dept, path)) out.push(child);
+    if (child.children) {
+      var kids = filter(
+        child.children,
+        f,
+        dept + 1,
+        (path ? path + '.' : '') + i + '.' + child.tagName
+      );
+      out = out.concat(kids);
+    }
+  });
+  return out;
+}
+
+module.exports = { parse, filter };

package/package.json

@@ -1,46 +1,60 @@
 {
   "name": "dasha",
-  "version": "2.3.6",
+  "version": "3.0.0",
   "author": "Vitaly Gashkov <vitalygashkov@vk.com>",
-  "description": "MPD-manifest parser for MPEG DASH",
-  "license": "Apache-2.0",
+  "description": "Parser for MPEG-DASH & HLS manifests",
+  "license": "AGPL-3.0",
   "keywords": [
     "mpeg",
     "dash",
+    "hls",
     "adaptive",
     "mpd",
+    "m3u8",
     "manifest"
   ],
+  "readmeFilename": "README.md",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vitalygashkov/dasha"
+  },
+  "bugs": {
+    "url": "https://github.com/vitalygashkov/dasha/issues",
+    "email": "vitalygashkov@vk.com"
+  },
   "main": "dasha.js",
   "types": "types/dasha.d.ts",
+  "funding": [
+    {
+      "type": "individual",
+      "url": "https://boosty.to/vitalygashkov/donate"
+    }
+  ],
   "files": [
     "lib",
     "types"
   ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/vitalygashkov/dasha.git"
-  },
-  "funding": {
-    "type": "individual",
-    "url": "https://boosty.to/vitalygashkov"
-  },
   "scripts": {
-    "test": "jest",
+    "test": "node --test",
     "types": "tsc -p tsconfig.json",
     "lint": "eslint \"**/*.js\" --fix",
     "lint:check": "eslint \"**/*.js\"",
     "format": "prettier --loglevel warn --write \"**/*.{ts,js,json,yaml}\"",
-    "format:check": "prettier --loglevel warn --check \"**/*.{ts,js,json,yaml}\""
+    "format:check": "prettier --loglevel warn --check \"**/*.{ts,js,json,yaml}\"",
+    "build": "tsup ./dasha.js --format cjs",
+    "build:bun": "bun build ./dasha.js --outdir ./dist --format cjs"
+  },
+  "dependencies": {
+    "m3u8-parser": "^7.1.0"
   },
   "devDependencies": {
-    "@types/node": "^17.0.23",
-    "eslint": "^8.12.0",
-    "eslint-config-prettier": "^8.5.0",
-    "eslint-plugin-import": "^2.25.4",
-    "eslint-plugin-prettier": "^4.0.0",
-    "jest": "^27.5.1",
-    "prettier": "^2.6.1",
-    "typescript": "^4.6.3"
+    "@types/node": "^20.12.7",
+    "eslint": "^8.57.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-prettier": "^5.1.3",
+    "prettier": "^3.2.5",
+    "tsup": "^8.0.2",
+    "typescript": "^5.4.5"
   }
 }

package/types/dasha.d.ts

@@ -1,2 +1,98 @@
-export * from './manifest';
-export * from './constants';
+export function parse(text: string, url: string, fallbackLanguage?: string): Promise<Manifest>;
+
+export interface Manifest {
+  duration?: number;
+  tracks: {
+    all: (VideoTrack | AudioTrack | SubtitleTrack)[];
+    videos: VideoTrack[];
+    audios: AudioTrack[];
+    subtitles: SubtitleTrack[];
+    withResolution(resolution: { width?: string; height?: string }): VideoTrack[];
+    withVideoQuality(quality: number | string): VideoTrack[];
+    withAudioLanguages(languages: string[], maxTracksPerLanguage?: number): AudioTrack[];
+    withSubtitleLanguages(languages: string[]): SubtitleTrack[];
+  };
+}
+
+export interface Track {
+  id: string;
+  type: 'video' | 'audio' | 'text';
+  segments: Segment[];
+  size?: Size;
+  label?: string;
+  protection?: TrackProtection;
+  toString: () => string;
+}
+
+export interface Bitrate {
+  bps: number;
+  kbps: number;
+  mbps: number;
+  gbps: number;
+  toString: () => string;
+}
+
+export interface Size {
+  b: number;
+  kb: number;
+  mb: number;
+  gb: number;
+  toString: () => string;
+}
+
+export interface Segment {
+  url: string;
+  range?: string;
+  init?: boolean;
+  duration?: number;
+  number?: number;
+  presentationTime?: number;
+}
+
+export interface TrackProtection {
+  common?: { id: string; value: 'cenc' | 'cbcs'; keyId?: string };
+  playready?: { id: string; pssh?: string; value?: string };
+  widevine?: { id: string; pssh: string };
+  fairplay?: { keyFormat: string; uri: string; method: string };
+}
+
+export type VideoCodec = 'H.264' | 'H.265' | 'VC-1' | 'VP8' | 'VP9' | 'AV1';
+export type DynamicRange = 'SDR' | 'HLG' | 'HDR10' | 'HDR10+' | 'DV';
+
+export interface VideoTrack extends Track {
+  type: 'video';
+  codec: VideoCodec;
+  bitrate: Bitrate;
+  width: number;
+  height: number;
+  quality: '144p' | '240p' | '360p' | '480p' | '720p' | '1080p' | '2160p' | '4320p' | string;
+  dynamicRange: DynamicRange;
+  fps?: string;
+  language?: string;
+}
+
+export type AudioCodec = 'AAC' | 'DD' | 'DD+' | 'OPUS' | 'VORB' | 'DTS' | 'ALAC' | 'FLAC';
+
+export interface AudioTrack extends Track {
+  type: 'audio';
+  codec: AudioCodec;
+  bitrate: Bitrate;
+  language: string;
+  channels?: number;
+  jointObjectCoding?: number;
+  isDescriptive?: boolean;
+}
+
+export type SubtitleCodec = 'SRT' | 'SSA' | 'ASS' | 'TTML' | 'VTT' | 'STPP' | 'fTTML' | 'fVTT';
+
+export interface SubtitleTrack extends Track {
+  type: 'text';
+  codec: SubtitleCodec;
+  bitrate?: Bitrate;
+  language: string;
+  isClosedCaption?: boolean;
+  isSdh?: boolean;
+  isForced?: boolean;
+}
+
+export type AnyTrack = VideoTrack | AudioTrack | SubtitleTrack;

package/lib/constants.js

@@ -1,16 +0,0 @@
-const CONTENT_TYPE = {
-  video: 'video',
-  audio: 'audio',
-  text: 'text',
-  image: 'image',
-  application: 'application',
-};
-
-const KEY_SYSTEMS = {
-  'org.w3.clearkey': 'urn:uuid:1077efec-c0b2-4d02-ace3-3c1e52e2fb4b',
-  'com.widevine.alpha': 'urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed',
-  'com.microsoft.playready': 'urn:uuid:9a04f079-9840-4286-ab92-e65be0885f95',
-  'com.adobe.primetime': 'urn:uuid:f239e769-efa3-4850-9c16-a903c6932efb',
-};
-
-module.exports = { CONTENT_TYPE, KEY_SYSTEMS };