1.4.0

some episodes would be missing

COOOOKIIIEEEEE!!!!

(I think I'm hungry, I should go to eat!)

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,35 @@
+---
+name: Bug report
+about: Create a report to help us improve
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Please fill theses informations:**
+(Add a X between brackets to make them ticked if relevant)
+ - OS: [e.g:. Windows 10, Mac OS X 10.13, ...]
+ - [ ] I'm using the latest version of Crunchy
+ - [ ] I have a premium accrount on CR
+ - [ ] I am using a VPN
+ - My region in the world (country or continent):
+ - Serie you get a problem with (and specify which episode if it is specific to one):
+ - The command line you are running Crunchy with:
+ - The message Crunchy is giving you, if any:
+
+**Please be careful to remove your real account login and password if they appear!**
+
+
+**Additional context**
+Add any other context about the problem here.
+
+
+_Also don't hesitate to add labels you feel apropriate on your report._
+_Please don't edit logs if you are adding them, apart from removing sensitive informations like login/password_

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,17 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,11 @@
+*Goal for this pull request*
+A clear and concise description of pull request
+
+
+
+### Checklist
+[ ] I've run `npm run compile` and it produce no error
+[ ] I've run `npm run test` and it produce no error
+[ ] I've not pushing more than one feature in that pull request
+[ ] My branch is updated with the latest from main when I make that pull request
+[ ] I've tested as much as I can my changes

.gitignore

@@ -1,8 +1,2 @@
 dist/
 node_modules/
-obj/
-typings/
-*.dat
-*.dll
-*.suo
-*.tmp

.npmignore

@@ -1,16 +1,8 @@
 extras/
 node_modules/
-obj/
 src/
 typings/
-*.dat
-*.DotSettings
-*.dll
-*.map
-*.njsproj
-*.sln
-*.suo
-*.tmp
 ts.js
+tsconfig.json
 tsd.json
-tslint.json
+tslint.json

.travis.yml

@@ -0,0 +1,10 @@
+language: node_js
+sudo: false
+node_js:
+ - 8
+ - 9
+before_install:
+ - npm install --only=dev
+script:
+ - npm run build
+ - npm test

LICENSE

@@ -1,4 +1,5 @@
 Copyright (c) 2015 Roel van Uden
+Copyright (c) 2016 Manoel <Godzil> Trapier
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to

README

@@ -0,0 +1 @@
+README.md

README.md

@@ -1,69 +1,246 @@
-# CrunchyRoll.js
+# Crunchy: a fork of Deathspike/CrunchyRoll.js
 
-*CrunchyRoll.js* is capable of downloading *anime* episodes from the popular
-*CrunchyRoll* streaming service. An episode is stored in the original video format
-(often H.264 in a MP4 container) and the configured subtitle format (ASS or
-SRT).The two output files are then merged into a single MKV file.
+[![Issue Stats](http://issuestats.com/github/Godzil/Crunchy/badge/issue)](http://issuestats.com/github/Godzil/Crunchy) [![Travis CI](https://travis-ci.org/Godzil/Crunchy.svg?branch=master)](https://travis-ci.org/Godzil/Crunchy) [![Maintainability](https://api.codeclimate.com/v1/badges/413c7ca11c0805b1ef3e/maintainability)](https://codeclimate.com/github/Godzil/Crunchy/maintainability) 
+
+*Crunchy* is capable of downloading *anime* episodes from the popular *CrunchyRoll* streaming service. An episode is stored in the original video format (often H.264 in a MP4 container) and the configured subtitle format (ASS or SRT).The two output files are then merged into a single MKV file.
 
 ## Motivation
 
-*CrunchyRoll* has been providing an amazing streaming service and offers the
-best way to enjoy *anime* in a *convenient* and *legal* way. As a streaming
-service, video files cannot be downloaded and watched offline. Understandable
-from a business perspective and considering possible contract implications, but
-annoying for users. This application enables episodes to be downloaded for
-offline convenience. Please do not abuse this application; download episodes for
-**personal use** and **delete them** if you do not have an active premium
-account. Continue to support *CrunchyRoll*; without our financial backing their
-service cannot exist!
+*CrunchyRoll* has been providing an amazing streaming service and offers the best way to enjoy *anime* in a *convenient* and *legal* way. As a streaming service, video files cannot be downloaded and watched offline. Understandable from a business perspective and considering possible contract implications, but annoying for users. This application enables episodes to be downloaded for offline convenience. Please do not abuse this application; download episodes for **personal use** and **delete them** if you do not have an active premium account. Continue to support *CrunchyRoll*; without our financial backing their service cannot exist!
 
 ## Legal Warning
 
-This application is not endorsed or affliated with *CrunchyRoll*. The usage of
-this application enables episodes to be downloaded for offline convenience which
-may be forbidden by law in your country. Usage of this application may also
-cause a violation of the agreed *Terms of Service* between you and the stream
-provider. A tool is not responsible for your actions; please make an informed
-decision prior to using this application.
+This application is not endorsed or affliated with *CrunchyRoll*. The usage of this application enables episodes to be downloaded for offline convenience which may be forbidden by law in your country. Usage of this application may also cause a violation of the agreed *Terms of Service* between you and the stream provider. A tool is not responsible for your actions; please make an informed decision prior to using this application.
 
-## Status
-
-### Implemented
-
-* Subtitle decoding.
-* Subtitle converter for SRT subtitle output.
-* Video streaming.
-* Episode page scraping with subtitle saving and video streaming.
-* Add ASS support.
-* Add muxing (MP4+ASS=MKV).
-* Add series API to save an entire series rather than per-episode.
-* Add support for incremental saves.
-* Add batch-mode to queue a bunch of series.
-* Add CLI interface with all the options.
-* Support scheduled merging; if it fails now, the video is probably being watched.
-* Add authentication to the entire stack to support premium content.
-* Binary runner for `npm`
-* Windows examples with a .bat for ease of use.
-* Publish to `npm` with a fixed package.json.
-* Conversion to beautiful TypeScript 1.4 code.
-
-### Pending Implementation
-
-* Documentation.
-* Enjoy beautiful anime series from disk when internet is down.
+**_ONLY_ USE THIS TOOL IF YOU HAVE A _PREMIUM ACCOUNT_**
 
 ## Configuration
 
-Set defaults in https://www.crunchyroll.com/acct/?action=video. We'll use that.
+You need to authentication (`-p` and `-u`) to use Crunchy so you need to have an account on *CrunchyRool*. It is not possible to download non-free material without an account and premium subscription.
+
+
+## Prerequisites
+
+* NodeJS >= 8.1 (http://nodejs.org/)
+* NPM >= 5.8 (https://www.npmjs.org/)
+
+## Installation
+
+Use the applicable instructions to install. Is your operating system not listed? Please ask or contribute!
+
+### Linux (Debian, Mint, Ubuntu, etc)
+
+1. Run in *Terminal*: `sudo apt-get install nodejs npm mkvtoolnix rtmpdump ffmpeg`
+2. Run in *Terminal*: `sudo ln -s /usr/bin/nodejs /usr/bin/node`
+3. Run in *Terminal*: `sudo npm install -g crunchy`
+
+#### Updating:
+1. Run in *Terminal*: `sudo npm update -g crunchy`
+
+### Mac OS X
+
+1. Install *Homebrew* following the instructions at http://brew.sh/
+2. Run in *Terminal*: `brew install node mkvtoolnix rtmpdump ffmpeg`
+3. Run in *Terminal*: `npm install -g crunchy`
+
+#### Updating:
+1. Run in *Terminal*: `sudo npm update -g crunchy`
+
+### Windows
+
+1. Install *NodeJS* following the instructions at http://nodejs.org/
+3. Run in *Command Prompt*: `npm install -g crunchy`
+
+#### Updating:
+1. Run in *Command Prompt*: `npm update -g crunchy`
+
+## Instructions
+
+Use the applicable instructions for the interface of your choice (currently limited to command-line).
+
+### Command-line Interface (`crunchy`)
+
+The [command-line interface](http://en.wikipedia.org/wiki/Command-line_interface) does not have a graphical component and is ideal for automation purposes and headless machines. The interface can run using a sequence of series addresses (the site address containing the episode listing), or with a batch-mode source file. The `crunchy --help` command will produce the following output:
+
+    Usage: crunchy [options]
+
+    Options:
+
+        -V, --version         output the version number
+        -p, --pass <s>        The password.
+        -u, --user <s>        The e-mail address or username.
+        -d, --unlog           Unlog
+        -c, --cache           Disables the cache.
+        -m, --merge           Disables merging subtitles and videos.
+        -e, --episodes <s>    Episode list. Read documentation on how to use
+        -f, --format <s>      The subtitle format. (default: ass)
+        -o, --output <s>      The output path.
+        -s, --series <s>      The series name override.
+        --ignoredub           Experimental: Ignore all seasons where the title end with 'Dub)'
+        -n, --nametmpl <s>    Output name template (default: {SERIES_TITLE} - s{SEASON_NUMBER}e{EPISODE_NUMBER} - [{TAG}])
+        -t, --tag <s>         The subgroup. (default: CrunchyRoll)
+        -r, --resolution <s>  The video resolution. (valid: 360, 480, 720, 1080) (default: 1080)
+        -b, --batch <s>       Batch file (default: CrunchyRoll.txt)
+        --verbose             Make tool verbose
+        --rebuildcrp          Rebuild the crpersistant file.
+        --retry <i>           Number or time to retry fetching an episode. (default: 5)
+        -h, --help            output usage information
+
+#### Batch-mode
+
+When no sequence of series addresses is provided, the batch-mode source file will be read (which is *CrunchyRoll.txt* in the current work directory. Each line in this file is processed contain the URL of a series and can support some of the command line parameter (like `-e`). This makes it ideal to manage a large sequence of series addresses.
+
+#### Configuration file
+
+Starting from version 1.4.0, Crunchy store some information in a config.json file. The file which is use have to be in the folder you are calling Crunchy. This is partly by design and a limitation on where Crunchy can find files.
+
+This file store some informations like your username and password.
+
+You don't need to create that file as Crunchy will create it for you, the first time you run it. Each run will update the content of the file, so it you run crunchy with your credential on the command line, it will add them to config file.
+
+There are some parameter that the config file can accept which are not created by default, and some of them are cannont be set form the command line parameter.
+
+Don't mess with them if you don't know what you are doing.
+
+Here are the list of valid parameter in the config file:
+
+ - Output options
+  * `merge` see `--merge`
+  * `format` see `--format`
+  * `output` see `--output`
+  * `nametmpl` see `--nametmpl`
+  * `tag` see `--tag`
+  * `resolution` see `--resolution`
+
+ - Login related options:
+  * `pass` see `--user`
+  * `user` see `--pass`
+  * `userAgent` set the user agent reported by Crunchy while crawling pages
+  * `logUsingApi`
+  * `logUsingCookie`
+  * `crSessionUrl`
+  * `crDeviceType`
+  * `crAPIVersion`
+  * `crLocale`
+  * `crSessionKey`
+  * `crLoginUrl`
+  * `crUserId`
+  * `crUserKey`
+
+ - Generated values: don't touch them:
+  * `crDeviceId`
+  * `crSessionId`
+
+Some of theses login related options are not going to be documented on what to put there for _legal_ reason.
+
+Crunchy will also create a `.cookie.jar` file in the output folder (by default the current folder) it is the file used by Crunchy to store the web cookies.
+
+#### Examples
+
+Download in batch-mode:
+
+ You will need to create the batch file (default name is `CrunchyRoll.txt`):
+
+    http://www.cr.com/tail-fairy
+    http://www.cr.com/gin-mama
+    http://www.cr.com/two-parts
+    // Just download episodes 3 to 42
+    http://www.cr.com/defense-of-dwarfs -e 3-42
+
+ Then launch crunchy:
+
+    crunchy -u login -p password http://www.cr.com/tail-fairy
+
+Download *Tail Fairy* to the current work directory:
+
+    crunchy -u login -p password http://www.cr.com/tail-fairy
+
+Download *Tail Fairy* to `C:\Anime`:
+
+    crunchy -u login -p password --output C:\Anime http://www.cr.com/tail-fairy
+
+Download episode 42 of *Tail Fairy* to `C:\Anime`:
+
+    crunchy -u login -p password --output C:\Anime @http://www.cr.com/tail-fairy/episode-42-the-episode-which-dont-exist-665544
+
+  *Notice the '@' in front of the URL, it is there to tell Crunchy that the URL is an episode URL and not a series URL.*
+
+ or 
+
+    crunchy -u login -p password --output C:\Anime http://www.cr.com/tail-fairy -e 42
+
+Download episode 10 to 42 (both included) of *Tail Fairy*:
+
+    crunchy -u login -p password http://www.cr.com/tail-fairy -e 10-42
+
+Download episode up to 42 (included) of *Tail Fairy*:
+
+    crunchy -u login -p password http://www.cr.com/tail-fairy -e -42
+
+Download episodes starting from 42 to the last available of *Tail Fairy*:
+
+    crunchy -u login -p password http://www.cr.com/tail-fairy -e 42-
+
+
+
+#### Command line parameters
+
+##### Authentication
+
+* `-p or --pass <s>` sets the password.
+* `-u or --user <s>` sets the e-mail address or username.
+* `-d or --unlog` unlog
+
+_New in 1.4.0_: Crunchy remember between run about login information and other, so you need to passe the login and password only once
+I recommend to unlog if you see some problems during the run.
+
+*When you unlog, the cookie file is deleted as for some parameter in the config file (like username and password).*
+
+##### Disables
+
+* `-c or --cache` disables the cache in batch mode.
+* `-m or --merge` disables merging subtitles and videos.
+
+##### Settings
+
+* `-e or --episodes <s>` set an episode
+* `-f or --format <s>` sets the subtitle format. (Default: ass)
+* `-o or --output <s>` sets the output path.
+* `-s or --series <s>` sets the series override.
+* `-t or --tag <s>` sets The subgroup. (Default: CrunchyRoll)
+* `-r or --resolution <s>` sets the resolutoin you want to download (360, 480, 720, 1080)
+* `--retry <i>` set the number of try Crunchy will use if downloading a serie or episode fail
+* `--ignoredub` It is an experimental features that will ignore all season where the name ends with 'dub)'. The idea is to try to ignore dubbed season.
+
+##### Others
+
+* `-b or --batch <s>` specify the batch file to use. Default to "CrunchyRoll.txt"
+* `--verbose` make Crunchy really verbose. You should use it only for bug reporting or to try to see why it does not work
+* `-g or --rebuildcrp` use that parameter only if the .crpersistent file has been corrupted and Crunchy try to redownload everything. It will try to rebuild the cache file from the file if find. If you renamed of move any file they will be ignored and not added to the cache file.
+
+
+## When things goes wrong
+
+First, make sure you have the latest version of Crunchy installed, if you run an older version, the issue you face may have been solved.
+
+Second thing to check, you have to give your credentials (-u and -p parameters) each time you run Crunchy. It does not actually store the token it receive when login and need to relog each time it is called. This may change in the future.
+
+Third, is it a recently released episode? If yes, sometimes CR have issues were the requested format is not available, and Crunchy is not able to get it. When in doubt, try to watch CR website, if it does not work there, Crunchy will not either. This is valid in all cases even on non recently released.
+
+Fourth, sometimes, CR website does weird things, and there are some transient errors, wait a couple of minutes (or hours) and try again. It has really often solved lots of weird issue on my side (yes I know that's not really a way of fixing, but if the error is on CR side, Crunchy can't do anything)
+
+If really nothing works or you find a problem with Crunchy, then you can go and fill an Issue, first read the already open and closed one to make sure you are not reporting an existing problem. If your problem has been already reported, what you can do is to either:
+- Add a comment saying you also have the same issue
+- Add a Thumbs Up reaction to the original entry in the issue, I use them as a metric to know how many people are annoyed by that issue
+If you find one which correspond and it is close, don't hesitate to add a comment, the issue may have not be fully solved.
+
+If there is no comparable opened or close issue, you are welcome to create a new one.
 
 ## Developers
 
-* Visual Studio 2013 Update 4 (Core)
-* NodeJS Tools (Debugging)
-* TypeScript 1.4 (Language)
-* ReSharper 9.0+ (Hints/Formatting)
-* Web Essentials (TSLint)
+More information will be added at a later point. For now the recommendations are:
 
-## Work In Progress
+* Atom with `atom-typescript` and `linter-tslint` (and dependencies).
+
+Since this project uses TypeScript, compile with `node run compile` to build the tool and `npm run test` to run the linter.
 
-Open an issue or e-mail me directly. I'd be happy to answer your questions.

bin/crunchy.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+PARAMS=$*
+for i in {1..20}; do
+	crunchy ${PARAMS}
+	if [ $? == 0 ]; then
+	 	break
+	fi
+	echo "Going to retry..."	
+	sleep 3
+done

crunchyroll.js.njsproj

@@ -1,102 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <EnableTypeScript>True</EnableTypeScript>
-    <OutputPath>.</OutputPath>
-    <ProjectGuid>{c5cff68a-d733-4347-83e7-6e5fe58eb0e3}</ProjectGuid>
-    <ProjectHome />
-    <ProjectTypeGuids>{3AF33F2E-1136-4D97-BBB7-1795711AC8B8};{349c5851-65df-11da-9384-00065b846f21};{9092AA53-FB77-4645-B42D-1CCCA6BD08BD}</ProjectTypeGuids>
-    <ProjectView>ShowAllFiles</ProjectView>
-    <SchemaVersion>2.0</SchemaVersion>
-    <StartupFile>cli.ts</StartupFile>
-    <TypeScriptModuleKind>CommonJS</TypeScriptModuleKind>
-    <TypeScriptNoImplicitAny>True</TypeScriptNoImplicitAny>
-    <TypeScriptOutDir>dist</TypeScriptOutDir>
-    <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">11.0</VisualStudioVersion>
-    <VSToolsPath Condition="'$(VSToolsPath)' == ''">$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)</VSToolsPath>
-    <WorkingDirectory>.</WorkingDirectory>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)' == 'Debug'">
-    <TypeScriptSourceMap>True</TypeScriptSourceMap>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)' == 'Release'">
-    <TypeScriptGeneratesDeclarations>True</TypeScriptGeneratesDeclarations>
-  </PropertyGroup>
-  <ItemGroup>
-    <TypeScriptCompile Include="src\cli.ts" />
-    <TypeScriptCompile Include="src\batch.ts" />
-    <TypeScriptCompile Include="src\episode.ts" />
-    <TypeScriptCompile Include="src\index.ts" />
-    <TypeScriptCompile Include="src\request.ts" />
-    <TypeScriptCompile Include="src\series.ts" />
-    <TypeScriptCompile Include="src\subtitle\decode.ts" />
-    <TypeScriptCompile Include="src\subtitle\formats\ass.ts" />
-    <TypeScriptCompile Include="src\subtitle\formats\index.ts" />
-    <TypeScriptCompile Include="src\subtitle\formats\srt.ts" />
-    <TypeScriptCompile Include="src\subtitle\index.ts" />
-    <TypeScriptCompile Include="src\typings.ts" />
-    <TypeScriptCompile Include="src\video\index.ts" />
-    <TypeScriptCompile Include="src\video\merge.ts" />
-    <TypeScriptCompile Include="src\video\stream.ts" />
-    <TypeScriptCompile Include="typings\big-integer\big-integer.d.ts" />
-    <TypeScriptCompile Include="typings\cheerio\cheerio.d.ts" />
-    <TypeScriptCompile Include="typings\commander\commander.d.ts" />
-    <TypeScriptCompile Include="typings\form-data\form-data.d.ts" />
-    <TypeScriptCompile Include="typings\mkdirp\mkdirp.d.ts" />
-    <TypeScriptCompile Include="typings\node\node.d.ts" />
-    <TypeScriptCompile Include="typings\request\request.d.ts" />
-    <TypeScriptCompile Include="typings\xml2js\xml2js.d.ts" />
-  </ItemGroup>
-  <ItemGroup>
-    <Folder Include="src\" />
-    <Folder Include="src\subtitle\" />
-    <Folder Include="src\subtitle\formats\" />
-    <Folder Include="src\video\" />
-    <Folder Include="typings" />
-    <Folder Include="typings\big-integer\" />
-    <Folder Include="typings\cheerio\" />
-    <Folder Include="typings\commander\" />
-    <Folder Include="typings\form-data\" />
-    <Folder Include="typings\mkdirp\" />
-    <Folder Include="typings\node" />
-    <Folder Include="typings\request\" />
-    <Folder Include="typings\xml2js\" />
-  </ItemGroup>
-  <Import Project="$(MSBuildToolsPath)\Microsoft.Common.targets" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
-  <Import Project="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\TypeScript\Microsoft.TypeScript.targets" Condition="False" />
-  <Import Project="$(VSToolsPath)\Node.js Tools\Microsoft.NodejsTools.targets" />
-  <ProjectExtensions>
-    <VisualStudio>
-      <FlavorProperties GUID="{349c5851-65df-11da-9384-00065b846f21}">
-        <WebProjectProperties>
-          <AutoAssignPort>True</AutoAssignPort>
-          <CustomServerUrl>http://localhost:1337</CustomServerUrl>
-          <DevelopmentServerPort>0</DevelopmentServerPort>
-          <DevelopmentServerVPath>/</DevelopmentServerVPath>
-          <IISUrl>http://localhost:48022/</IISUrl>
-          <NTLMAuthentication>False</NTLMAuthentication>
-          <SaveServerSettingsInUserFile>False</SaveServerSettingsInUserFile>
-          <UseCustomServer>True</UseCustomServer>
-          <UseIIS>False</UseIIS>
-        </WebProjectProperties>
-      </FlavorProperties>
-      <FlavorProperties GUID="{349c5851-65df-11da-9384-00065b846f21}" User="">
-        <WebProjectProperties>
-          <AlwaysStartWebServerOnDebug>False</AlwaysStartWebServerOnDebug>
-          <AspNetDebugging>True</AspNetDebugging>
-          <EnableENC>False</EnableENC>
-          <ExternalProgram />
-          <NativeDebugging>False</NativeDebugging>
-          <SilverlightDebugging>False</SilverlightDebugging>
-          <SQLDebugging>False</SQLDebugging>
-          <StartAction>CurrentPage</StartAction>
-          <StartCmdLineArguments />
-          <StartExternalURL />
-          <StartPageUrl />
-          <StartWorkingDirectory />
-        </WebProjectProperties>
-      </FlavorProperties>
-    </VisualStudio>
-  </ProjectExtensions>
-</Project>

crunchyroll.js.sln

@@ -1,22 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 2013
-VisualStudioVersion = 12.0.31101.0
-MinimumVisualStudioVersion = 10.0.40219.1
-Project("{9092AA53-FB77-4645-B42D-1CCCA6BD08BD}") = "crunchyroll.js", "crunchyroll.js.njsproj", "{C5CFF68A-D733-4347-83E7-6E5FE58EB0E3}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Any CPU = Debug|Any CPU
-		Release|Any CPU = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{C5CFF68A-D733-4347-83E7-6E5FE58EB0E3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{C5CFF68A-D733-4347-83E7-6E5FE58EB0E3}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{C5CFF68A-D733-4347-83E7-6E5FE58EB0E3}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{C5CFF68A-D733-4347-83E7-6E5FE58EB0E3}.Release|Any CPU.Build.0 = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-EndGlobal

crunchyroll.js.sln.DotSettings

@@ -1,65 +0,0 @@
-<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
-	<s:String x:Key="/Default/CodeEditing/Intellisense/CodeCompletion/IntellisenseGloballyEnabled/IntellisenseEnabled/@EntryValue">Disabled</s:String>
-	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=DeclarationHides/@EntryIndexedValue">DO_NOT_SHOW</s:String>
-	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=InconsistentNaming/@EntryIndexedValue">DO_NOT_SHOW</s:String>
-	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=NotAllPathsReturnValue/@EntryIndexedValue">DO_NOT_SHOW</s:String>
-	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=RedundantQualifier/@EntryIndexedValue">DO_NOT_SHOW</s:String>
-	
-	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=SpecifyVariableTypeExplicitly/@EntryIndexedValue">DO_NOT_SHOW</s:String>
-	<s:String x:Key="/Default/CodeInspection/TypeScriptInspections/Level/@EntryValue">TypeScript14</s:String>
-	<s:String x:Key="/Default/CodeStyle/CodeCleanup/Profiles/=TypeScript/@EntryIndexedValue">&lt;?xml version="1.0" encoding="utf-16"?&gt;&lt;Profile name="TypeScript"&gt;&lt;FormatAttributeQuoteDescriptor&gt;True&lt;/FormatAttributeQuoteDescriptor&gt;&lt;JsReformatCode&gt;True&lt;/JsReformatCode&gt;&lt;JsFormatDocComments&gt;True&lt;/JsFormatDocComments&gt;&lt;JsInsertSemicolon&gt;True&lt;/JsInsertSemicolon&gt;&lt;RemoveRedundantQualifiersTs&gt;True&lt;/RemoveRedundantQualifiersTs&gt;&lt;OptimizeImportsTs&gt;True&lt;/OptimizeImportsTs&gt;&lt;OptimizeReferenceCommentsTs&gt;True&lt;/OptimizeReferenceCommentsTs&gt;&lt;PublicModifierStyleTs&gt;True&lt;/PublicModifierStyleTs&gt;&lt;RelativePathStyleTs&gt;True&lt;/RelativePathStyleTs&gt;&lt;TypeAnnotationStyleTs&gt;True&lt;/TypeAnnotationStyleTs&gt;&lt;/Profile&gt;</s:String>
-	<s:String x:Key="/Default/CodeStyle/CodeCleanup/SilentCleanupProfile/@EntryValue">TypeScript</s:String>
-	<s:String x:Key="/Default/CodeStyle/CodeFormatting/JavaScriptCodeFormatting/FORCE_CONTROL_STATEMENTS_BRACES/@EntryValue">ONLY_FOR_MULTILINE</s:String>
-	<s:Int64 x:Key="/Default/CodeStyle/CodeFormatting/JavaScriptCodeFormatting/KEEP_BLANK_LINES_BETWEEN_DECLARATIONS/@EntryValue">1</s:Int64>
-	<s:Int64 x:Key="/Default/CodeStyle/CodeFormatting/JavaScriptCodeFormatting/KEEP_BLANK_LINES_IN_CODE/@EntryValue">1</s:Int64>
-	<s:String x:Key="/Default/CodeStyle/CodeFormatting/JavaScriptCodeFormatting/QUOTE_STYLE/@EntryValue">SingleQuoted</s:String>
-	
-	
-	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/JavaScriptCodeFormatting/SPACE_WITHIN_OBJECT_LITERAL_BRACES/@EntryValue">False</s:Boolean>
-	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/JavaScriptCodeFormatting/STICK_COMMENT/@EntryValue">False</s:Boolean>
-	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=JS_005FBLOCK_005FSCOPE_005FCONSTANT/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=JS_005FBLOCK_005FSCOPE_005FVARIABLE/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=JS_005FCONSTRUCTOR/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=JS_005FFUNCTION/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=JS_005FGLOBAL_005FVARIABLE/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=JS_005FLABEL/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=JS_005FLOCAL_005FVARIABLE/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=JS_005FOBJECT_005FPROPERTY_005FOF_005FFUNCTION/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=JS_005FPARAMETER/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FCLASS/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FENUM/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FENUM_005FMEMBER/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FINTERFACE/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="I" Suffix="" Style="AaBb" /&gt;</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FINTERFACE_005FFOR_005FJS_005FGLOBAL_005FVARIABLE/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FMODULE/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FMODULE_005FEXPORTED/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FMODULE_005FLOCAL/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FPRIVATE_005FMEMBER_005FACCESSOR/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FPRIVATE_005FSTATIC_005FTYPE_005FFIELD/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FPRIVATE_005FTYPE_005FFIELD/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FPRIVATE_005FTYPE_005FMETHOD/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FPROTECTED_005FMEMBER_005FACCESSOR/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FPROTECTED_005FSTATIC_005FTYPE_005FFIELD/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FPROTECTED_005FTYPE_005FFIELD/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FPROTECTED_005FTYPE_005FMETHOD/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FPUBLIC_005FMEMBER_005FACCESSOR/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FPUBLIC_005FSTATIC_005FTYPE_005FFIELD/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FPUBLIC_005FTYPE_005FFIELD/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FPUBLIC_005FTYPE_005FMETHOD/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FTYPE_005FPARAMETER/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="T" Suffix="" Style="AaBb" /&gt;</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/WebNaming/UserRules/=ASP_005FFIELD/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/WebNaming/UserRules/=ASP_005FHTML_005FCONTROL/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/WebNaming/UserRules/=ASP_005FTAG_005FNAME/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/WebNaming/UserRules/=ASP_005FTAG_005FPREFIX/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/XamlNaming/UserRules/=NAMESPACE_005FALIAS/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/XamlNaming/UserRules/=XAML_005FFIELD/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/XamlNaming/UserRules/=XAML_005FRESOURCE/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
-	<s:Boolean x:Key="/Default/CodeStyle/TypeScriptCodeStyle/ExplicitPublicModifier/@EntryValue">True</s:Boolean>
-	<s:String x:Key="/Default/CodeStyle/TypeScriptCodeStyle/FileReferenceStyle/@EntryValue">RelativeDotSlash</s:String>
-	<s:Boolean x:Key="/Default/CodeStyle/TypeScriptCodeStyle/NoImplicitAny/@EntryValue">True</s:Boolean>
-	
-	<s:Boolean x:Key="/Default/CodeStyle/TypeScriptCodeStyle/PreferUsingAliases/@EntryValue">False</s:Boolean>
-	<s:Boolean x:Key="/Default/Environment/InjectedLayers/FileInjectedLayer/=AAA631615CEE9646AA8766F222F9457C/@KeyIndexDefined">True</s:Boolean>
-	<s:String x:Key="/Default/Environment/InjectedLayers/FileInjectedLayer/=AAA631615CEE9646AA8766F222F9457C/AbsolutePath/@EntryValue">C:\Dropbox\Github\crunchyroll.js\crunchyroll.js.sln.DotSettings</s:String>
-	<s:Boolean x:Key="/Default/Environment/InjectedLayers/InjectedLayerCustomization/=FileAAA631615CEE9646AA8766F222F9457C/@KeyIndexDefined">True</s:Boolean>
-	<s:Double x:Key="/Default/Environment/InjectedLayers/InjectedLayerCustomization/=FileAAA631615CEE9646AA8766F222F9457C/RelativePriority/@EntryValue">1</s:Double></wpf:ResourceDictionary>

package.json

@@ -1,36 +1,63 @@
 {
-  "author": "Roel van Uden",
-  "description": "CrunchyRoll.js is capable of downloading anime episodes from the popular CrunchyRoll streaming service.",
+  "author": "Godzil",
+  "description": "Crunchy is a fork of Crunchyroll.js, capable of downloading anime episodes from the popular CrunchyRoll streaming service.",
+  "license": "MIT",
   "keywords": [
     "anime",
     "download",
     "crunchyroll"
   ],
-  "name": "crunchyroll",
+  "name": "crunchy",
   "repository": {
     "type": "git",
-    "url": "git://github.com/Deathspike/crunchyroll.js.git"
+    "url": "git://github.com/Godzil/crunchyroll.js.git"
   },
-  "version": "1.1.0",
+  "engines": {
+    "node": ">=5.0"
+  },
+  "version": "1.4.0",
   "bin": {
-    "crunchyroll": "./bin/crunchyroll"
+    "crunchy": "./bin/crunchy",
+    "crunchy.sh": "./bin/crunchy.sh"
   },
   "dependencies": {
-    "big-integer": "^1.4.3",
-    "cheerio": "^0.18.0",
-    "commander": "^2.6.0",
+    "big-integer": "^1.6.32",
+    "bluebird": "^3.5.1",
+    "cheerio": "^0.22.0",
+    "cloudscraper": "^1.5.0",
+    "commander": "^2.16.0",
+    "fs-extra": "^7.0.0",
     "mkdirp": "^0.5.0",
-    "request": "^2.53.0",
-    "xml2js": "^0.4.4"
+    "pjson": "^1.0.9",
+    "request": "^2.87.0",
+    "request-promise": "^4.2.2",
+    "tough-cookie-file-store": "^1.2.0",
+    "uuid": "^3.3.2",
+    "xml2js": "^0.4.5"
   },
   "devDependencies": {
-    "tsd": "^0.5.7",
-    "tslint": "^2.1.0",
-    "typescript": "^1.4.1"
+    "@types/bluebird": "^3.5.23",
+    "@types/cheerio": "^0.22.8",
+    "@types/fs-extra": "^5.0.4",
+    "@types/mkdirp": "^0.5.2",
+    "@types/node": "^10.5.3",
+    "@types/request": "^2.47.1",
+    "@types/request-promise": "^4.1.42",
+    "@types/uuid": "^3.4.3",
+    "@types/xml2js": "^0.4.3",
+    "npm-check": "^5.7.1",
+    "tsconfig-lint": "^0.12.0",
+    "tslint": "^5.11.0",
+    "typescript": "^2.9.2"
   },
   "scripts": {
-    "prepublish": "npm run tsd && node ts",
-    "test":  "node ts --only-test",
-    "tsd": "./node_modules/.bin/tsd reinstall --overwrite"
+    "prepublishOnly": "npm run build",
+    "compile": "tsc",
+    "build": "tsc",
+    "test": "tslint --project .",
+    "start": "node ./bin/crunchy"
+  },
+  "bugs": {
+    "url": "https://github.com/Godzil/Crunchy/issues"
   }
-}
+}

src/batch.ts

@@ -1,25 +1,160 @@
 'use strict';
-export = main;
 import commander = require('commander');
 import fs = require('fs');
 import path = require('path');
-import series = require('./series');
-import typings = require('./typings');
+import log = require('./log');
+import my_request = require('./my_request');
+import cfg = require('./config');
+import series from './series';
+
+/* correspondances between resolution and value CR excpect */
+const resol_table: { [id: string]: IResolData; } =
+{
+    360:  {quality: '60', format: '106'},
+    480:  {quality: '61', format: '106'},
+    720:  {quality: '62', format: '106'},
+    1080: {quality: '80', format: '108'},
+};
 
 /**
  * Streams the batch of series to disk.
  */
-function main(args: string[], done: (err?: Error) => void) {
-  var config = parse(args);
-  var batchPath = path.join(config.output || process.cwd(), 'CrunchyRoll.txt');
-  tasks(config, batchPath, (err, tasks) => {
-    if (err) return done(err);
-    var i = 0;
-    (function next() {
-      if (i >= tasks.length) return done();
-      series(tasks[i].config, tasks[i].address, err => {
-        if (err) return done(err);
-        i += 1;
+export default function(args: string[], done: (err?: Error) => void)
+{
+  const config = Object.assign(cfg.load(), parse(args));
+  let batchPath;
+
+  if (path.isAbsolute(config.batch))
+  {
+    batchPath = path.normalize(config.batch);
+  }
+  else
+  {
+    batchPath = path.normalize(path.join(process.cwd(), config.batch));
+  }
+
+  // Update the config file with new parameters
+  cfg.save(config);
+
+  if (config.unlog)
+  {
+    config.crDeviceId = undefined;
+    config.user = undefined;
+    config.pass = undefined;
+    my_request.eatCookies(config);
+    cfg.save(config);
+    log.info('Unlogged!');
+
+    process.exit(0);
+  }
+
+  // set resolution
+  if (config.resolution)
+  {
+    try
+    {
+      config.video_format = resol_table[config.resolution].format;
+      config.video_quality = resol_table[config.resolution].quality;
+    }
+    catch (e)
+    {
+      log.warn('Invalid resolution ' + config.resolution + 'p. Setting to 1080p');
+      config.video_format = resol_table['1080'].format;
+      config.video_quality = resol_table['1080'].quality;
+    }
+  }
+  else
+  {
+    /* 1080 by default */
+    config.video_format = resol_table['1080'].format;
+    config.video_quality = resol_table['1080'].quality;
+  }
+
+  if (config.debug)
+  {
+    /* Ugly but meh */
+    const tmp = JSON.parse(JSON.stringify(config));
+    tmp.pass = 'obfuscated';
+    tmp.user = 'obfustated';
+    tmp.rawArgs = undefined;
+    tmp.options = undefined;
+    log.dumpToDebug('Config', JSON.stringify(tmp), true);
+  }
+
+  tasks(config, batchPath, (err, tasksArr) =>
+  {
+    if (err)
+    {
+        return done(err);
+    }
+
+    if (tasksArr[0].address === '')
+    {
+        return done();
+    }
+
+    let i = 0;
+
+    (function next()
+    {
+      if (i >= tasksArr.length)
+      {
+        // Save configuration before leaving (should store info like session & other)
+        cfg.save(config);
+
+        return done();
+      }
+
+      if (config.debug)
+      {
+        log.dumpToDebug('Task ' + i, JSON.stringify(tasksArr[i]));
+      }
+
+      series(config, tasksArr[i], (errin) =>
+      {
+        if (errin)
+        {
+          if (errin.error)
+          {
+            /* Error from the request, so ignore it */
+            tasksArr[i].retry = 0;
+          }
+
+          if (errin.authError)
+          {
+            /* Force a graceful exit */
+            log.error(errin.message);
+            i = tasksArr.length;
+          }
+          else if (tasksArr[i].retry <= 0)
+          {
+            log.error(JSON.stringify(errin));
+            if (config.debug)
+            {
+              log.dumpToDebug('BatchGiveUp', JSON.stringify(errin));
+            }
+            log.error('Cannot get episodes from "' + tasksArr[i].address + '", please rerun later');
+            /* Go to the next on the list */
+            i += 1;
+          }
+          else
+          {
+            if (config.verbose)
+            {
+              log.error(JSON.stringify(errin));
+            }
+            if (config.debug)
+            {
+              log.dumpToDebug('BatchRetry', JSON.stringify(errin));
+            }
+            log.warn('Retrying to fetch episodes list from' + tasksArr[i].retry + ' / ' + config.retry);
+            tasksArr[i].retry -= 1;
+          }
+        }
+        else
+        {
+          i += 1;
+        }
         next();
       });
     })();
@@ -29,42 +164,160 @@ function main(args: string[], done: (err?: Error) => void) {
 /**
  * Splits the value into arguments.
  */
-function split(value: string): string[] {
-  var inQuote = false;
-  var i: number;
-  var pieces: string[] = [];
-  var previous = 0;
-  for (i = 0; i < value.length; i += 1) {
-    if (value.charAt(i) === '"') inQuote = !inQuote;
-    if (!inQuote && value.charAt(i) === ' ') {
+function split(value: string): string[]
+{
+  let inQuote = false;
+  let i: number;
+  const pieces: string[] = [];
+  let previous = 0;
+
+  for (i = 0; i < value.length; i += 1)
+  {
+    if (value.charAt(i) === '"')
+    {
+      inQuote = !inQuote;
+    }
+
+    if (!inQuote && value.charAt(i) === ' ')
+    {
       pieces.push(value.substring(previous, i).match(/^"?(.+?)"?$/)[1]);
       previous = i + 1;
     }
   }
-  pieces.push(value.substring(previous, i).match(/^"?(.+?)"?$/)[1]);
+
+  const lastPiece = value.substring(previous, i).match(/^"?(.+?)"?$/);
+
+  if (lastPiece)
+  {
+    pieces.push(lastPiece[1]);
+  }
+
   return pieces;
 }
 
+function get_min_filter(filter: string): number
+{
+  if (filter !== undefined)
+  {
+    const tok = filter.split('-');
+
+    if (tok.length > 2)
+    {
+      log.error('Invalid episode filter \'' + filter + '\'');
+      process.exit(-1);
+    }
+
+    if (tok[0] !== '')
+    {
+      return parseInt(tok[0], 10);
+    }
+  }
+  return 0;
+}
+
+function get_max_filter(filter: string): number
+{
+  if (filter !== undefined)
+  {
+    const tok = filter.split('-');
+
+    if (tok.length > 2)
+    {
+      log.error('Invalid episode filter \'' + filter + '\'');
+      process.exit(-1);
+    }
+
+    if ((tok.length > 1) && (tok[1] !== ''))
+    {
+      /* We have a max value */
+      return parseInt(tok[1], 10);
+    }
+    else if ((tok.length === 1) && (tok[0] !== ''))
+    {
+      /* A single episode has been requested */
+      return parseInt(tok[0], 10);
+    }
+  }
+  return +Infinity;
+}
+
+/**
+ * Check that URL start with http:// or https://
+ * As for some reason request just return an error but a useless one when that happen so check it
+ * soon enough.
+ */
+function checkURL(address: string): boolean
+{
+  if (address.startsWith('http:\/\/'))
+  {
+    return true;
+  }
+  if (address.startsWith('http:\/\/'))
+  {
+    return true;
+  }
+
+  log.error('URL ' + address + ' miss \'http:\/\/\' or \'https:\/\/\' => will be ignored');
+
+  return false;
+}
+
 /**
  * Parses the configuration or reads the batch-mode file for tasks.
  */
-function tasks(config: typings.IConfigLine, batchPath: string, done: (err: Error, tasks?: typings.IConfigTask[]) => void) {
-  if (config.args.length) {
-    return done(null, config.args.map(address => {
-      return {address: address, config: config};
+function tasks(config: IConfigLine, batchPath: string, done: (err: Error, tasks?: IConfigTask[]) => void)
+{
+  if (config.args.length)
+  {
+    return done(null, config.args.map((addressIn) =>
+    {
+      if (checkURL(addressIn))
+      {
+        return {address: addressIn, retry: config.retry,
+                episode_min: get_min_filter(config.episodes), episode_max: get_max_filter(config.episodes)};
+      }
+
+      return {address: '', retry: 0, episode_min: 0, episode_max: 0};
     }));
   }
-  fs.exists(batchPath, exists => {
-    if (!exists) return done(null, []);
-    fs.readFile(batchPath, 'utf8', (err, data) => {
-      if (err) return done(err);
-      var map: typings.IConfigTask[] = [];
-      data.split(/\r?\n/).forEach(line => {
-        if (/^(\/\/|#)/.test(line)) return;
-        var lineConfig = parse(process.argv.concat(split(line)));
-        lineConfig.args.forEach(address => {
-          if (!address) return;
-          map.push({address: address, config: lineConfig});
+
+  fs.exists(batchPath, (exists) =>
+  {
+    if (!exists)
+    {
+      return done(null, []);
+    }
+
+    fs.readFile(batchPath, 'utf8', (err, data) =>
+    {
+      if (err)
+      {
+        return done(err);
+      }
+
+      const map: IConfigTask[] = [];
+
+      data.split(/\r?\n/).forEach((line) =>
+      {
+        if (/^(\/\/|#)/.test(line))
+        {
+          return;
+        }
+
+        const lineConfig = parse(process.argv.concat(split(line)));
+
+        lineConfig.args.forEach((addressIn) =>
+        {
+          if (!addressIn)
+          {
+            return;
+          }
+
+          if (checkURL(addressIn))
+          {
+            map.push({address: addressIn, retry: lineConfig.retry,
+                      episode_min: get_min_filter(lineConfig.episodes), episode_max: get_max_filter(lineConfig.episodes)});
+          }
         });
       });
       done(null, map);
@@ -75,21 +328,30 @@ function tasks(config: typings.IConfigLine, batchPath: string, done: (err: Error
 /**
  * Parses the arguments and returns a configuration.
  */
-function parse(args: string[]): typings.IConfigLine {
+function parse(args: string[]): IConfigLine
+{
   return new commander.Command().version(require('../package').version)
     // Authentication
     .option('-p, --pass <s>', 'The password.')
     .option('-u, --user <s>', 'The e-mail address or username.')
+    .option('-d, --unlog', 'Unlog')
     // Disables
     .option('-c, --cache', 'Disables the cache.')
     .option('-m, --merge', 'Disables merging subtitles and videos.')
-    // Filters
-    .option('-e, --episode <i>', 'The episode filter.')
-    .option('-v, --volume <i>', 'The volume filter.')
+    // Episode filter
+    .option('-e, --episodes <s>', 'Episode list. Read documentation on how to use')
     // Settings
-    .option('-f, --format <s>', 'The subtitle format. (Default: ass)')
+    .option('-f, --format <s>', 'The subtitle format.', 'ass')
     .option('-o, --output <s>', 'The output path.')
-    .option('-s, --series <s>', 'The series override.')
-    .option('-t, --tag <s>', 'The subgroup. (Default: CrunchyRoll)')
+    .option('-s, --series <s>', 'The series name override.')
+    .option('--ignoredub', 'Experimental: Ignore all seasons where the title end with \'Dub)\'')
+    .option('-n, --nametmpl <s>', 'Output name template', '{SERIES_TITLE} - s{SEASON_NUMBER}e{EPISODE_NUMBER} - {EPISODE_TITLE} - [{TAG}]')
+    .option('-t, --tag <s>', 'The subgroup.', 'CrunchyRoll')
+    .option('-r, --resolution <s>', 'The video resolution. (valid: 360, 480, 720, 1080)', '1080')
+    .option('-b, --batch <s>', 'Batch file', 'CrunchyRoll.txt')
+    .option('--verbose', 'Make tool verbose')
+    .option('--debug', 'Create a debug file. Use only if requested!')
+    .option('--rebuildcrp', 'Rebuild the crpersistant file.')
+    .option('--retry <i>', 'Number or time to retry fetching an episode.', 5)
     .parse(args);
-}
+}

src/cli.ts

@@ -1,6 +1,41 @@
 'use strict';
-import batch = require('./batch');
+import batch from './batch';
+import request = require('request');
+import log  = require('./log');
+import pjson = require('pjson');
 
-batch(process.argv, (err: any) => {
-  if (err) console.error(err.stack || err);
-});
+const current_version = pjson.version;
+
+/* Check if the current version is the latest */
+log.info('Crunchy version ' + current_version);
+request.get({ uri: 'https://raw.githubusercontent.com/Godzil/Crunchy/master/package.json' },
+                  (error: Error, response: any, body: any) =>
+{
+  const onlinepkg = JSON.parse(body);
+  let tmp = current_version.split('.');
+  const cur = (Number(tmp[0]) * 10000) + (Number(tmp[1]) * 100) + Number(tmp[2]);
+  tmp = onlinepkg.version.split('.');
+  const dist = (Number(tmp[0]) * 10000) + (Number(tmp[1]) * 100) + Number(tmp[2]);
+  if (dist > cur)
+  {
+    log.warn('There is a newer version of crunchy (v' + onlinepkg.version + '), you should update!');
+  }
+});
+
+batch(process.argv, (err: any) =>
+{
+  if (err)
+  {
+    if (err.stack)
+    {
+      console.error(err.stack || err);
+    }
+    else
+    {
+      console.error(err);
+    }
+    process.exit(-1);
+  }
+  console.info('Done!');
+  process.exit(0);
+});

src/config.ts

@@ -0,0 +1,63 @@
+'use strict';
+import os = require('os');
+import fs = require('fs-extra');
+import path = require('path');
+
+const configFile = path.join(process.cwd(), 'config.json');
+
+function fileExist(path: string)
+{
+  try
+  {
+    fs.statSync(path);
+    return true;
+  } catch (e)
+  {
+    return false;
+  }
+}
+
+export function load(): IConfigLine
+{
+  if (fileExist(configFile))
+  {
+    const data = fs.readFileSync(configFile, 'utf8');
+    return JSON.parse(data);
+  }
+
+  return {args: undefined};
+}
+
+export function save(config: IConfig)
+{
+  const tmp = JSON.parse(JSON.stringify(config));
+
+  // Things added by the command line parser
+  tmp.rawArgs = undefined;
+  tmp.options = undefined;
+  tmp._execs = undefined;
+  tmp._args = undefined;
+  tmp._name = undefined;
+  tmp._version = undefined;
+  tmp._versionOptionName = undefined;
+  tmp._events = undefined;
+  tmp._eventsCount = undefined;
+  tmp.args = undefined;
+  tmp.commands = undefined;
+  tmp._allowUnknownOption = undefined;
+
+  // Things we don't want to save
+  tmp.cache = undefined;
+  tmp.episodes = undefined;
+  tmp.series = undefined;
+  tmp.video_format = undefined;
+  tmp.video_quality = undefined;
+  tmp.rebuildcrp = undefined;
+  tmp.batch = undefined;
+  tmp.verbose = undefined;
+  tmp.debug = undefined;
+  tmp.unlog = undefined;
+  tmp.ignoredub = undefined;
+
+  fs.writeFileSync(configFile, JSON.stringify(tmp, null, '  '));
+}

src/episode.ts

@@ -1,23 +1,33 @@
 'use strict';
-export = main;
 import cheerio = require('cheerio');
 import fs = require('fs');
 import mkdirp = require('mkdirp');
-import request = require('./request');
+import my_request = require('./my_request');
 import path = require('path');
-import subtitle = require('./subtitle/index');
-import typings = require('./typings');
-import video = require('./video/index');
+import subtitle from './subtitle/index';
+import video from './video/index';
 import xml2js = require('xml2js');
+import log  = require('./log');
 
 /**
  * Streams the episode to disk.
  */
-function main(config: typings.IConfig, address: string, done: (err: Error) => void) {
-  scrapePage(config, address, (err, page) => {
-    if (err) return done(err);
-    scrapePlayer(config, address, page.id, (err, player) => {
-      if (err) return done(err);
+export default function(config: IConfig, address: string, done: (err: Error, ign: boolean) => void)
+{
+  scrapePage(config, address, (err, page) =>
+  {
+    if (err)
+    {
+      return done(err, false);
+    }
+
+    scrapePlayer(config, address, page.id, (errS, player) =>
+    {
+      if (errS)
+      {
+        return done(errS, false);
+      }
+
       download(config, page, player, done);
     });
   });
@@ -26,36 +36,133 @@ function main(config: typings.IConfig, address: string, done: (err: Error) => vo
 /**
  * Completes a download and writes the message with an elapsed time.
  */
-function complete(message: string, begin: number, done: (err: Error) => void) {
-  var timeInMs = Date.now() - begin;
-  var seconds = prefix(Math.floor(timeInMs / 1000) % 60, 2);
-  var minutes = prefix(Math.floor(timeInMs / 1000 / 60) % 60, 2);
-  var hours = prefix(Math.floor(timeInMs / 1000 / 60 / 60), 2);
-  console.log(message + ' (' + hours + ':' + minutes + ':' + seconds + ')');
-  done(null);
+function complete(epName: string, message: string, begin: number, done: (err: Error, ign: boolean) => void)
+{
+  const timeInMs = Date.now() - begin;
+  const seconds = prefix(Math.floor(timeInMs / 1000) % 60, 2);
+  const minutes = prefix(Math.floor(timeInMs / 1000 / 60) % 60, 2);
+  const hours = prefix(Math.floor(timeInMs / 1000 / 60 / 60), 2);
+
+  log.dispEpisode(epName, message + ' (' + hours + ':' + minutes + ':' + seconds + ')', true);
+
+  done(null, false);
+}
+
+/**
+ * Check if a file exist..
+ */
+function fileExist(path: string)
+{
+  try
+  {
+    fs.statSync(path);
+    return true;
+  }
+  catch (e)
+  {
+    return false;
+  }
+}
+
+function sanitiseFileName(str: string)
+{
+  return str.replace(/[\/':\?\*"<>\.]/g, '_');
 }
 
 /**
  * Downloads the subtitle and video.
  */
-function download(config: typings.IConfig, page: typings.IEpisodePage, player: typings.IEpisodePlayer, done: (err: Error) => void) {
-  var series = config.series || page.series;
-  var fileName = name(config, page, series);
-  var filePath = path.join(config.output || process.cwd(), series, fileName);
-  mkdirp(path.dirname(filePath), (err: Error) => {
-    if (err) return done(err);
-    downloadSubtitle(config, player, filePath, err => {
-      if (err) return done(err);
-      var now = Date.now();
-      console.log('Fetching ' + fileName);
-      downloadVideo(config, page, player, filePath, err => {
-        if (err) return done(err);
-        if (config.merge) return complete('Finished ' + fileName, now, done);
-        video.merge(config, player.video.file, filePath, err => {
-          if (err) return done(err);
-          complete('Finished ' + fileName, now, done);
+function download(config: IConfig, page: IEpisodePage, player: IEpisodePlayer, done: (err: Error, ign: boolean) => void)
+{
+  const serieFolder = sanitiseFileName(config.series || page.series);
+
+  let fileName = sanitiseFileName(generateName(config, page));
+  let filePath = path.join(config.output || process.cwd(), serieFolder, fileName);
+
+  if (fileExist(filePath + '.mkv'))
+  {
+    let count = 0;
+
+    if (config.rebuildcrp)
+    {
+      log.warn('Adding \'' + fileName + '\' to the DB...');
+      return done(null, false);
+    }
+
+    log.warn('File \'' + fileName + '\' already exist...');
+
+    do
+    {
+      count = count + 1;
+      fileName = sanitiseFileName(generateName(config, page, '-' + count));
+      filePath = path.join(config.output || process.cwd(), serieFolder, fileName);
+    } while (fileExist(filePath + '.mkv'));
+
+    log.warn('Renaming to \'' + fileName + '\'...');
+
+    page.filename = fileName;
+  }
+
+  if (config.rebuildcrp)
+  {
+    log.warn('Ignoring \'' + fileName + '\' as it does not exist...');
+    return done(null, true);
+  }
+
+  mkdirp(path.dirname(filePath), (errM: Error) =>
+  {
+    if (errM)
+    {
+      log.dispEpisode(fileName, 'Error...', true);
+      return done(errM, false);
+    }
+
+    log.dispEpisode(fileName, 'Fetching...', false);
+    downloadSubtitle(config, player, filePath, (errDS) =>
+    {
+      if (errDS)
+      {
+        log.dispEpisode(fileName, 'Error...', true);
+        return done(errDS, false);
+      }
+
+      const now = Date.now();
+      if (player.video.file !== undefined)
+      {
+        log.dispEpisode(fileName, 'Fetching video...', false);
+        downloadVideo(config, page, player, filePath, (errDV) =>
+        {
+          if (errDV)
+          {
+            log.dispEpisode(fileName, 'Error...', true);
+            return done(errDV, false);
+          }
+
+          if (config.merge)
+          {
+            return complete(fileName, 'Finished!', now, done);
+          }
+
+          const isSubtited = Boolean(player.subtitle);
+
+          log.dispEpisode(fileName, 'Merging...', false);
+          video.merge(config, isSubtited, player.video.file, filePath, player.video.mode, config.verbose, (errVM) =>
+          {
+            if (errVM)
+            {
+              log.dispEpisode(fileName, 'Error...', true);
+              return done(errVM, false);
+            }
+
+            complete(fileName, 'Finished!', now, done);
+          });
         });
-      });
+      }
+      else
+      {
+        log.dispEpisode(fileName, 'Ignoring: not released yet', true);
+        done(null, true);
+      }
     });
   });
 }
@@ -63,14 +170,37 @@ function download(config: typings.IConfig, page: typings.IEpisodePage, player: t
 /**
  * Saves the subtitles to disk.
  */
-function downloadSubtitle(config: typings.IConfig, player: typings.IEpisodePlayer, filePath: string, done: (err: Error) => void) {
-  var enc = player.subtitle;
-  subtitle.decode(enc.id, enc.iv, enc.data, (err, data) => {
-    if (err) return done(err);
-    var formats = subtitle.formats;
-    var format = formats[config.format] ? config.format : 'ass';
-    formats[format](data, (err: Error, decodedSubtitle: string) => {
-      if (err) return done(err);
+function downloadSubtitle(config: IConfig, player: IEpisodePlayer, filePath: string, done: (err?: Error) => void)
+{
+  const enc = player.subtitle;
+
+  if (!enc)
+  {
+    return done();
+  }
+
+  subtitle.decode(enc.id, enc.iv, enc.data, (errSD, data) =>
+  {
+    if (errSD)
+    {
+      return done(errSD);
+    }
+
+    if (config.debug)
+    {
+      log.dumpToDebug('SubtitlesXML', data);
+    }
+
+    const formats = subtitle.formats;
+    const format = formats[config.format] ? config.format : 'ass';
+
+    formats[format](config, data, (errF: Error, decodedSubtitle: string) =>
+    {
+      if (errF)
+      {
+        return done(errF);
+      }
+
       fs.writeFile(filePath + '.' + format, '\ufeff' + decodedSubtitle, done);
     });
   });
@@ -79,92 +209,189 @@ function downloadSubtitle(config: typings.IConfig, player: typings.IEpisodePlaye
 /**
  * Streams the video to disk.
  */
-function downloadVideo(config: typings.IConfig,
-  page: typings.IEpisodePage,
-  player: typings.IEpisodePlayer,
-  filePath: string,
-  done: (err: Error) => void) {
-  video.stream(
-    player.video.host,
-    player.video.file,
-    page.swf,
-    filePath + path.extname(player.video.file),
-    done);
+function downloadVideo(config: IConfig,  page: IEpisodePage, player: IEpisodePlayer,
+                       filePath: string, done: (err: Error) => void)
+{
+  video.stream(player.video.host, player.video.file, page.swf, filePath,
+               path.extname(player.video.file), player.video.mode, config.verbose, done);
 }
 
 /**
  * Names the file based on the config, page, series and tag.
  */
-function name(config: typings.IConfig, page: typings.IEpisodePage, series: string) {
-  var episode = (page.episode < 10 ? '0' : '') + page.episode;
-  var volume = (page.volume < 10 ? '0' : '') + page.volume;
-  var tag = config.tag || 'CrunchyRoll';
-  return series + ' ' + volume + 'x' + episode + ' [' + tag + ']';
+function generateName(config: IConfig, page: IEpisodePage, extra = '')
+{
+  const episodeNum = parseInt(page.episode, 10);
+  const volumeNum = parseInt(page.volume, 10);
+  const episode = (episodeNum < 10 ? '0' : '') + page.episode;
+  const volume = (volumeNum < 10 ? '0' : '') + page.volume;
+  const tag = config.tag || 'CrunchyRoll';
+  const series = config.series || page.series;
+
+  return config.nametmpl
+      .replace(/{EPISODE_ID}/g, page.id.toString())
+      .replace(/{EPISODE_NUMBER}/g, episode)
+      .replace(/{SEASON_NUMBER}/g, volume)
+      .replace(/{VOLUME_NUMBER}/g, volume)
+      .replace(/{SEASON_TITLE}/g, page.season)
+      .replace(/{VOLUME_TITLE}/g, page.season)
+      .replace(/{SERIES_TITLE}/g, series)
+      .replace(/{EPISODE_TITLE}/g, page.title)
+      .replace(/{TAG}/g, tag) + extra;
 }
 
 /**
  * Prefixes a value.
  */
-function prefix(value: number|string, length: number) {
-  var valueString = typeof value !== 'string' ? String(value) : value;
-  while (valueString.length < length) valueString = '0' + valueString;
+function prefix(value: number|string, length: number)
+{
+  let valueString = (typeof value !== 'string') ? String(value) : value;
+
+  while (valueString.length < length)
+  {
+    valueString = '0' + valueString;
+  }
+
   return valueString;
 }
 
 /**
  * Requests the page data and scrapes the id, episode, series and swf.
  */
-function scrapePage(config: typings.IConfig, address: string, done: (err: Error, page?: typings.IEpisodePage) => void) {
-  var id = parseInt((address.match(/[0-9]+$/) || ['0'])[0], 10);
-  if (!id) return done(new Error('Invalid address.'));
-  request.get(config, address, (err, result) => {
-    if (err) return done(err);
-    var $ = cheerio.load(result);
-    var swf = /^([^?]+)/.exec($('link[rel=video_src]').attr('href'));
-    var regexp = /Watch\s+(.+?)(?:\s+Season\s+([0-9]+))?\s+Episode\s+([0-9]+)/;
-    var data = regexp.exec($('title').text());
-    if (!swf || !data) return done(new Error('Invalid page.'));
-    done(null, {
-      id: id,
-      episode: parseInt(data[3], 10),
-      series: data[1],
-      swf: swf[1],
-      volume: parseInt(data[2], 10) || 1
-    });
+function scrapePage(config: IConfig, address: string, done: (err: Error, page?: IEpisodePage) => void)
+{
+  const epId = parseInt((address.match(/[0-9]+$/) || ['0'])[0], 10);
+
+  if (!epId)
+  {
+    return done(new Error('Invalid address.'));
+  }
+
+  my_request.get(config, address, (err, result) =>
+  {
+    if (err)
+    {
+      return done(err);
+    }
+
+    const $ = cheerio.load(result);
+    const swf = /^([^?]+)/.exec($('link[rel=video_src]').attr('href'));
+    const regexp = /\s*([^\n\r\t\f]+)\n?\s*[^0-9]*([0-9][\-0-9.]*)?,?\n?\s\s*[^0-9]*((PV )?[S0-9][P0-9.]*[a-fA-F]?)/;
+    const look = $('#showmedia_about_media').text();
+    const seasonTitle = $('span[itemprop="title"]').text();
+    const episodeTitle = $('#showmedia_about_name').text().replace(/[“”]/g, '');
+    const data = regexp.exec(look);
+
+    if (config.debug)
+    {
+      log.dumpToDebug('episode page', $.html());
+    }
+
+    if (!swf || !data)
+    {
+      log.warn('Somethig unexpected in the page at ' + address + ' (data are: ' + look + ')');
+      log.warn('Setting Season to ’0’ and episode to ’0’...');
+
+      if (config.debug)
+      {
+        log.dumpToDebug('episode unexpected', look);
+      }
+
+      done(null, {
+        episode: '0',
+        id: epId,
+        series: seasonTitle,
+        season: seasonTitle,
+        title: episodeTitle,
+        swf: swf[1],
+        volume: '0',
+        filename: '',
+      });
+    }
+    else
+    {
+      done(null, {
+        episode: data[3],
+        id: epId,
+        series: data[1],
+        season: seasonTitle,
+        title: episodeTitle,
+        swf: swf[1],
+        volume: data[2] || '1',
+        filename: '',
+      });
+    }
   });
 }
 
 /**
  * Requests the player data and scrapes the subtitle and video data.
  */
-function scrapePlayer(config: typings.IConfig, address: string, id: number, done: (err: Error, player?: typings.IEpisodePlayer) => void) {
-  var url = address.match(/^(https?:\/\/[^\/]+)/);
-  if (!url) return done(new Error('Invalid address.'));
-  request.post(config, {
-    form: {current_page: address},
-    url: url[1] + '/xml/?req=RpcApiVideoPlayer_GetStandardConfig&media_id=' + id
-  }, (err, result) => {
-    if (err) return done(err);
+function scrapePlayer(config: IConfig, address: string, id: number, done: (err: Error, player?: IEpisodePlayer) => void)
+{
+  const url = address.match(/^(https?:\/\/[^\/]+)/);
+
+  if (!url)
+  {
+    return done(new Error('Invalid address.'));
+  }
+
+  my_request.post(config, {
+    form: {
+      current_page: address,
+      video_format: config.video_format,
+      video_quality: config.video_quality,
+      media_id: id
+    },
+    url: url[1] + '/xml/?req=RpcApiVideoPlayer_GetStandardConfig&media_id=' + id,
+  }, (err, result) =>
+  {
+    if (err)
+    {
+      return done(err);
+    }
+
     xml2js.parseString(result, {
       explicitArray: false,
-      explicitRoot: false
-    }, (err: Error, player: typings.IEpisodePlayerConfig) => {
-      if (err) return done(err);
-      try {
+      explicitRoot: false,
+    }, (errPS: Error, player: IEpisodePlayerConfig) =>
+    {
+      if (errPS)
+      {
+        return done(errPS);
+      }
+
+      try
+      {
+        const isSubtitled = Boolean(player['default:preload'].subtitle);
+        let streamMode = 'RTMP';
+
+        if (player['default:preload'].stream_info.host === '')
+        {
+          streamMode = 'HLS';
+        }
+
         done(null, {
-          subtitle: {
+          subtitle: isSubtitled ? {
+            data: player['default:preload'].subtitle.data,
             id: parseInt(player['default:preload'].subtitle.$.id, 10),
             iv: player['default:preload'].subtitle.iv,
-            data: player['default:preload'].subtitle.data
-          },
+          } : null,
           video: {
             file: player['default:preload'].stream_info.file,
-            host: player['default:preload'].stream_info.host
-          }
+            host: player['default:preload'].stream_info.host,
+            mode: streamMode,
+          },
         });
-      } catch (parseError) {
+      } catch (parseError)
+      {
+        if (config.debug)
+        {
+          log.dumpToDebug('player scrape', parseError);
+        }
+
         done(parseError);
       }
     });
   });
-}
+}

src/index.ts

@@ -1,4 +1,5 @@
 'use strict';
-export import batch = require('./batch');
-export import episode = require('./episode');
-export import series = require('./series');
+import batch from './batch';
+import episode from './episode';
+import series from './series';
+export {batch, episode, series};

src/interface/AuthError.d.ts

@@ -0,0 +1,3 @@
+interface IAuthError extends Error {
+  authError: boolean;
+}

src/interface/IConfig.d.ts

@@ -0,0 +1,41 @@
+interface IConfig {
+  // Authentication
+  pass?: string;
+  user?: string;
+  // Disables
+  cache?: boolean;
+  merge?: boolean;
+  episodes?: string;
+  // Settings
+  format?: string;
+  output?: string;
+  series?: string;
+  nametmpl?: string;
+  tag?: string;
+  ignoredub?: boolean;
+  resolution?: string;
+  video_format?: string;
+  video_quality?: string;
+  rebuildcrp?: boolean;
+  batch?: string;
+  verbose?: boolean;
+  debug?: boolean;
+  unlog?: boolean;
+  retry?: number;
+  // Login options
+  userAgent?: string;
+  logUsingApi?: boolean;
+  logUsingCookie?: boolean;
+  crSessionUrl?: string;
+  crDeviceType?: string;
+  crAPIVersion?: string;
+  crLocale?: string;
+  crSessionKey?: string;
+  crLoginUrl?: string;
+  // Third method, injecting data from cookies
+  crUserId?: string;
+  crUserKey?: string;
+  // Generated values
+  crDeviceId?: string;
+  crSessionId?: string;
+}

src/interface/IConfigLine.d.ts

@@ -0,0 +1,3 @@
+interface IConfigLine extends IConfig {
+  args: string[];
+}

src/interface/IConfigTask.d.ts

@@ -0,0 +1,6 @@
+interface IConfigTask {
+  address: string;
+  retry: number;
+  episode_min: number;
+  episode_max: number;
+}

src/interface/IEpisodePage.d.ts

@@ -0,0 +1,10 @@
+interface IEpisodePage {
+  id: number;
+  episode: string;
+  series: string;
+  volume: string;
+  season: string;
+  title: string;
+  swf: string;
+  filename: string;
+}

src/interface/IEpisodePlayer.d.ts

@@ -0,0 +1,12 @@
+interface IEpisodePlayer {
+  subtitle?: {
+    id: number;
+    iv: string;
+    data: string;
+  };
+  video: {
+    mode: string;
+    file: string;
+    host: string;
+  };
+}

src/interface/IEpisodePlayerConfig.d.ts

@@ -0,0 +1,15 @@
+interface IEpisodePlayerConfig {
+  'default:preload': {
+    subtitle: {
+      $: {
+        id: string;
+      };
+      iv: string;
+      data: string;
+    };
+    stream_info: {
+      file: string;
+      host: string;
+    };
+  };
+}

src/interface/IFormatterTable.d.ts

@@ -0,0 +1,3 @@
+interface IFormatterTable {
+  [key: string]: (config: IConfig, input: string|Buffer, done: (err: Error, subtitle?: string) => void) => void;
+}

src/interface/IResolData.d.ts

@@ -0,0 +1,4 @@
+interface IResolData {
+  quality: string;
+  format: string;
+}

src/interface/ISeries.d.ts

@@ -0,0 +1,4 @@
+interface ISeries {
+  episodes: ISeriesEpisode[];
+  series: string;
+}

src/interface/ISeriesEpisode.d.ts

@@ -0,0 +1,7 @@
+interface ISeriesEpisode {
+  address: string;
+  episode: string;
+  seasonName: string;
+  volume: number;
+  retry: number;
+}

src/interface/ISubtitle.d.ts

@@ -0,0 +1,13 @@
+interface ISubtitle {
+  $: {
+    title: string;
+    wrap_style: string;
+    play_res_x: string;
+    play_res_y: string;
+    id: string;
+    lang_string: string;
+    created: string;
+  };
+  events: ISubtitleEvent;
+  styles: ISubtitleStyle;
+}

src/interface/ISubtitleEvent.d.ts

@@ -0,0 +1,15 @@
+interface ISubtitleEvent {
+  event: {
+    $: {
+      end: string;
+      start: string;
+      style: string;
+      name: string;
+      margin_l: string;
+      margin_r: string;
+      margin_v: string;
+      effect: string;
+      text: string;
+    };
+  }[];
+}

src/interface/ISubtitleStyle.d.ts

@@ -0,0 +1,29 @@
+interface ISubtitleStyle {
+  style: {
+    $: {
+      name: string;
+      font_name: string;
+      font_size: string;
+      primary_colour: string;
+      secondary_colour: string;
+      outline_colour: string;
+      back_colour: string;
+      bold: string;
+      italic: string;
+      underline: string;
+      strikeout: string;
+      scale_x: string;
+      scale_y: string;
+      spacing: string;
+      angle: string;
+      border_style: string;
+      outline: string;
+      shadow: string;
+      alignment: string;
+      margin_l: string;
+      margin_r: string;
+      margin_v: string;
+      encoding: string;
+    };
+  }[];
+}

src/log.ts

@@ -0,0 +1,49 @@
+'use strict';
+import os = require('os');
+import fs = require('fs-extra');
+
+export function error(str: string|Error)
+{
+  /* Do fancy output */
+  console.error(' \x1B[1;31m* ERROR\x1B[0m: ' + str);
+}
+
+export function info(str: string)
+{
+  /* Do fancy output */
+  console.log(' \x1B[1;32m* INFO \x1B[0m: ' + str);
+}
+
+export function debug(str: string)
+{
+  /* Do fancy output */
+  console.log(' \x1B[1;35m* DEBUG\x1B[0m: ' + str);
+}
+
+export function warn(str: string)
+{
+  /* Do fancy output */
+  console.log(' \x1B[1;33m* WARN \x1B[0m: ' + str);
+}
+
+export function dispEpisode(name: string, status: string, addNL: boolean)
+{
+  /* Do fancy output */
+  process.stdout.write('\x1B[K \x1B[1;33m> \x1B[37m' + name + '\x1B[0m : \x1B[33m' + status + '\x1B[0m\x1B[0G');
+
+  if (addNL)
+  {
+    console.log('');
+  }
+}
+
+export function dumpToDebug(what: string, data: any, create = false)
+{
+  if (create)
+  {
+    fs.writeFileSync('debug.txt', '>>>>>>>> ' + what + ':\n' + data + '\n<<<<<<<<\n');
+    return;
+  }
+
+  fs.appendFileSync('debug.txt', '>>>>>>>> ' + what + ':\n' + data + '\n<<<<<<<<\n');
+}

src/my_request.ts

@@ -0,0 +1,409 @@
+'use strict';
+import cheerio = require('cheerio');
+import request = require('request');
+import rp = require('request-promise');
+import Promise = require('bluebird');
+import uuid = require('uuid');
+import path = require('path');
+import fs = require('fs-extra');
+import log = require('./log');
+
+import { RequestPromise } from 'request-promise';
+import { Response } from 'request';
+
+// tslint:disable-next-line:no-var-requires
+const cookieStore = require('tough-cookie-file-store');
+// tslint:disable-next-line:no-var-requires
+const cloudscraper = require('cloudscraper');
+
+const CR_COOKIE_DOMAIN = 'http://crunchyroll.com';
+
+let isAuthenticated = false;
+let isPremium = false;
+
+let j: request.CookieJar;
+
+const defaultHeaders: request.Headers =
+{
+  'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.87 Safari/537.36',
+  'Connection': 'keep-alive',
+  'Referer': 'https://www.crunchyroll.com/login',
+};
+
+function AuthError(msg: string): IAuthError
+{
+  return { name: 'AuthError', message: msg, authError: true };
+}
+
+function startSession(config: IConfig): Promise<any>
+{
+  return rp(
+  {
+    method: 'GET',
+    url: config.crSessionUrl,
+    qs:
+    {
+      device_id: config.crDeviceId,
+      device_type: config.crDeviceType,
+      access_token: config.crSessionKey,
+      version: config.crAPIVersion,
+      locale: config.crLocale,
+    },
+    json: true,
+  })
+  .then((response: any) =>
+  {
+    if ((response.data === undefined) || (response.data.session_id === undefined))
+    {
+      throw new Error('Getting session failed: ' + JSON.stringify(response));
+    }
+
+    return response.data.session_id;
+  });
+}
+
+function login(config: IConfig, sessionId: string, user: string, pass: string): Promise<any>
+{
+  return rp(
+  {
+    method: 'POST',
+    url:  config.crLoginUrl,
+    form:
+    {
+      account: user,
+      password: pass,
+      session_id: sessionId,
+      version: config.crAPIVersion,
+    },
+    json: true,
+    jar: j,
+  })
+  .then((response) =>
+  {
+    if (response.error) throw new Error('Login failed: ' + response.message);
+    return response.data;
+  });
+}
+
+function checkIfUserIsAuth(config: IConfig, done: (err: Error) => void): void
+{
+  if (j === undefined)
+  {
+    loadCookies(config);
+  }
+
+  /**
+   * The main page give us some information about the user
+   */
+  const options =
+  {
+    headers: defaultHeaders,
+    jar: j,
+    url: 'http://www.crunchyroll.com/',
+    method: 'GET',
+  };
+  cloudscraper.request(options, (err: Error, rep: string, body: string) =>
+  {
+    if (err)
+    {
+      return done(err);
+    }
+
+    const $ = cheerio.load(body);
+
+    /* Check if auth worked */
+    const regexps = /ga\('set', 'dimension[5-8]', '([^']*)'\);/g;
+    const dims = regexps.exec($('script').text());
+
+    for (let i = 1; i < 5; i++)
+    {
+      if ((dims[i] !== undefined) && (dims[i] !== '') && (dims[i] !== 'not-registered'))
+      {
+        isAuthenticated = true;
+      }
+
+      if ((dims[i] === 'premium') || (dims[i] === 'premiumplus'))
+      {
+        isPremium = true;
+      }
+    }
+
+    if (isAuthenticated === false)
+    {
+        const error = $('ul.message, li.error').text();
+        return done(AuthError('Authentication failed: ' + error));
+    }
+    else
+    {
+      if (isPremium === false)
+      {
+        log.warn('Do not use this app without a premium account.');
+      }
+      else
+      {
+        log.info('You have a premium account! Good!');
+      }
+    }
+
+    done(null);
+  });
+}
+
+function loadCookies(config: IConfig)
+{
+  const cookiePath = path.join(config.output || process.cwd(), '.cookies.json');
+
+  if (!fs.existsSync(cookiePath))
+  {
+    fs.closeSync(fs.openSync(cookiePath, 'w'));
+  }
+
+  j = request.jar(new cookieStore(cookiePath));
+}
+
+export function eatCookies(config: IConfig)
+{
+  const cookiePath = path.join(config.output || process.cwd(), '.cookies.json');
+
+  if (fs.existsSync(cookiePath))
+  {
+      fs.removeSync(cookiePath);
+  }
+
+  j = undefined;
+}
+
+/**
+ * Performs a GET request for the resource.
+ */
+export function get(config: IConfig, options: string|request.Options, done: (err: any, result?: string) => void)
+{
+  if (j === undefined)
+  {
+    loadCookies(config);
+  }
+
+  if (config.userAgent)
+  {
+    defaultHeaders['User-Agent'] = config.userAgent;
+  }
+
+  authenticate(config, (err) =>
+  {
+    if (err)
+    {
+      return done(err);
+    }
+
+    cloudscraper.request(modify(options, 'GET'), (error: any, response: any, body: any) =>
+    {
+      if (error) return done(error);
+
+      done(null, typeof body === 'string' ? body : String(body));
+    });
+  });
+}
+
+/**
+ * Performs a POST request for the resource.
+ */
+export function post(config: IConfig, options: request.Options, done: (err: Error, result?: string) => void)
+{
+  if (j === undefined)
+  {
+    loadCookies(config);
+  }
+
+  if (config.userAgent)
+  {
+    defaultHeaders['User-Agent'] = config.userAgent;
+  }
+
+  authenticate(config, (err) =>
+  {
+    if (err)
+    {
+      return done(err);
+    }
+
+    cloudscraper.request(modify(options, 'POST'), (error: Error, response: any, body: any) =>
+    {
+      if (error)
+      {
+        return done(error);
+      }
+      done(null, typeof body === 'string' ? body : String(body));
+    });
+  });
+}
+
+/**
+ * Authenticates using the configured pass and user.
+ */
+function authenticate(config: IConfig, done: (err: Error) => void)
+{
+  if (isAuthenticated)
+  {
+    return done(null);
+  }
+
+  /* First of all, check if the user is not already logged via the cookies */
+  checkIfUserIsAuth(config, (errCheckAuth) =>
+  {
+    if (isAuthenticated)
+    {
+      return done(null);
+    }
+
+    /* So if we are here now, that mean we are not authenticated so do as usual */
+    if (!config.pass || !config.user)
+    {
+      log.error('You need to give login/password to use Crunchy');
+      process.exit(-1);
+    }
+
+    log.info('Seems we are not currently logged. Let\'s login!');
+
+    if (config.logUsingApi)
+    {
+      if (config.crDeviceId === undefined)
+      {
+        config.crDeviceId = uuid.v4();
+      }
+
+      if (!config.crSessionUrl || !config.crDeviceType || !config.crAPIVersion ||
+          !config.crLocale || !config.crLoginUrl)
+      {
+        return done(AuthError('Invalid API configuration, please check your config file.'));
+      }
+
+      startSession(config)
+      .then((sessionId: string) =>
+      {
+        defaultHeaders.Cookie = `sess_id=${sessionId}; c_locale=enUS`;
+        return login(config, sessionId, config.user, config.pass);
+      })
+      .then((userData) =>
+      {
+        checkIfUserIsAuth(config, (errCheckAuth2) =>
+        {
+          if (isAuthenticated)
+          {
+            return done(null);
+          }
+          else
+          {
+            return done(errCheckAuth2);
+          }
+        });
+      })
+      .catch((errInChk) =>
+      {
+        return done(AuthError(errInChk.message));
+      });
+    }
+    else if (config.logUsingCookie)
+    {
+      j.setCookie(request.cookie('c_userid=' + config.crUserId + '; Domain=crunchyroll.com; HttpOnly; hostOnly=false;'),
+                  CR_COOKIE_DOMAIN);
+      j.setCookie(request.cookie('c_userkey=' + config.crUserKey + '; Domain=crunchyroll.com; HttpOnly; hostOnly=false;'),
+                  CR_COOKIE_DOMAIN);
+
+      checkIfUserIsAuth(config, (errCheckAuth2) =>
+      {
+        if (isAuthenticated)
+        {
+          return done(null);
+        }
+        else
+        {
+          return done(errCheckAuth2);
+        }
+      });
+    }
+    else
+    {
+      /* First get https://www.crunchyroll.com/login to get the login token */
+      const options =
+      {
+        headers: defaultHeaders,
+        jar: j,
+        gzip: false,
+        method: 'GET',
+        url: 'https://www.crunchyroll.com/login'
+      };
+
+      cloudscraper.request(options, (err: Error, rep: string, body: string) =>
+      {
+        if (err) return done(err);
+
+        const $ = cheerio.load(body);
+
+        /* Get the token from the login page */
+        const token = $('input[name="login_form[_token]"]').attr('value');
+        if (token === '')
+        {
+            return done(AuthError('Can\'t find token!'));
+        }
+
+        /* Now call the page again with the token and credentials */
+        const options =
+        {
+          headers: defaultHeaders,
+          form:
+          {
+            'login_form[name]': config.user,
+            'login_form[password]': config.pass,
+            'login_form[redirect_url]': '/',
+            'login_form[_token]': token
+          },
+          jar: j,
+          gzip: false,
+          method: 'POST',
+          url: 'https://www.crunchyroll.com/login'
+        };
+
+        cloudscraper.request(options, (err: Error, rep: string, body: string) =>
+        {
+          if (err)
+          {
+              return done(err);
+          }
+
+          /* Now let's check if we are authentificated */
+          checkIfUserIsAuth(config, (errCheckAuth2) =>
+          {
+            if (isAuthenticated)
+            {
+              return done(null);
+            }
+            else
+            {
+              return done(errCheckAuth2);
+            }
+          });
+        });
+      });
+    }
+  });
+}
+
+/**
+ * Modifies the options to use the authenticated cookie jar.
+ */
+function modify(options: string|request.Options, reqMethod: string): request.Options
+{
+  if (typeof options !== 'string')
+  {
+    options.jar = j;
+    options.headers = defaultHeaders;
+    options.method = reqMethod;
+    return options;
+  }
+  return {
+    jar: j,
+    headers: defaultHeaders,
+    url: options.toString(),
+    method: reqMethod
+  };
+}

src/request.ts

@@ -1,63 +0,0 @@
-'use strict';
-import request = require('request');
-import typings = require('./typings');
-var isAuthenticated = false;
-
-/**
- * Performs a GET request for the resource.
- */
-export function get(config: typings.IConfig, options: request.Options, done: (err: Error, result?: string) => void) {
-  authenticate(config, err => {
-    if (err) return done(err);
-    request.get(modify(options), (err: Error, response: any, body: any) => {
-      if (err) return done(err);
-      done(null, typeof body === 'string' ? body : String(body));
-    });
-  });
-}
-
-/**
- * Performs a POST request for the resource.
- */
-export function post(config: typings.IConfig, options: request.Options, done: (err: Error, result?: string) => void) {
-  authenticate(config, err => {
-    if (err) return done(err);
-    request.post(modify(options), (err: Error, response: any, body: any) => {
-      if (err) return done(err);
-      done(null, typeof body === 'string' ? body : String(body));
-    });
-  });
-}
-
-/**
- * Authenticates using the configured pass and user.
- */
-function authenticate(config: typings.IConfig, done: (err: Error) => void) {
-  if (isAuthenticated || !config.pass || !config.user) return done(null);
-  var options = {
-    form: {
-      formname: 'RpcApiUser_Login',
-      fail_url: 'https://www.crunchyroll.com/login',
-      name: config.user,
-      password: config.pass
-    },
-    jar: true,
-    url: 'https://www.crunchyroll.com/?a=formhandler'
-  };
-  request.post(options, (err: Error) => {
-    if (err) return done(err);
-    isAuthenticated = true;
-    done(null);
-  });
-}
-
-/**
- * Modifies the options to use the authenticated cookie jar.
- */
-function modify(options: string|request.Options): request.Options {
-  if (typeof options !== 'string') {
-    options.jar = true;
-    return options;
-  }
-  return {jar: true, url: options.toString()};
-}

src/series.ts

@@ -1,34 +1,134 @@
 'use strict';
-export = main;
 import cheerio = require('cheerio');
-import episode = require('./episode');
-import fs = require('fs');
-import request = require('./request');
+import episode from './episode';
+// import fs = require('fs');
+import fs = require('fs-extra');
+import my_request = require('./my_request');
 import path = require('path');
-import typings = require('./typings');
 import url = require('url');
-var persistent = '.crpersistent';
+import log  = require('./log');
+const persistent = '.crpersistent';
+
+/**
+ * Check if a file exist..
+ */
+function fileExist(path: string)
+{
+  try
+  {
+    fs.statSync(path);
+    return true;
+  } catch (e)
+  {
+    return false;
+  }
+}
 
 /**
  * Streams the series to disk.
  */
-function main(config: typings.IConfig, address: string, done: (err: Error) => void) {
-  var persistentPath = path.join(config.output || process.cwd(), persistent);
-  fs.readFile(persistentPath, 'utf8', (err, contents) => {
-    var cache = config.cache ? {} : JSON.parse(contents || '{}');
-    page(config, address, (err, page) => {
-      if (err) return done(err);
-      var i = 0;
-      (function next() {
+export default function(config: IConfig, task: IConfigTask, done: (err: any) => void)
+{
+  const persistentPath = path.join(config.output || process.cwd(), persistent);
+
+  /* Make a backup of the persistent file in case of */
+  if (fileExist(persistentPath))
+  {
+    fs.copySync(persistentPath, persistentPath + '.backup');
+  }
+
+  fs.readFile(persistentPath, 'utf8', (err: Error, contents: string) =>
+  {
+    const cache = config.cache ? {} : JSON.parse(contents || '{}');
+
+    pageScrape(config, task, (errP, page) =>
+    {
+      if (errP)
+      {
+        const reqErr = errP.error;
+        if ((reqErr !== undefined) && (reqErr.syscall))
+        {
+          if ((reqErr.syscall === 'getaddrinfo') && (reqErr.errno === 'ENOTFOUND'))
+          {
+            log.error('The URL \'' + task.address + '\' is invalid, please check => I\'m ignoring it.');
+          }
+        }
+
+        return done(errP);
+      }
+
+      let i = 0;
+      (function next()
+      {
+        if (config.debug)
+        {
+          log.dumpToDebug('Episode ' + i, JSON.stringify(page.episodes[i]));
+        }
+
         if (i >= page.episodes.length) return done(null);
-        download(cache, config, address, page.episodes[i], err => {
-          if (err) return done(err);
-          var newCache = JSON.stringify(cache, null, '  ');
-          fs.writeFile(persistentPath, newCache, err => {
-            if (err) return done(err);
-            i += 1;
+        download(cache, config, task, page.episodes[i], (errD, ignored) =>
+        {
+          if (errD)
+          {
+            /* Check if domain is valid */
+            const reqErr = errD.error;
+            if ((reqErr !== undefined) && (reqErr.syscall))
+            {
+              if ((reqErr.syscall === 'getaddrinfo') && (reqErr.errno === 'ENOTFOUND'))
+              {
+                page.episodes[i].retry = 0;
+                log.error('The URL \'' + task.address + '\' is invalid, please check => I\'m ignoring it.');
+              }
+            }
+
+            if (page.episodes[i].retry <= 0)
+            {
+              log.error(JSON.stringify(errD));
+              log.error('Cannot fetch episode "s' + page.episodes[i].volume + 'e' + page.episodes[i].episode +
+                            '", please rerun later');
+              /* Go to the next on the list */
+              i += 1;
+            }
+            else
+            {
+              if ((config.verbose) || (config.debug))
+              {
+                if (config.debug)
+                {
+                  log.dumpToDebug('series address', task.address);
+                  log.dumpToDebug('series error', JSON.stringify(errD));
+                  log.dumpToDebug('series data', JSON.stringify(page));
+                }
+                log.error(errD);
+              }
+              log.warn('Retrying to fetch episode "s' + page.episodes[i].volume + 'e' + page.episodes[i].episode +
+                           '" - Retry ' + page.episodes[i].retry + ' / ' + config.retry);
+              page.episodes[i].retry -= 1;
+            }
             next();
-          });
+          }
+          else
+          {
+            if ((ignored === false) || (ignored === undefined))
+            {
+              const newCache = JSON.stringify(cache, null, '  ');
+              fs.writeFile(persistentPath, newCache, (errW: Error) =>
+              {
+                if (errW)
+                {
+                  return done(errW);
+                }
+
+                i += 1;
+                next();
+              });
+            }
+            else
+            {
+              i += 1;
+              next();
+            }
+          }
         });
       })();
     });
@@ -38,60 +138,123 @@ function main(config: typings.IConfig, address: string, done: (err: Error) => vo
 /**
  * Downloads the episode.
  */
-function download(cache: {[address: string]: number},
-  config: typings.IConfig,
-  baseAddress: string,
-  item: typings.ISeriesEpisode,
-  done: (err: Error) => void) {
-  if (!filter(config, item)) return done(null);
-  var address = url.resolve(baseAddress, item.address);
-  if (cache[address]) return done(null);
-  episode(config, address, err => {
-    if (err) return done(err);
+function download(cache: {[address: string]: number}, config: IConfig,
+                  task: IConfigTask, item: ISeriesEpisode,
+                  done: (err: any, ign: boolean) => void)
+{
+  const episodeNumber = parseInt(item.episode, 10);
+
+  if ( (episodeNumber < task.episode_min) ||
+       (episodeNumber > task.episode_max) )
+  {
+    return done(null, false);
+  }
+
+  const address = url.resolve(task.address, item.address);
+
+  if (cache[address])
+  {
+    return done(null, false);
+  }
+
+  episode(config, address, (err, ignored) =>
+  {
+    if (err)
+    {
+      return done(err, false);
+    }
+
     cache[address] = Date.now();
-    done(null);
+    done(null, ignored);
   });
 }
 
-/**
- * Filters the item based on the configuration.
- */
-function filter(config: typings.IConfig, item: typings.ISeriesEpisode) {
-  // Filter on chapter.
-  var episodeFilter = config.episode;
-  if (episodeFilter > 0 && item.episode <= episodeFilter) return false;
-  if (episodeFilter < 0 && item.episode >= -episodeFilter) return false;
-
-  // Filter on volume.
-  var volumeFilter = config.volume;
-  if (volumeFilter > 0 && item.volume <= volumeFilter) return false;
-  if (volumeFilter < 0 && item.volume >= -volumeFilter) return false;
-  return true;
-}
-
 /**
  * Requests the page and scrapes the episodes and series.
  */
-function page(config: typings.IConfig, address: string, done: (err: Error, result?: typings.ISeries) => void) {
-  request.get(config, address, (err, result) => {
-    if (err) return done(err);
-    var $ = cheerio.load(result);
-    var title = $('span[itemprop=name]').text();
-    if (!title) return done(new Error('Invalid page.'));
-    var episodes: typings.ISeriesEpisode[] = [];
-    $('.episode').each((i, el) => {
-      if ($(el).children('img[src*=coming_soon]').length) return;
-      var volume = /([0-9]+)\s*$/.exec($(el).closest('ul').prev('a').text());
-      var regexp = /Episode\s+([0-9]+)\s*$/i;
-      var episode = regexp.exec($(el).children('.series-title').text());
-      var address = $(el).attr('href');
-      if (!address || !episode) return;
-      episodes.push({
-        address: address,
-        episode: parseInt(episode[0], 10),
-        volume: volume ? parseInt(volume[0], 10) : 1
-      });
+function pageScrape(config: IConfig, task: IConfigTask, done: (err: any, result?: ISeries) => void)
+{
+  if (task.address[0] === '@')
+  {
+    log.info('Trying to fetch from ' + task.address.substr(1));
+    const episodes: ISeriesEpisode[] = [];
+    episodes.push({
+      address: task.address.substr(1),
+      episode: '',
+      seasonName: '',
+      volume: 0,
+      retry: config.retry,
     });
-    done(null, {episodes: episodes.reverse(), series: title});
-  });
-}
+    done(null, {episodes: episodes.reverse(), series: ''});
+  }
+  else
+  {
+    let episodeCount = 0;
+    my_request.get(config, task.address, (err, result) => {
+      if (err)
+      {
+        return done(err);
+      }
+
+      const $ = cheerio.load(result);
+      const title = $('span[itemprop=name]').text();
+
+      if (config.debug)
+      {
+        log.dumpToDebug('serie page', $.html());
+      }
+
+      if (!title) {
+        if (config.debug)
+        {
+          log.dumpToDebug('missing title', task.address);
+        }
+        return done(new Error('Invalid page.(' + task.address + ')'));
+      }
+
+      log.info('Checking availability for ' + title);
+      const episodes: ISeriesEpisode[] = [];
+
+      if ($('.availability-notes-low').length || $('.availability-notes-high').length)
+      {
+        log.warn('This serie may have georestriction and some missings episode.');
+      }
+
+      $('.episode').each((i, el) => {
+        if ($(el).children('img[src*=coming_soon]').length) {
+          return;
+        }
+
+        const season_name = $(el).closest('ul').prev('a').text();
+        const volume = /([0-9]+)\s*$/.exec($(el).closest('ul').prev('a').text());
+        const regexp = /Episode\s+((PV )?[S0-9][\-P0-9.]*[a-fA-F]?)\s*$/i;
+        const episode = regexp.exec($(el).children('.series-title').text());
+        const url = $(el).attr('href');
+
+        if (config.ignoredub && (season_name.endsWith('Dub)') || season_name.endsWith('dub)')))
+        {
+          return;
+        }
+
+        if ((!url) || (!episode))
+        {
+          return;
+        }
+        episodeCount += 1;
+        episodes.push({
+          address: url,
+          episode: episode[1],
+          seasonName: season_name,
+          volume: volume ? parseInt(volume[0], 10) : 1,
+          retry: config.retry,
+        });
+      });
+
+      if (episodeCount === 0)
+      {
+        log.warn('No episodes found for ' + title + '. Could it be a movie?');
+      }
+      done(null, {episodes: episodes.reverse(), series: title});
+    });
+  }
+}

src/subtitle/decode.ts

@@ -1,17 +1,20 @@
 /* tslint:disable:no-bitwise false */
 'use strict';
-export = main;
-import crypto = require('crypto');
 import bigInt = require('big-integer');
+import crypto = require('crypto');
 import zlib = require('zlib');
 
 /**
  * Decodes the data.
  */
-function main(id: number, iv: Buffer|string, data: Buffer|string, done: (err?: Error, result?: Buffer) => void) {
-  try {
+export default function(id: number, iv: Buffer|string, data: Buffer|string,
+                        done: (err?: Error, result?: Buffer) => void)
+{
+  try
+  {
     decompress(decrypt(id, iv, data), done);
-  } catch (e) {
+  } catch (e)
+  {
     done(e);
   }
 }
@@ -19,21 +22,27 @@ function main(id: number, iv: Buffer|string, data: Buffer|string, done: (err?: E
 /**
  * Decrypts the data.
  */
-function decrypt(id: number, iv: Buffer|string, data: Buffer|string) {
-  var ivBuffer = typeof iv === 'string' ? new Buffer(iv, 'base64') : iv;
-  var dataBuffer = typeof data === 'string' ? new Buffer(data, 'base64') : data;
-  var decipher = crypto.createDecipheriv('aes-256-cbc', key(id), ivBuffer);
+function decrypt(id: number, iv: Buffer|string, data: Buffer|string)
+{
+  const ivBuffer = typeof iv === 'string' ? Buffer.from(iv, 'base64') : iv;
+  const dataBuffer = typeof data === 'string' ? Buffer.from(data, 'base64') : data;
+  const decipher = crypto.createDecipheriv('aes-256-cbc', key(id), ivBuffer);
+
   decipher.setAutoPadding(false);
+
   return Buffer.concat([decipher.update(dataBuffer), decipher.final()]);
 }
 
 /**
  * Decompresses the data.
  */
-function decompress(data: Buffer, done: (err: Error, result?: Buffer) => void) {
-  try {
+function decompress(data: Buffer, done: (err: Error, result?: Buffer) => void)
+{
+  try
+  {
     zlib.inflate(data, done);
-  } catch (e) {
+  } catch (e)
+  {
     done(null, data);
   }
 }
@@ -41,36 +50,45 @@ function decompress(data: Buffer, done: (err: Error, result?: Buffer) => void) {
 /**
  * Generates a key.
  */
-function key(subtitleId: number): Buffer {
-  var hash = secret(20, 97, 1, 2) + magic(subtitleId);
-  var result = new Buffer(32);
+function key(subtitleId: number): Buffer
+{
+  const hash = secret(20, 97, 1, 2) + magic(subtitleId);
+  const result = Buffer.allocUnsafe(32);
+
   result.fill(0);
   crypto.createHash('sha1').update(hash).digest().copy(result);
+
   return result;
 }
 
 /**
  * Generates a magic number.
  */
-function magic(subtitleId: number): number {
-  var base = Math.floor(Math.sqrt(6.9) * Math.pow(2, 25));
-  var hash = bigInt(base).xor(subtitleId).toJSNumber();
-  var multipliedHash = bigInt(hash).multiply(32).toJSNumber();
+function magic(subtitleId: number): number
+{
+  const base = Math.floor(Math.sqrt(6.9) * Math.pow(2, 25));
+  const hash = bigInt(base).xor(subtitleId).toJSNumber();
+  const multipliedHash = bigInt(hash).multiply(32).toJSNumber();
+
   return bigInt(hash).xor(hash >> 3).xor(multipliedHash).toJSNumber();
 }
 
 /**
  * Generates a secret string based on a Fibonacci sequence.
  */
-function secret(size: number, modulo: number, firstSeed: number, secondSeed: number): string {
-  var currentValue = firstSeed + secondSeed;
-  var previousValue = secondSeed;
-  var result = '';
-  for (var i = 0; i < size; i += 1) {
-    var oldValue = currentValue;
+function secret(size: number, modulo: number, firstSeed: number, secondSeed: number): string
+{
+  let currentValue = firstSeed + secondSeed;
+  let previousValue = secondSeed;
+  let result = '';
+
+  for (let i = 0; i < size; i += 1)
+  {
+    const oldValue = currentValue;
     result += String.fromCharCode(currentValue % modulo + 33);
     currentValue += previousValue;
     previousValue = oldValue;
   }
+
   return result;
-}
+}

src/subtitle/formats/ass.ts

@@ -1,22 +1,28 @@
 'use strict';
-export = main;
 import xml2js = require('xml2js');
-import typings = require('../../typings');
 
 /**
  * Converts an input buffer to a SubStation Alpha subtitle.
  */
-function main(input: string|Buffer, done: (err: Error, subtitle?: string) => void) {
+export default function(config: IConfig, input: string|Buffer, done: (err: Error, subtitle?: string) => void)
+{
   xml2js.parseString(input.toString(), {
     explicitArray: false,
     explicitRoot: false
-  }, (err: Error, xml: typings.ISubtitle) => {
-    if (err) return done(err);
-    try {
-      done(null, script(xml) + '\n' +
-        style(xml.styles) + '\n' +
-        event(xml.events));
-    } catch (err) {
+  }, (err: Error, xml: ISubtitle) =>
+  {
+    if (err)
+    {
+      return done(err);
+    }
+
+    try
+    {
+      done(null, script(config, xml) + '\n' +
+          style(xml.styles) + '\n' +
+          event(config, xml.events));
+    } catch (err)
+    {
       done(err);
     }
   });
@@ -25,69 +31,74 @@ function main(input: string|Buffer, done: (err: Error, subtitle?: string) => voi
 /**
  * Converts the event block.
  */
-function event(block: typings.ISubtitleEvent): string {
-  var format = 'Layer,Start,End,Style,Name,MarginL,MarginR,MarginV,Effect,Text';
+function event(config: IConfig, block: ISubtitleEvent): string
+{
+  const format = 'Layer,Start,End,Style,Name,MarginL,MarginR,MarginV,Effect,Text';
+
   return '[Events]\n' +
-    'Format: ' + format + '\n' +
-    block.event.map(style => ('Dialogue: 0,' +
-      style.$.start + ',' +
-      style.$.end + ',' +
-      style.$.style + ',' +
-      style.$.name + ',' +
-      style.$.margin_l + ',' +
-      style.$.margin_r + ',' +
-      style.$.margin_v + ',' +
-      style.$.effect + ',' +
-      style.$.text)).join('\n') + '\n';
+         'Format: ' + format + '\n' + [].concat(block.event).map((style) => ('Dialogue: 0,' +
+              style.$.start + ',' +
+              style.$.end + ',' +
+              style.$.style + ',' +
+              style.$.name + ',' +
+              style.$.margin_l + ',' +
+              style.$.margin_r + ',' +
+              style.$.margin_v + ',' +
+              style.$.effect + ',' +
+              style.$.text)).join('\n') + '\n';
 }
 
 /**
  * Converts the script block.
  */
-function script(block: typings.ISubtitle): string {
+function script(config: IConfig, block: ISubtitle): string
+{
+
   return '[Script Info]\n' +
-    'Title: ' + block.$.title + '\n' +
-    'ScriptType: v4.00+\n' +
-    'WrapStyle: ' + block.$.wrap_style + '\n' +
-    'PlayResX: ' + block.$.play_res_x + '\n' +
-    'PlayResY: ' + block.$.play_res_y + '\n' +
-    'Subtitle ID: ' + block.$.id + '\n' +
-    'Language: ' + block.$.lang_string + '\n' +
-    'Created: ' + block.$.created + '\n';
+         'Origin: Downloaded from Crunchyroll.com  by ' + config.user + '\n' +
+         'Title: ' + block.$.title + '\n' +
+         'ScriptType: v4.00+\n' +
+         'WrapStyle: ' + block.$.wrap_style + '\n' +
+         'PlayResX: ' + block.$.play_res_x + '\n' +
+         'PlayResY: ' + block.$.play_res_y + '\n' +
+         'Subtitle ID: ' + block.$.id + '\n' +
+         'Language: ' + block.$.lang_string + '\n' +
+         'Created: ' + block.$.created + '\n';
 }
 
 /**
  * Converts the style block.
  */
-function style(block: typings.ISubtitleStyle): string {
-  var format = 'Name,Fontname,Fontsize,PrimaryColour,SecondaryColour,' +
-    'OutlineColour,BackColour,Bold,Italic,Underline,StrikeOut,ScaleX,' +
-    'ScaleY,Spacing,Angle,BorderStyle,Outline,Shadow,Alignment,' +
-    'MarginL,MarginR,MarginV,Encoding';
+function style(block: ISubtitleStyle): string
+{
+  const format = 'Name,Fontname,Fontsize,PrimaryColour,SecondaryColour,' +
+               'OutlineColour,BackColour,Bold,Italic,Underline,StrikeOut,ScaleX,' +
+               'ScaleY,Spacing,Angle,BorderStyle,Outline,Shadow,Alignment,' +
+               'MarginL,MarginR,MarginV,Encoding';
+
   return '[V4+ Styles]\n' +
-    'Format: ' + format + '\n' +
-    block.style.map(style => 'Style: ' +
-      style.$.name + ',' +
-      style.$.font_name + ',' +
-      style.$.font_size + ',' +
-      style.$.primary_colour + ',' +
-      style.$.secondary_colour + ',' +
-      style.$.outline_colour + ',' +
-      style.$.back_colour + ',' +
-      style.$.bold + ',' +
-      style.$.italic + ',' +
-      style.$.underline + ',' +
-      style.$.strikeout + ',' +
-      style.$.scale_x + ',' +
-      style.$.scale_y + ',' +
-      style.$.spacing + ',' +
-      style.$.angle + ',' +
-      style.$.border_style + ',' +
-      style.$.outline + ',' +
-      style.$.shadow + ',' +
-      style.$.alignment + ',' +
-      style.$.margin_l + ',' +
-      style.$.margin_r + ',' +
-      style.$.margin_v + ',' +
-      style.$.encoding).join('\n') + '\n';
-}
+         'Format: ' + format + '\n' + [].concat(block.style).map((style) => 'Style: ' +
+              style.$.name + ',' +
+              style.$.font_name + ',' +
+              style.$.font_size + ',' +
+              style.$.primary_colour + ',' +
+              style.$.secondary_colour + ',' +
+              style.$.outline_colour + ',' +
+              style.$.back_colour + ',' +
+              style.$.bold + ',' +
+              style.$.italic + ',' +
+              style.$.underline + ',' +
+              style.$.strikeout + ',' +
+              style.$.scale_x + ',' +
+              style.$.scale_y + ',' +
+              style.$.spacing + ',' +
+              style.$.angle + ',' +
+              style.$.border_style + ',' +
+              style.$.outline + ',' +
+              style.$.shadow + ',' +
+              style.$.alignment + ',' +
+              style.$.margin_l + ',' +
+              style.$.margin_r + ',' +
+              style.$.margin_v + ',' +
+              style.$.encoding).join('\n') + '\n';
+}

src/subtitle/formats/index.ts

@@ -1,10 +1,8 @@
 'use strict';
-export = main;
-import ass = require('./ass');
-import srt = require('./srt');
-import typings = require('../../typings');
+import ass from './ass';
+import srt from './srt';
 
-var main: typings.IFormatterTable = {
-  ass: ass,
-  srt: srt
-};
+export default {
+  ass,
+  srt
+} as IFormatterTable;

src/subtitle/formats/srt.ts

@@ -1,23 +1,33 @@
 'use strict';
-export = srt;
 import xml2js = require('xml2js');
-import typings = require('../../typings');
 
 /**
  * Converts an input buffer to a SubRip subtitle.
  */
-function srt(input: Buffer|string, done: (err: Error, subtitle?: string) => void) {
-  var options = {explicitArray: false, explicitRoot: false};
-  xml2js.parseString(input.toString(), options, (err: Error, xml: typings.ISubtitle) => {
-    try {
-      if (err) return done(err);
-      done(null, xml.events.event.map((event, index) => {
-        var attributes = event.$;
+export default function(config: IConfig, input: Buffer|string, done: (err: Error, subtitle?: string) => void)
+{
+  const options = {explicitArray: false, explicitRoot: false};
+
+  xml2js.parseString(input.toString(), options, (err: Error, xml: ISubtitle) =>
+  {
+    try
+    {
+      if (err)
+      {
+        return done(err);
+      }
+
+      done(null, xml.events.event.map((event, index) =>
+      {
+        const attributes = event.$;
+
         return (index + 1) + '\n' +
-          time(attributes.start) + ' --> ' + time(attributes.end) + '\n' +
-          text(attributes.text) + '\n';
+               time(attributes.start) + ' --> ' + time(attributes.end) + '\n' +
+               text(attributes.text) + '\n';
       }).join('\n'));
-    } catch (err) {
+
+    } catch (err)
+    {
       done(err);
     }
   });
@@ -26,41 +36,59 @@ function srt(input: Buffer|string, done: (err: Error, subtitle?: string) => void
 /**
  * Prefixes a value.
  */
-function prefix(value: string, length: number): string {
-  while (value.length < length) value = '0' + value;
+function prefix(value: string, length: number): string
+{
+  while (value.length < length)
+  {
+    value = '0' + value;
+  }
+
   return value;
 }
 
 /**
  * Suffixes a value.
  */
-function suffix(value: string, length: number): string {
-  while (value.length < length) value = value + '0';
+function suffix(value: string, length: number): string
+{
+  while (value.length < length)
+  {
+    value = value + '0';
+  }
+
   return value;
 }
 
 /**
  * Formats a text value.
  */
-function text(value: string): string {
+function text(value: string): string
+{
   return value
-    .replace(/{\\i1}/g, '<i>').replace(/{\\i0}/g, '</i>')
-    .replace(/{\\b1}/g, '<b>').replace(/{\\b0}/g, '</b>')
-    .replace(/{\\u1}/g, '<u>').replace(/{\\u0}/g, '</u>')
-    .replace(/{[^}]+}/g, '')
-    .replace(/(\s+)?\\n(\s+)?/ig, '\n')
-    .trim();
+      .replace(/{\\i1}/g, '<i>').replace(/{\\i0}/g, '</i>')
+      .replace(/{\\b1}/g, '<b>').replace(/{\\b0}/g, '</b>')
+      .replace(/{\\u1}/g, '<u>').replace(/{\\u0}/g, '</u>')
+      .replace(/{[^}]+}/g, '')
+      .replace(/(\s+)?\\n(\s+)?/ig, '\n')
+      .trim();
 }
 
 /**
  * Formats a time stamp.
  */
-function time(value: string): string {
-  var all = value.match(/^([0-9]+):([0-9]+):([0-9]+)\.([0-9]+)$/);
-  if (!all) throw new Error('Invalid time.');
-  var hours = prefix(all[1], 2);
-  var minutes = prefix(all[2], 2);
-  var seconds = prefix(all[3], 2);
-  var milliseconds = suffix(all[4], 3);
+function time(value: string): string
+{
+  const all = value.match(/^([0-9]+):([0-9]+):([0-9]+)\.([0-9]+)$/);
+
+  if (!all)
+  {
+    throw new Error('Invalid time.');
+  }
+
+  const hours = prefix(all[1], 2);
+  const minutes = prefix(all[2], 2);
+  const seconds = prefix(all[3], 2);
+  const milliseconds = suffix(all[4], 3);
+
   return hours + ':' + minutes + ':' + seconds + ',' + milliseconds;
-}
+}

src/subtitle/index.ts

@@ -1,3 +1,4 @@
 'use strict';
-export import decode = require('./decode');
-export import formats = require('./formats/index');
+import decode from './decode';
+import formats from './formats/index';
+export default {decode, formats};

src/typings.ts

@@ -1,136 +0,0 @@
-export interface IConfig {
-  // Authentication
-  pass?: string;
-  user?: string;
-  // Disables
-  cache?: boolean;
-  merge?: boolean;
-  // Filters
-  episode?: number;
-  volume?: number;
-  // Settings
-  format?: string;
-  output?: string;
-  series?: string;
-  tag?: string;
-}
-
-export interface IConfigLine extends IConfig {
-  args: string[];
-}
-
-export interface IConfigTask {
-  address: string;
-  config: IConfigLine;
-}
-
-export interface IEpisodePage {
-  id: number;
-  episode: number;
-  series: string;
-  volume: number;
-  swf: string;
-}
-
-export interface IEpisodePlayer {
-  subtitle: {
-    id: number;
-    iv: string;
-    data: string;
-  };
-  video: {
-    file: string;
-    host: string;
-  };
-}
-
-export interface IEpisodePlayerConfig {
-  'default:preload': {
-    subtitle: {
-      $: {
-        id: string;
-      };
-      iv: string;
-      data: string;
-    };
-    stream_info: {
-      file: string;
-      host: string;
-    };
-  };
-}
-
-export interface IFormatterTable {
-  [key: string]: (input: string|Buffer, done: (err: Error, subtitle?: string) => void) => void;
-}
-
-export interface ISeries {
-  episodes: ISeriesEpisode[];
-  series: string;
-}
-
-export interface ISeriesEpisode {
-  address: string;
-  episode: number;
-  volume: number;
-}
-
-export interface ISubtitle {
-  $: {
-    title: string;
-    wrap_style: string;
-    play_res_x: string;
-    play_res_y: string;
-    id: string;
-    lang_string: string;
-    created: string;
-  };
-  events: ISubtitleEvent;
-  styles: ISubtitleStyle;
-}
-
-export interface ISubtitleEvent {
-  event: {
-    $: {
-      end: string;
-      start: string;
-      style: string;
-      name: string;
-      margin_l: string;
-      margin_r: string;
-      margin_v: string;
-      effect: string;
-      text: string;
-    };
-  }[];
-}
-
-export interface ISubtitleStyle {
-  style: {
-    $: {
-      name: string;
-      font_name: string;
-      font_size: string;
-      primary_colour: string;
-      secondary_colour: string;
-      outline_colour: string;
-      back_colour: string;
-      bold: string;
-      italic: string;
-      underline: string;
-      strikeout: string;
-      scale_x: string;
-      scale_y: string;
-      spacing: string;
-      angle: string;
-      border_style: string;
-      outline: string;
-      shadow: string;
-      alignment: string;
-      margin_l: string;
-      margin_r: string;
-      margin_v: string;
-      encoding: string;
-    };
-  }[];
-}

src/video/index.ts

@@ -1,3 +1,4 @@
 'use strict';
-export import merge = require('./merge');
-export import stream = require('./stream');
+import merge from './merge';
+import stream from './stream';
+export default {merge, stream};

src/video/merge.ts

@@ -1,47 +1,87 @@
 'use strict';
-export = main;
 import childProcess = require('child_process');
 import fs = require('fs');
-import path = require('path');
 import os = require('os');
-import subtitle = require('../subtitle/index');
-import typings = require('../typings');
+import path = require('path');
+
+import subtitle from '../subtitle/index';
 
 /**
  * Merges the subtitle and video files into a Matroska Multimedia Container.
  */
-function main(config: typings.IConfig, rtmpInputPath: string, filePath: string, done: (err: Error) => void) {
-  var subtitlePath = filePath + '.' + (subtitle.formats[config.format] ? config.format : 'ass');
-  var videoPath = filePath + path.extname(rtmpInputPath);
-  childProcess.exec(command() + ' ' +
-    '-o "' + filePath + '.mkv" ' +
-    '"' + videoPath + '" ' +
-    '"' + subtitlePath + '"', {
-      maxBuffer: Infinity
-    }, err => {
-      if (err) return done(err);
-      unlink(videoPath, subtitlePath, err => {
-        if (err) unlinkTimeout(videoPath, subtitlePath, 5000);
-        done(null);
-      });
+export default function(config: IConfig, isSubtitled: boolean, rtmpInputPath: string, filePath: string,
+                        streamMode: string, verbose: boolean, done: (err: Error) => void)
+{
+  const subtitlePath = filePath + '.' + (subtitle.formats[config.format] ? config.format : 'ass');
+  let videoPath = filePath;
+  let cp;
+
+  if (streamMode === 'RTMP')
+  {
+    videoPath += path.extname(rtmpInputPath);
+  }
+  else
+  {
+    videoPath += '.mp4';
+  }
+
+  cp = childProcess.exec(command() + ' ' +
+        '-o "' + filePath + '.mkv" ' +
+        '"' + videoPath + '" ' +
+        (isSubtitled ? '"' + subtitlePath + '"' : ''), {
+        maxBuffer: Infinity,
+  }, (err) =>
+  {
+    if (err)
+    {
+        return done(err);
+    }
+
+    unlink(videoPath, subtitlePath, (errin) =>
+    {
+      if (errin)
+      {
+          unlinkTimeout(videoPath, subtitlePath, 5000);
+      }
+
+      done(null);
     });
+  });
+
+  if (verbose === true)
+  {
+    cp.stdin.pipe(process.stdin);
+    cp.stdout.pipe(process.stdout);
+    cp.stderr.pipe(process.stderr);
+  }
 }
 
 /**
  * Determines the command for the operating system.
  */
-function command(): string {
-  if (os.platform() !== 'win32') return 'mkvmerge';
-  return path.join(__dirname, '../../bin/mkvmerge.exe');
+function command(): string
+{
+  if (os.platform() !== 'win32')
+  {
+      return 'mkvmerge';
+  }
+
+  return '"' + path.join(__dirname, '../../bin/mkvmerge.exe') + '"';
 }
 
 /**
  * Unlinks the video and subtitle.
  * @private
  */
-function unlink(videoPath: string, subtitlePath: string, done: (err: Error) => void) {
-  fs.unlink(videoPath, err => {
-    if (err) return done(err);
+function unlink(videoPath: string, subtitlePath: string, done: (err: Error) => void)
+{
+  fs.unlink(videoPath, (err) =>
+  {
+    if (err)
+    {
+        return done(err);
+    }
+
     fs.unlink(subtitlePath, done);
   });
 }
@@ -49,10 +89,16 @@ function unlink(videoPath: string, subtitlePath: string, done: (err: Error) => v
 /**
  * Attempts to unlink the video and subtitle with a timeout between each try.
  */
-function unlinkTimeout(videoPath: string, subtitlePath: string, timeout: number) {
-  setTimeout(() => {
-    unlink(videoPath, subtitlePath, err => {
-      if (err) unlinkTimeout(videoPath, subtitlePath, timeout);
+function unlinkTimeout(videoPath: string, subtitlePath: string, timeout: number)
+{
+  setTimeout(() =>
+  {
+    unlink(videoPath, subtitlePath, (err) =>
+    {
+      if (err)
+      {
+          unlinkTimeout(videoPath, subtitlePath, timeout);
+      }
     });
   }, timeout);
-}
+}

src/video/stream.ts

@@ -1,26 +1,61 @@
 'use strict';
-export = main;
 import childProcess = require('child_process');
-import path = require('path');
 import os = require('os');
+import path = require('path');
+
+import log  = require('../log');
 
 /**
  * Streams the video to disk.
  */
-function main(rtmpUrl: string, rtmpInputPath: string, swfUrl: string, filePath: string, done: (err: Error) => void) {
-  childProcess.exec(command() + ' ' +
-    '-r "' + rtmpUrl + '" ' +
-    '-y "' + rtmpInputPath + '" ' +
-    '-W "' + swfUrl + '" ' +
-    '-o "' + filePath + '"', {
-      maxBuffer: Infinity
-    }, done);
+export default function(rtmpUrl: string, rtmpInputPath: string, swfUrl: string, filePath: string,
+                        fileExt: string, mode: string, verbose: boolean, done: (err: Error) => void)
+{
+  let cp;
+  let cmd;
+  if (mode === 'RTMP')
+  {
+       cmd = command('rtmpdump') + ' ' +
+          '-r "' + rtmpUrl + '" ' +
+          '-y "' + rtmpInputPath + '" ' +
+          '-W "' + swfUrl + '" ' +
+          '-o "' + filePath + fileExt + '"';
+  }
+  else if (mode === 'HLS')
+  {
+      cmd = command('ffmpeg') + ' ' +
+          '-y -xerror ' +
+          '-i "' + rtmpInputPath + '" ' +
+          '-c copy -bsf:a aac_adtstoasc ' +
+          '"' + filePath + '.mp4"';
+  }
+  else
+  {
+    log.error('No such mode: ' + mode);
+  }
+
+  cp = childProcess.exec(cmd,
+  {
+      maxBuffer: Infinity,
+  }, done);
+
+  if (verbose === true)
+  {
+    cp.stdin.pipe(process.stdin);
+    cp.stdout.pipe(process.stdout);
+    cp.stderr.pipe(process.stderr);
+  }
 }
 
 /**
  * Determines the command for the operating system.
  */
-function command(): string {
-  if (os.platform() !== 'win32') return 'rtmpdump';
-  return path.join(__dirname, '../../bin/rtmpdump.exe');
-}
+function command(exe: string): string
+{
+  if (os.platform() !== 'win32')
+  {
+    return exe;
+  }
+
+  return '"' + path.join(__dirname, '../../bin/' + exe + '.exe') + '"';
+}

ts.js

@@ -4,6 +4,15 @@ var fs = require('fs');
 var path = require('path');
 var isTest = process.argv[2] === '--only-test';
 
+// TODO: This build task should be removed upon release of TypeScript 1.5 with
+// the support for `tsconfig.json`. Invoking `tsc` from `package.json` will then
+// read the configuration and compile accordingly. It seems that `TSLint` will,
+// eventually, support this mechanism too. That prevents the need for any kind
+// of build task and will run entirely based on instructions from `npm`.
+//
+// Reference #1: https://github.com/Microsoft/TypeScript/issues/1667
+// Reference #2: https://github.com/palantir/tslint/issues/281
+
 read(function(err, fileNames) {
   clean(fileNames, function() {
     var hasLintError = false;
@@ -48,13 +57,13 @@ function clean(filePaths, done) {
  * @param {function(Error)} done
  */
 function compile(filePaths, done) {
-    if (isTest) return done(null);
+  if (isTest) return done(null);
   var execPath = path.join(__dirname, 'node_modules/.bin/tsc');
-  var options = '--declaration --module CommonJS --noImplicitAny --outDir dist';
+  var options = '--declaration --module CommonJS --noImplicitAny --outDir dist --target ES5';
   childProcess.exec([execPath, options].concat(filePaths).join(' '), function(err, stdout) {
-      if (stdout) return done(new Error(stdout));
-      done(null);
-    });
+    if (stdout) return done(new Error(stdout));
+    done(null);
+  });
 }
 
 /**
@@ -83,10 +92,5 @@ function lint(filePaths, handler, done) {
  * @param {function(Error, Array.<string>)} done
  */
 function read(done) {
-  var contents = fs.readFileSync('crunchyroll.js.njsproj', 'utf8');
-  var expression = /<TypeScriptCompile\s+Include="([\w\W]+?\.ts)" \/>/g;
-  var matches;
-  var filePaths = [];
-  while ((matches = expression.exec(contents))) filePaths.push(matches[1]);
-  done(null, filePaths);
-}
+  done(null, JSON.parse(fs.readFileSync('tsconfig.json', 'utf8')).files);
+}

tsconfig.json

@@ -0,0 +1,14 @@
+{
+    "target": "es6",
+    "compilerOptions": {
+        "declaration": true,
+        "noImplicitAny": true,
+        "removeComments": false,
+        "module": "commonjs",
+        "outDir": "dist",
+        "sourceMap": true,
+        "lib": [
+            "es2015"
+        ]
+    }
+}

tsd.json

@@ -1,33 +0,0 @@
-{
-  "version": "v4",
-  "repo": "borisyankov/DefinitelyTyped",
-  "ref": "master",
-  "path": "typings",
-  "bundle": "typings/tsd.d.ts",
-  "installed": {
-    "node/node.d.ts": {
-      "commit": "42c8a3b74c05f6887ce21dd63c6234e424f9f8fe"
-    },
-    "commander/commander.d.ts": {
-      "commit": "42c8a3b74c05f6887ce21dd63c6234e424f9f8fe"
-    },
-    "xml2js/xml2js.d.ts": {
-      "commit": "42c8a3b74c05f6887ce21dd63c6234e424f9f8fe"
-    },
-    "cheerio/cheerio.d.ts": {
-      "commit": "42c8a3b74c05f6887ce21dd63c6234e424f9f8fe"
-    },
-    "mkdirp/mkdirp.d.ts": {
-      "commit": "42c8a3b74c05f6887ce21dd63c6234e424f9f8fe"
-    },
-    "request/request.d.ts": {
-      "commit": "42c8a3b74c05f6887ce21dd63c6234e424f9f8fe"
-    },
-    "big-integer/big-integer.d.ts": {
-      "commit": "42c8a3b74c05f6887ce21dd63c6234e424f9f8fe"
-    },
-    "form-data/form-data.d.ts": {
-      "commit": "42c8a3b74c05f6887ce21dd63c6234e424f9f8fe"
-    }
-  }
-}

tslint.json

@@ -1,4 +1,5 @@
 {
+  "extends": "tslint:latest",
   "rules": {
     "ban": false,
     "class-name": true,
@@ -8,47 +9,39 @@
     "curly": false,
     "eofline": false,
     "forin": true,
-    "indent": [true, 2],
+    "indent": [true, "spaces", 2],
     "interface-name": true,
     "jsdoc-format": true,
     "label-position": true,
-    "label-undefined": true,
     "max-line-length": [true, 140],
-    "member-ordering": [true,
-      "public-before-private",
-      "static-before-instance",
-      "variables-before-functions"
-    ],
+    "member-ordering": false,
+    "no-shadowed-variable": false,
+    "array-type": [true, "array"],
+    "trailing-comma": false,
     "no-any": false,
     "no-arg": true,
     "no-bitwise": true,
+    "prefer-conditional-expression": false,
+    "space-within-parens": false,
+    "no-object-literal-type-assertion": false,
     "no-console": [true,
       "debug",
-      "info",
       "time",
       "timeEnd",
       "trace"
     ],
     "no-construct": true,
-    "no-constructor-vars": true,
     "no-debugger": true,
-    "no-duplicate-key": true,
     "no-duplicate-variable": true,
     "no-empty": true,
     "no-eval": true,
     "no-string-literal": true,
     "no-switch-case-fall-through": true,
-    "no-trailing-comma": true,
     "no-trailing-whitespace": true,
     "no-unused-expression": true,
-    "no-unused-variable": true,
-    "no-unreachable": true,
     "no-use-before-declare": false,
     "no-var-requires": true,
     "one-line": [true,
-      "check-catch",
-      "check-else",
-      "check-open-brace",
       "check-whitespace"
     ],
     "quotemark": [true, "single"],
@@ -66,7 +59,6 @@
       "property-declaration": "nospace",
       "variable-declaration": "nospace"
     }],
-    "use-strict": false,
     "variable-name": false,
     "whitespace": [true,
       "check-branch",
@@ -74,6 +66,8 @@
       "check-operator",
       "check-separator",
       "check-type"
-    ]
+    ],
+    "object-literal-sort-keys": false,
+    "ordered-imports": false
   }
 }