ahmad-module 1.0.0

package/ytdl-core/node_modules/sax/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "sax",
+  "description": "An evented streaming XML parser in JavaScript",
+  "author": "Isaac Z. Schlueter <i@izs.me> (http://blog.izs.me/)",
+  "version": "1.2.4",
+  "main": "lib/sax.js",
+  "license": "ISC",
+  "scripts": {
+    "test": "tap test/*.js --cov -j4",
+    "posttest": "standard -F test/*.js lib/*.js",
+    "preversion": "npm test",
+    "postversion": "npm publish",
+    "postpublish": "git push origin --all; git push origin --tags"
+  },
+  "repository": "git://github.com/isaacs/sax-js.git",
+  "files": [
+    "lib/sax.js",
+    "LICENSE",
+    "README.md"
+  ],
+  "devDependencies": {
+    "standard": "^8.6.0",
+    "tap": "^10.5.1"
+  }
+}

package/ytdl-core/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "ytdl-core",
+  "description": "YouTube video downloader in pure javascript.",
+  "keywords": [
+    "youtube",
+    "video",
+    "download"
+  ],
+  "version": "4.11.1",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/fent/node-ytdl-core.git"
+  },
+  "author": "fent <fentbox@gmail.com> (https://github.com/fent)",
+  "contributors": [
+    "Tobias Kutscha (https://github.com/TimeForANinja)",
+    "Andrew Kelley (https://github.com/andrewrk)",
+    "Mauricio Allende (https://github.com/mallendeo)",
+    "Rodrigo Altamirano (https://github.com/raltamirano)",
+    "Jim Buck (https://github.com/JimmyBoh)",
+    "Paweł Ruciński (https://github.com/Roki100)",
+    "Alexander Paolini (https://github.com/Million900o)"
+  ],
+  "main": "./lib/index.js",
+  "types": "./typings/index.d.ts",
+  "files": [
+    "lib",
+    "typings"
+  ],
+  "scripts": {
+    "test": "nyc --reporter=lcov --reporter=text-summary npm run test:unit",
+    "test:unit": "mocha --ignore test/irl-test.js test/*-test.js --timeout 4000",
+    "test:irl": "mocha --timeout 16000 test/irl-test.js",
+    "lint": "eslint ./",
+    "lint:fix": "eslint --fix ./",
+    "lint:typings": "tslint typings/index.d.ts",
+    "lint:typings:fix": "tslint --fix typings/index.d.ts"
+  },
+  "dependencies": {
+    "m3u8stream": "^0.8.6",
+    "miniget": "^4.2.2",
+    "sax": "^1.1.3"
+  },
+  "devDependencies": {
+    "@types/node": "^13.1.0",
+    "assert-diff": "^3.0.1",
+    "dtslint": "^3.6.14",
+    "eslint": "^6.8.0",
+    "mocha": "^7.0.0",
+    "muk-require": "^1.2.0",
+    "nock": "^13.0.4",
+    "nyc": "^15.0.0",
+    "sinon": "^9.0.0",
+    "stream-equal": "~1.1.0",
+    "typescript": "^3.9.7"
+  },
+  "engines": {
+    "node": ">=12"
+  },
+  "license": "MIT"
+}

package/ytdl-core/typings/index.d.ts

@@ -0,0 +1,426 @@
+declare module 'ytdl-core' {
+  import { ClientRequest } from 'http';
+  import { Readable } from 'stream';
+
+  namespace ytdl {
+    type Filter = 'audioandvideo' | 'videoandaudio' | 'video' | 'videoonly' | 'audio' | 'audioonly' | ((format: videoFormat) => boolean);
+
+    interface getInfoOptions {
+      lang?: string;
+      requestCallback?: () => {};
+      requestOptions?: {};
+    }
+
+    interface chooseFormatOptions {
+      quality?: 'lowest' | 'highest' | 'highestaudio' | 'lowestaudio' | 'highestvideo' | 'lowestvideo' | string | number | string[] | number[];
+      filter?: Filter;
+      format?: videoFormat;
+    }
+
+    interface downloadOptions extends getInfoOptions, chooseFormatOptions {
+      range?: {
+        start?: number;
+        end?: number;
+      };
+      begin?: string | number | Date;
+      liveBuffer?: number;
+      highWaterMark?: number;
+      IPv6Block?: string;
+      dlChunkSize?: number;
+    }
+
+    interface videoFormat {
+      itag: number;
+      url: string;
+      mimeType?: string;
+      bitrate?: number;
+      audioBitrate?: number;
+      width?: number;
+      height?: number;
+      initRange?: { start: string; end: string };
+      indexRange?: { start: string; end: string };
+      lastModified: string;
+      contentLength: string;
+      quality: 'tiny' | 'small' | 'medium' | 'large' | 'hd720' | 'hd1080' | 'hd1440' | 'hd2160' | 'highres' | string;
+      qualityLabel: '144p' | '144p 15fps' | '144p60 HDR' | '240p' | '240p60 HDR' | '270p' | '360p' | '360p60 HDR'
+        | '480p' | '480p60 HDR' | '720p' | '720p60' | '720p60 HDR' | '1080p' | '1080p60' | '1080p60 HDR' | '1440p'
+        | '1440p60' | '1440p60 HDR' | '2160p' | '2160p60' | '2160p60 HDR' | '4320p' | '4320p60';
+      projectionType?: 'RECTANGULAR';
+      fps?: number;
+      averageBitrate?: number;
+      audioQuality?: 'AUDIO_QUALITY_LOW' | 'AUDIO_QUALITY_MEDIUM';
+      colorInfo?: {
+        primaries: string;
+        transferCharacteristics: string;
+        matrixCoefficients: string;
+      };
+      highReplication?: boolean;
+      approxDurationMs?: string;
+      targetDurationSec?: number;
+      maxDvrDurationSec?: number;
+      audioSampleRate?: string;
+      audioChannels?: number;
+
+      // Added by ytdl-core
+      container: 'flv' | '3gp' | 'mp4' | 'webm' | 'ts';
+      hasVideo: boolean;
+      hasAudio: boolean;
+      codecs: string;
+      videoCodec?: string;
+      audioCodec?: string;
+
+      isLive: boolean;
+      isHLS: boolean;
+      isDashMPD: boolean;
+    }
+
+    interface thumbnail {
+      url: string;
+      width: number;
+      height: number;
+    }
+
+    interface captionTrack {
+      baseUrl: string;
+      name: {
+        simpleText: 'Afrikaans' | 'Albanian' | 'Amharic' | 'Arabic' | 'Armenian' | 'Azerbaijani' | 'Bangla' | 'Basque'
+        | 'Belarusian' | 'Bosnian' | 'Bulgarian' | 'Burmese' | 'Catalan' | 'Cebuano' | 'Chinese (Simplified)'
+        | 'Chinese (Traditional)' | 'Corsican' | 'Croatian' | 'Czech' | 'Danish' | 'Dutch' | 'English'
+        | 'English (auto-generated)' | 'Esperanto' | 'Estonian' | 'Filipino' | 'Finnish' | 'French' | 'Galician'
+        | 'Georgian' | 'German' | 'Greek' | 'Gujarati' | 'Haitian Creole' | 'Hausa' | 'Hawaiian' | 'Hebrew' | 'Hindi'
+        | 'Hmong' | 'Hungarian' | 'Icelandic' | 'Igbo' | 'Indonesian' | 'Irish' | 'Italian' | 'Japanese' | 'Javanese'
+        | 'Kannada' | 'Kazakh' | 'Khmer' | 'Korean' | 'Kurdish' | 'Kyrgyz' | 'Lao' | 'Latin' | 'Latvian' | 'Lithuanian'
+        | 'Luxembourgish' | 'Macedonian' | 'Malagasy' | 'Malay' | 'Malayalam' | 'Maltese' | 'Maori' | 'Marathi'
+        | 'Mongolian' | 'Nepali' | 'Norwegian' | 'Nyanja' | 'Pashto' | 'Persian' | 'Polish' | 'Portuguese' | 'Punjabi'
+        | 'Romanian' | 'Russian' | 'Samoan' | 'Scottish Gaelic' | 'Serbian' | 'Shona' | 'Sindhi' | 'Sinhala' | 'Slovak'
+        | 'Slovenian' | 'Somali' | 'Southern Sotho' | 'Spanish' | 'Spanish (Spain)' | 'Sundanese' | 'Swahili'
+        | 'Swedish' | 'Tajik' | 'Tamil' | 'Telugu' | 'Thai' | 'Turkish' | 'Ukrainian' | 'Urdu' | 'Uzbek' | 'Vietnamese'
+        | 'Welsh' | 'Western Frisian' | 'Xhosa' | 'Yiddish' | 'Yoruba' | 'Zulu' | string;
+      };
+      vssId: string;
+      languageCode: 'af' | 'sq' | 'am' | 'ar' | 'hy' | 'az' | 'bn' | 'eu' | 'be' | 'bs' | 'bg' | 'my' | 'ca' | 'ceb'
+      | 'zh-Hans' | 'zh-Hant' | 'co' | 'hr' | 'cs' | 'da' | 'nl' | 'en' | 'eo' | 'et' | 'fil' | 'fi' | 'fr' | 'gl'
+      | 'ka' | 'de' | 'el' | 'gu' | 'ht' | 'ha' | 'haw' | 'iw' | 'hi' | 'hmn' | 'hu' | 'is' | 'ig' | 'id' | 'ga' | 'it'
+      | 'ja' | 'jv' | 'kn' | 'kk' | 'km' | 'ko' | 'ku' | 'ky' | 'lo' | 'la' | 'lv' | 'lt' | 'lb' | 'mk' | 'mg' | 'ms'
+      | 'ml' | 'mt' | 'mi' | 'mr' | 'mn' | 'ne' | 'no' | 'ny' | 'ps' | 'fa' | 'pl' | 'pt' | 'pa' | 'ro' | 'ru' | 'sm'
+      | 'gd' | 'sr' | 'sn' | 'sd' | 'si' | 'sk' | 'sl' | 'so' | 'st' | 'es' | 'su' | 'sw' | 'sv' | 'tg' | 'ta' | 'te'
+      | 'th' | 'tr' | 'uk' | 'ur' | 'uz' | 'vi' | 'cy' | 'fy' | 'xh' | 'yi' | 'yo' | 'zu' | string;
+      kind: string;
+      rtl?: boolean;
+      isTranslatable: boolean;
+    }
+
+    interface audioTrack {
+      captionTrackIndices: number[];
+    }
+
+    interface translationLanguage {
+      languageCode: captionTrack['languageCode'];
+      languageName: captionTrack['name'];
+    }
+
+    interface VideoDetails {
+      videoId: string;
+      title: string;
+      shortDescription: string;
+      lengthSeconds: string;
+      keywords?: string[];
+      channelId: string;
+      isOwnerViewing: boolean;
+      isCrawlable: boolean;
+      thumbnails: thumbnail[];
+      averageRating: number;
+      allowRatings: boolean;
+      viewCount: string;
+      author: string;
+      isPrivate: boolean;
+      isUnpluggedCorpus: boolean;
+      isLiveContent: boolean;
+    }
+
+    interface Media {
+      category: string;
+      category_url: string;
+      game?: string;
+      game_url?: string;
+      year?: number;
+      song?: string;
+      artist?: string;
+      artist_url?: string;
+      writers?: string;
+      licensed_by?: string;
+      thumbnails: thumbnail[];
+    }
+
+    interface Author {
+      id: string;
+      name: string;
+      avatar: string; // to remove later
+      thumbnails?: thumbnail[];
+      verified: boolean;
+      user?: string;
+      channel_url: string;
+      external_channel_url?: string;
+      user_url?: string;
+      subscriber_count?: number;
+    }
+
+    interface MicroformatRenderer {
+      thumbnail: {
+        thumbnails: thumbnail[];
+      };
+      embed: {
+        iframeUrl: string;
+        flashUrl: string;
+        width: number;
+        height: number;
+        flashSecureUrl: string;
+      };
+      title: {
+        simpleText: string;
+      };
+      description: {
+        simpleText: string;
+      };
+      lengthSeconds: string;
+      ownerProfileUrl: string;
+      ownerGplusProfileUrl?: string;
+      externalChannelId: string;
+      isFamilySafe: boolean;
+      availableCountries: string[];
+      isUnlisted: boolean;
+      hasYpcMetadata: boolean;
+      viewCount: string;
+      category: string;
+      publishDate: string;
+      ownerChannelName: string;
+      liveBroadcastDetails?: {
+        isLiveNow: boolean;
+        startTimestamp: string;
+        endTimestamp?: string;
+      };
+      uploadDate: string;
+    }
+
+    interface storyboard {
+      templateUrl: string;
+      thumbnailWidth: number;
+      thumbnailHeight: number;
+      thumbnailCount: number;
+      interval: number;
+      columns: number;
+      rows: number;
+      storyboardCount: number;
+    }
+
+    interface Chapter {
+      title: string;
+      start_time: number;
+    }
+
+    interface MoreVideoDetails extends Omit<VideoDetails, 'author' | 'thumbnail' | 'shortDescription'>, Omit<MicroformatRenderer, 'title' | 'description'> {
+      published: number;
+      video_url: string;
+      age_restricted: boolean;
+      likes: number | null;
+      dislikes: number | null;
+      media: Media;
+      author: Author;
+      thumbnails: thumbnail[];
+      storyboards: storyboard[];
+      chapters: Chapter[];
+      description: string | null;
+    }
+
+    interface videoInfo {
+      iv_load_policy?: string;
+      iv_allow_in_place_switch?: string;
+      iv_endscreen_url?: string;
+      iv_invideo_url?: string;
+      iv3_module?: string;
+      rmktEnabled?: string;
+      uid?: string;
+      vid?: string;
+      focEnabled?: string;
+      baseUrl?: string;
+      storyboard_spec?: string;
+      serialized_ad_ux_config?: string;
+      player_error_log_fraction?: string;
+      sffb?: string;
+      ldpj?: string;
+      videostats_playback_base_url?: string;
+      innertube_context_client_version?: string;
+      t?: string;
+      fade_in_start_milliseconds: string;
+      timestamp: string;
+      ad3_module: string;
+      relative_loudness: string;
+      allow_below_the_player_companion: string;
+      eventid: string;
+      token: string;
+      atc: string;
+      cr: string;
+      apply_fade_on_midrolls: string;
+      cl: string;
+      fexp: string[];
+      apiary_host: string;
+      fade_in_duration_milliseconds: string;
+      fflags: string;
+      ssl: string;
+      pltype: string;
+      enabled_engage_types: string;
+      hl: string;
+      is_listed: string;
+      gut_tag: string;
+      apiary_host_firstparty: string;
+      enablecsi: string;
+      csn: string;
+      status: string;
+      afv_ad_tag: string;
+      idpj: string;
+      sfw_player_response: string;
+      account_playback_token: string;
+      encoded_ad_safety_reason: string;
+      tag_for_children_directed: string;
+      no_get_video_log: string;
+      ppv_remarketing_url: string;
+      fmt_list: string[][];
+      ad_slots: string;
+      fade_out_duration_milliseconds: string;
+      instream_long: string;
+      allow_html5_ads: string;
+      core_dbp: string;
+      ad_device: string;
+      itct: string;
+      root_ve_type: string;
+      excluded_ads: string;
+      aftv: string;
+      loeid: string;
+      cver: string;
+      shortform: string;
+      dclk: string;
+      csi_page_type: string;
+      ismb: string;
+      gpt_migration: string;
+      loudness: string;
+      ad_tag: string;
+      of: string;
+      probe_url: string;
+      vm: string;
+      afv_ad_tag_restricted_to_instream: string;
+      gapi_hint_params: string;
+      cid: string;
+      c: string;
+      oid: string;
+      ptchn: string;
+      as_launched_in_country: string;
+      avg_rating: string;
+      fade_out_start_milliseconds: string;
+      midroll_prefetch_size: string;
+      allow_ratings: string;
+      thumbnail_url: string;
+      iurlsd: string;
+      iurlmq: string;
+      iurlhq: string;
+      iurlmaxres: string;
+      ad_preroll: string;
+      tmi: string;
+      trueview: string;
+      host_language: string;
+      innertube_api_key: string;
+      show_content_thumbnail: string;
+      afv_instream_max: string;
+      innertube_api_version: string;
+      mpvid: string;
+      allow_embed: string;
+      ucid: string;
+      plid: string;
+      midroll_freqcap: string;
+      ad_logging_flag: string;
+      ptk: string;
+      vmap: string;
+      watermark: string[];
+      dbp: string;
+      ad_flags: string;
+      html5player: string;
+      formats: videoFormat[];
+      related_videos: relatedVideo[];
+      no_embed_allowed?: boolean;
+      player_response: {
+        playabilityStatus: {
+          status: string;
+          playableInEmbed: boolean;
+          miniplayer: {
+            miniplayerRenderer: {
+              playbackMode: string;
+            };
+          };
+          contextParams: string;
+        };
+        streamingData: {
+          expiresInSeconds: string;
+          formats: {}[];
+          adaptiveFormats: {}[];
+        };
+        captions?: {
+          playerCaptionsRenderer: {
+            baseUrl: string;
+            visibility: string;
+          };
+          playerCaptionsTracklistRenderer: {
+            captionTracks: captionTrack[];
+            audioTracks: audioTrack[];
+            translationLanguages: translationLanguage[];
+            defaultAudioTrackIndex: number;
+          };
+        };
+        microformat: {
+          playerMicroformatRenderer: MicroformatRenderer;
+        };
+        videoDetails: VideoDetails;
+        playerConfig: {
+          audioConfig: {
+            loudnessDb: number;
+            perceptualLoudnessDb: number;
+            enablePerFormatLoudness: boolean;
+          };
+          streamSelectionConfig: { maxBitrate: string };
+          mediaCommonConfig: { dynamicReadaheadConfig: {}[] };
+          webPlayerConfig: { webPlayerActionsPorting: {}[] };
+        };
+      };
+      videoDetails: MoreVideoDetails;
+    }
+
+    interface relatedVideo {
+      id?: string;
+      title?: string;
+      published?: string;
+      author: Author | 'string'; // to remove the `string` part later
+      ucid?: string; // to remove later
+      author_thumbnail?: string; // to remove later
+      short_view_count_text?: string;
+      view_count?: string;
+      length_seconds?: number;
+      video_thumbnail?: string; // to remove later
+      thumbnails: thumbnail[];
+      richThumbnails: thumbnail[];
+      isLive: boolean;
+    }
+
+    function getBasicInfo(url: string, options?: getInfoOptions): Promise<videoInfo>;
+    function getInfo(url: string, options?: getInfoOptions): Promise<videoInfo>;
+    function downloadFromInfo(info: videoInfo, options?: downloadOptions): Readable;
+    function chooseFormat(format: videoFormat | videoFormat[], options?: chooseFormatOptions): videoFormat | never;
+    function filterFormats(formats: videoFormat | videoFormat[], filter?: Filter): videoFormat[];
+    function validateID(string: string): boolean;
+    function validateURL(string: string): boolean;
+    function getURLVideoID(string: string): string | never;
+    function getVideoID(string: string): string | never;
+    const version: number;
+  }
+
+  function ytdl(link: string, options?: ytdl.downloadOptions): Readable;
+
+  export = ytdl;
+}

package/ytdl-getinfo/.travis.yml

@@ -0,0 +1,3 @@
+language: node_js
+node_js:
+  - "stable"

package/ytdl-getinfo/README.md

@@ -0,0 +1,77 @@
+# ytdl-getinfo ![](https://travis-ci.org/TheBITLINK/ytdl-getinfo.svg?branch=master)
+
+Gets information on a video (or playlist) using youtube-dl.
+
+Like the getInfo function of `node-youtube-dl`, but promisified and event-based.
+
+## Usage
+
+```javascript
+const { getInfo } = require('ytdl-getinfo')
+```
+
+## Examples
+
+- Basic example:
+  ```javascript
+  getInfo('https://www.youtube.com/watch?v=v7BddpYYNGk').then(info => {
+    // info.items[0] should contain the output of youtube-dl --dump-json
+    console.log(info.items[0].title)
+  })
+  ```
+
+- Video Search:
+  ```javascript
+  getInfo('Muzzy - Endgame').then(info => {
+    // info.items[0] contains information of the first search result
+    console.log(info.items[0].url)    
+  })
+  ```
+
+- Custom Arguments:
+  ```javascript
+  getInfo('v7BddpYYNGk', ['--format=bestaudio']).then(info => {
+    // ...
+  })
+  ```
+
+- Playlists (event based)
+  ```javascript
+  getInfo('PLwiyx1dc3P2JR9N8gQaQN_BCvlSlap7re').then(info => {
+    // info.partial is true for playlists
+    if (info.partial) {
+      info.on('video', v => console.log(v.title))
+      info.on('done', () => console.log(`Playlist contains ${info.items.length} items.`))
+    }
+  })
+  ```
+
+- Playlists (promise based)
+  ```javascript
+  getInfo('PLwiyx1dc3P2JR9N8gQaQN_BCvlSlap7re', [], true).then(info => {
+    // info.items contains all the playlist items
+  })
+  ```
+
+- Multiple queries at once (acts like a playlist)
+  ```javascript
+  getInfo(['v7BddpYYNGk', 'BMhrBLD_B2U']).then(info => {
+    // ...
+  })
+  ```
+
+## Manually updating the youtube-dl binary
+
+```javascript
+require('ytdl-getinfo').update().then(version => {
+  console.log(`youtube-dl updated to version ${version}`)
+})
+```
+
+## Determining the version of the youtube-dl binary
+
+```javascript
+require('ytdl-getinfo').getVersion().then(version => {
+  console.log(`Current youtube-dl version: ${version}`)
+})
+```

package/ytdl-getinfo/index.js

@@ -0,0 +1,105 @@
+const Playlist = require('./playlist')
+const update = require('./updater')
+const path = require('path')
+const os = require('os')
+const { spawn, execFile } = require('child_process')
+const { platform } = process
+
+module.exports = {
+  update,
+  /**
+   * Gets information about a video url.
+   *
+   * By default, if you don't pass any args to the executable, the following
+   * will be used: --default-search=ytsearch -i
+   *
+   * --dump-json will always be used no matter what.
+   *
+   * Unless wait is set to true, the promise will resolve when there's information
+   * on at least one video.
+   *
+   * @param {string|string[]} query - URL(s) to find.
+   * @param {string[]} args - Arguments passed to the youtube-dl executable.
+   * @param {boolean} wait - Wait for all videos before resolving the promise.
+   * @return {Promise<Playlist>} - A playlist object containing the video information.
+   */
+  getInfo (query, args, wait = false) {
+    return new Promise((resolve, reject) => {
+      let lastError
+      let pData = ''
+      // Checks
+      if (!query) return reject(new Error('No query specified.'))
+      if (typeof query !== 'string' && !(query instanceof Array)) {
+        return reject(new Error('query must be a string or array'))
+      }
+      // Arguments
+      const a = ['--dump-json']
+        .concat(args || ['--default-search=ytsearch', '-i', '--format=best'])
+        .concat(['-a', '-']) // stdin
+      const q = [].concat(query)
+      // Create a playlist object
+      const pl = new Playlist()
+      // Launch the youtube-dl executable
+      const bin = path.join(__dirname, `ytdl`, `youtube-dl${platform === 'win32' ? '.exe' : ''}`)
+      const ytdl = spawn(bin, a, { maxBuffer: Infinity })
+      // Handle errors
+      ytdl.on('error', reject)
+      ytdl.stderr.on('data', d => pl.emit('error', new Error(d)))
+      // Send query
+      ytdl.stdin.end(q.join(os.EOL), 'utf8')
+      // Parse incoming data
+      ytdl.stdout.on('data', d => {
+        pData += d
+        if (pData.indexOf('\n') <= 0) return
+        try {
+          const data = JSON.parse(pData)
+          pl.items.push(data)
+          pl.emit('video', data)
+          if (pl.items.length === 2 && !wait) {
+            // Wait 100ms for the process to exit before resolving the promise
+            // This way, if there's only 2 videos, the playlist will be resolved
+            // with 'partial' set to false.
+            setTimeout(() => {
+              if (pl.partial) {
+                resolve(pl)
+                pl.emit('video', data)
+              }
+            }, 100)
+          }
+        } catch (e) {
+          pl.emit('error', e)
+        }
+        pData = ''
+      })
+      // Close Event
+      ytdl.on('close', code => {
+        pl.partial = false
+        pl.emit('done')
+        // Reject the promise if there are no items and there's a error
+        if (!pl.items.length && code > 0) {
+          return reject(lastError || new Error('Process exited with code ' + code))
+        }
+        // Resolve the promise if wait is set to true or there's only one item
+        if (wait || pl.items.length <= 1) resolve(pl)
+      })
+      // Keep track of the errors
+      pl.on('error', e => { lastError = e })
+      // Add a _cancel function to kill the process
+      pl._cancel = () => ytdl.kill()
+    })
+  },
+  /**
+   * Resolves to the version string of the youtube-dl executable
+   * @return {Promise<string>}
+   */
+  getVersion () {
+    const bin = path.join(__dirname, `ytdl`, `youtube-dl${platform === 'win32' ? '.exe' : ''}`)
+
+    return new Promise((resolve, reject) => {
+      execFile(bin, ['--version'], (error, stdout, stderr) => {
+        if (error || stderr.length) return reject(error || stderr)
+        resolve(stdout)
+      })
+    })
+  }
+}