18.07

README.md

@@ -0,0 +1,4 @@
+Server start: nodemon ./back/index,
+Server DOMAIN: http://127.0.0.1:3001,
+Project start: webpack-dev-server --color --watch-content-base --open, 
+Project DOMAIN: http://localhost:9000

app/app.module.js

@@ -0,0 +1 @@
+var app = angular.module('crud', ['ngFileUpload']);

app/constans/webApi.com.js

@@ -0,0 +1,3 @@
+app.constant('WebApi',{
+    DOMAIN: 'http://127.0.0.1:3001'
+})

app/controller/edit.controller.js

@@ -0,0 +1,21 @@
+(function(){
+    'use strict';
+    app.controller('Edit',['$scope','$rootScope', function($scope, $rootScope){
+        
+        $rootScope.$on('EditComment', function(evnt, comments, id){
+            for (let i = 0; i < comments.length; i++) {
+                if(comments[i].id === id){
+                    $scope.editCommetById = comments[i]
+                }
+                
+            }
+        })
+        $scope.saveEdit = function(){
+            $rootScope.$emit('saveEdit', $scope.editCommetById, $scope.editCommetById.id);
+        }
+        $scope.cancelEdit = function(){
+            $rootScope.$emit('cancelEdit', $scope.editCommetById.id);
+        }
+        
+    }])
+})()

app/controller/editSecond.controller.js

@@ -0,0 +1,27 @@
+(function(){
+    'use srict';
+    app.controller('EditSecond', ['$rootScope', '$scope', function($rootScope, $scope){
+        $rootScope.$on('EditSecondComment', function(event, comments, mainId, secondId){
+            
+            for (let i = 0; i < comments.length; i++) {
+                for (let j = 0; j < comments[i].secondComments.length; j++) {
+
+                    if (comments[i].secondComments[j].mainId === mainId) {
+                       
+                        if (comments[i].secondComments[j].id === secondId) {
+                           $scope.editSecondCommetById = comments[i].secondComments[j]
+                        }
+                    }
+                        
+                }
+                
+            }
+        });
+        $scope.saveSecondEdit = function(){
+            $rootScope.$emit('SaveSecondEdit', $scope.editSecondCommetById, $scope.editSecondCommetById.mainId, $scope.editSecondCommetById.id);
+        };
+        $scope.cancelSecondEdit = function(){
+            $rootScope.$emit('CancelSecondEdit', $scope.editSecondCommetById.mainId, $scope.editSecondCommetById.id);
+        };
+    }])
+})()

app/controller/form.controller.js

@@ -0,0 +1,184 @@
+(function(){
+    'use strict';
+    app.controller('Form',['$scope', '$rootScope', 'comment.repository', function($scope, $rootScope, commentRepository,){
+//          Mod FUNCTION
+        $scope.editModToggle = function(id){
+            for (let i = 0; i < $scope.mainComments.length; i++) {
+                if($scope.mainComments[i].id === id){
+                    $scope.mainComments[i].isEditMod = !$scope.mainComments[i].isEditMod
+                }
+                
+            }
+        };
+        
+        $scope.editModSecondToggle = function(mainId, secondId){
+            for (let i = 0; i < $scope.mainComments.length; i++) {
+                for (let j = 0; j < $scope.mainComments[i].secondComments.length; j++) {
+
+                    if ($scope.mainComments[i].secondComments[j].mainId === mainId) {
+                       
+                        if ($scope.mainComments[i].secondComments[j].id === secondId) {
+                            $scope.mainComments[i].secondComments[j].isEditMod = !$scope.mainComments[i].secondComments[j].isEditMod
+                        }
+                    }
+                        
+                }
+                
+            }
+        };
+        $scope.replyModToggle = function(id){
+            for (let i = 0; i < $scope.mainComments.length; i++) {
+                if($scope.mainComments[i].id === id){
+                    $scope.mainComments[i].isReplyMod = !$scope.mainComments[i].isReplyMod
+                }
+                
+            }
+        };
+
+
+//          MAIN Comment
+        commentRepository.getComments().then(function(response){
+            $scope.mainComments = response.data
+        }, function(error) {
+            console.log(error)
+        });
+        $scope.newComment = {
+        authorName: '',
+        foto: '',
+        commentText: '',
+        isEditMod: false,
+        isReplyMod: false,
+        secondComments: []
+        }
+        $scope.addComment = function(){
+            $scope.newComment.id = new Date().getTime();
+            $scope.mainComments.unshift($scope.newComment)
+            commentRepository.addComment($scope.newComment).then(function(response){
+                console.log(response.data)
+                
+            }, function(error) {
+                console.log(error)
+            });
+            $scope.newComment = {
+                authorName: '',
+                foto: '',
+                commentText: '',
+                isEditMod: false,
+                isReplyMod: false,
+                secondComments: []
+                };
+            
+        };
+        $scope.deleteMainComment = function(id){
+            commentRepository.deleteComment(id).then(function(response){
+                console.log(response.data)
+                
+            }, function(error) {
+                console.log(error)
+            });
+            for (let i = 0; i < $scope.mainComments.length; i++) {
+                if($scope.mainComments[i].id === id){
+                    $scope.mainComments.splice(i, 1);
+                }
+            }
+            return $scope.mainComments
+        };
+        $scope.editMainComment = function(id){
+            $scope.editModToggle(id)
+            $rootScope.$broadcast('EditComment', $scope.mainComments, id);
+        };
+        $rootScope.$on('saveEdit', function(event, comment, id){
+            $scope.editModToggle(id)
+            commentRepository.editComment(comment).then(function(response){
+                console.log(response.data)
+                
+            }, function(error) {
+                console.log(error)
+            });
+            for (let i = 0; i < $scope.mainComments.length; i++) {
+                if ($scope.mainComments[i].id === comment.id) {
+                    $scope.mainComments.splice(i,1,comment);
+                }
+                
+            }
+        });
+        $rootScope.$on('cancelEdit', function(event,id){
+            $scope.editModToggle(id)
+        })
+//              SECOND COMMENTS
+
+        $scope.deleteSecondComment = function(mainId, secondId){
+            commentRepository.deleteSecondComment(mainId, secondId).then(function(response){
+                console.log(response.data)
+                
+            }, function(error) {
+                console.log(error)
+            });
+            for (let i = 0; i < $scope.mainComments.length; i++) {
+                for (let j = 0; j < $scope.mainComments[i].secondComments.length; j++) {
+                    if ($scope.mainComments[i].secondComments[j].mainId === mainId) {
+                        if ($scope.mainComments[i].secondComments[j].id === secondId) {
+                            $scope.mainComments[i].secondComments.splice(j,1);
+                        }
+                    }
+                        
+                }
+                
+            }
+        };
+        $scope.editSecondComment = function(mainId, secondId){
+
+            $scope.editModSecondToggle(mainId,secondId)
+            $rootScope.$broadcast('EditSecondComment', $scope.mainComments, mainId, secondId);
+
+        }
+        $rootScope.$on('SaveSecondEdit', function(event,comment, mainId, secondId){
+            $scope.editModSecondToggle(mainId,secondId)
+            commentRepository.editSecondComment(comment).then(function(response){
+                console.log(response.data)
+                
+            }, function(error) {
+                console.log(error)
+            });
+            for (let i = 0; i < $scope.mainComments.length; i++) {
+                for (let j = 0; j < $scope.mainComments[i].secondComments.length; j++) {
+                    if ($scope.mainComments[i].secondComments[j].mainId === comment.mainId) {
+                        if ($scope.mainComments[i].secondComments[j].id === comment.id) {
+                            $scope.mainComments[i].secondComments.splice(j,1,comment);
+                        }
+                    }
+                        
+                }
+                
+            }
+
+        });
+        $rootScope.$on('CancelSecondEdit', function(event, mainId, secondId){
+            $scope.editModSecondToggle(mainId,secondId)
+        });
+
+//          REPLY 
+        $scope.reply = function(id){
+            $scope.replyModToggle(id)
+            $rootScope.$broadcast('Reply', $scope.mainComments, id);
+        };
+        $rootScope.$on('commentReply', function(event,comment, id){
+            $scope.replyModToggle(id)
+            commentRepository.commentReply(comment).then(function(response){
+                console.log(response.data)
+                
+            }, function(error) {
+                console.log(error)
+            });
+            for (let i = 0; i < $scope.mainComments.length; i++) {
+                if ($scope.mainComments[i].id === comment.mainId) {
+                    $scope.mainComments[i].secondComments.unshift(comment);
+                }
+                
+            }
+        });
+        $rootScope.$on('cancelReplyMod', function(event, id){
+            $scope.replyModToggle(id)
+        })
+    }])
+})()

app/controller/reply.controller.js

@@ -0,0 +1,29 @@
+(function(){
+    'use strict';
+    app.controller('Reply', ['$rootScope', '$scope', function($rootScope,$scope){
+        $scope.comment = {authorName: '',
+            foto: '',
+            commentText: '',
+            isEditMod: false,
+            isReplyMod: false,
+            secondComments: []
+            };
+        $rootScope.$on('Reply', function(evnt, commets, id){
+            $scope.comment.id = new Date().getTime()
+           return $scope.comment.mainId = id
+        });
+        $scope.replyComment = function(){
+            $rootScope.$emit('commentReply', $scope.comment, $scope.comment.mainId);
+            return $scope.comment = {authorName: '',
+            foto: '',
+            commentText: '',
+            isEditMod: false,
+            isReplyMod: false,
+            secondComments: []
+            }; 
+        }
+        $scope.replyCancel = function(){
+            $rootScope.$emit('cancelReplyMod',$scope.comment.mainId)
+        }
+    }])
+})()

app/css/style.css

@@ -0,0 +1,48 @@
+img{
+    width: 150px;
+    height: 150px;
+    float: left;
+}
+body{
+    background-color: rgb(210, 247, 242);
+}
+span{
+    font-size: 17px;
+}
+div.container{
+    width: 980px;
+    background-color: white;
+}
+.container textarea{
+    margin: 20px 0 20px 0;
+}
+.btn-foto{
+    margin-top: 20px;
+    display: inline-block;
+    background: grey;
+    color: black;
+}
+.btn-form-comment{
+    margin-top: 20px;
+    float: right;
+}
+.text{
+    font-weight: 700;
+    font-size: 20px;
+}
+.main-comments{
+    margin: 40px 40px;
+}
+.comment-form{
+    margin-left: 180px;
+}
+.float-right{
+    float: right;
+}
+.block {
+    display: block;
+}
+.second-comments{
+    margin: 40px 0 0 70px;
+    height: 180px;
+}

app/services/comment.factory.js

@@ -0,0 +1,37 @@
+(function() {
+
+    'use strict';
+    
+    app.factory('comment.repository', ['WebApi', '$http', function(WebApi, $http) {
+        return {
+            getComments: _getComments,
+            addComment: _addComment,
+            deleteComment: _deleteComment,
+            editComment: _editComment,
+            deleteSecondComment: _deleteSecondComment,
+            editSecondComment: _editSecondComment,
+            commentReply: _commentReply
+        };
+        function _getComments(){
+            return $http.get(WebApi.DOMAIN + '/comments');
+        };
+        function _addComment(data){
+            return $http.post(WebApi.DOMAIN + '/addComment', data);
+        };
+        function _deleteComment(id){
+            return $http.delete(WebApi.DOMAIN + '/deleteComment/' + id);
+        };
+        function _editComment(data){
+            return $http.put(WebApi.DOMAIN + '/editComment/', data);
+        };
+        function _deleteSecondComment(mainId, secondId){
+            return $http.delete(WebApi.DOMAIN + '/deleteSecondComment/' + mainId + '/' + secondId);
+        };
+        function _commentReply(data){
+            return $http.post(WebApi.DOMAIN + '/commentReply', data);
+        };
+        function _editSecondComment(data){
+            return $http.put(WebApi.DOMAIN + '/editSecondComment/', data);
+        };
+    }])
+})()

app/template/editComment.template.html

@@ -0,0 +1,7 @@
+<div ng-controller="Edit">
+    <textarea placeholder="Comment text" class="form-control form-control-lg" ng-model="editCommetById.commentText"></textarea>
+    <input type="text" class="form-control form-control-sm" placeholder="Author name" ng-model="editCommetById.authorName">
+    <div class="btn-foto btn btn-secondary" ngf-select ng-model="newComment.foto" name="file" ngf-pattern="'.jpg, .png'" ngf-accept="'.jpg, .png'" ngf-max-size="20MB" ngf-min-height="100" ngf-resize="{width: 100, height: 100}">Select foto</div>
+    <button type="submit" class="btn-form-comment btn btn-light" ng-click="cancelEdit()">Cancel</button>
+    <button type="submit" style="margin-right: 10px" class="btn-form-comment btn btn-light" ng-click="saveEdit()">Save</button>
+</div>

app/template/editSecondComment.template.html

@@ -0,0 +1,7 @@
+<div ng-controller="EditSecond">
+        <textarea placeholder="Comment text" class="form-control form-control-lg" ng-model="editSecondCommetById.commentText"></textarea>
+        <input type="text" class="form-control form-control-sm" placeholder="Author name" ng-model="editSecondCommetById.authorName">
+        <div class="btn-foto btn btn-secondary" ngf-select ng-model="newComment.foto" name="file" ngf-pattern="'.jpg, .png'" ngf-accept="'.jpg, .png'" ngf-max-size="20MB" ngf-min-height="100" ngf-resize="{width: 100, height: 100}">Select foto</div>
+        <button type="submit" class="btn-form-comment btn btn-light" ng-click="cancelSecondEdit()">Cancel</button>
+        <button type="submit" style="margin-right: 10px" class="btn-form-comment btn btn-light" ng-click="saveSecondEdit()">Save</button>
+</div>

app/template/reply.template.html

@@ -0,0 +1,7 @@
+<div ng-controller="Reply">
+        <textarea placeholder="Comment text" class="form-control form-control-lg" ng-model='comment.commentText'></textarea>
+        <input type="text" class="form-control form-control-sm" placeholder="Author name" ng-model="comment.authorName">
+        <div class="btn-foto btn btn-secondary" ngf-select ng-model="newComment.foto" name="file" ngf-pattern="'.jpg, .png'" ngf-accept="'.jpg, .png'" ngf-max-size="20MB" ngf-min-height="100" ngf-resize="{width: 100, height: 100}">Select foto</div>
+        <button type="submit" class="btn-form-comment btn btn-light" ng-click="replyCancel()">Cancel</button>
+        <button type="submit" style="margin-right: 10px"  class="btn-form-comment btn btn-light" ng-click="replyComment()">Comment</button>
+</div>

back/img.jpg

@@ -0,0 +1 @@
+{}

back/index.js

@@ -0,0 +1,114 @@
+
+var express = require('express');
+var app = express();
+var cors = require('cors');
+var bodyParser = require('body-parser')
+var fs = require('fs');
+app.use(cors());
+
+app.use(bodyParser.json());
+
+app.get('/comments', function(req, res){
+    fs.readFile('comments.txt', function(err, data){
+        return res.status(200).send(JSON.parse(data));
+    }) 
+});
+app.post('/addComment', function(req,res){
+    var body = req.body;
+    fs.readFile('comments.txt', function(err, data){
+        let mainComments = JSON.parse(data);
+        mainComments.unshift(body);
+        fs.writeFile('comments.txt',JSON.stringify(mainComments) ,function(err, data){
+            return res.status(200).send(body);
+        })
+    })  
+});
+app.post('/commentReply', function(req,res){
+    var body = req.body;
+    fs.readFile('comments.txt', function(err, data){
+        let mainComments = JSON.parse(data);
+        for (let i = 0; i < mainComments.length; i++) {
+            if (mainComments[i].id === body.mainId) {
+                mainComments[i].secondComments.unshift(body);
+            }
+        }
+        fs.writeFile('comments.txt',JSON.stringify(mainComments) ,function(err, data){
+            return res.status(200).send(body);
+        })
+    }) 
+});
+app.delete('/deleteComment/:id', function(req ,res){
+    var itemId = +req.params.id
+    fs.readFile('comments.txt', function(err, data){
+        let mainComments = JSON.parse(data);
+        for (let i = 0; i < mainComments.length; i++) {
+            if(mainComments[i].id === itemId){
+                mainComments.splice(i, 1);
+            }
+        }
+        fs.writeFile('comments.txt',JSON.stringify(mainComments) ,function(err, data){
+            return res.status(200).send(data);
+        })
+    })  
+    
+});
+app.delete('/deleteSecondComment/:mainId/:secondId', function(req ,res){
+    var mainId = +req.params.mainId;
+    var secondId = +req.params.secondId;
+    fs.readFile('comments.txt', function(err, data){
+        let mainComments = JSON.parse(data);
+        for (let i = 0; i < mainComments.length; i++) {
+            for (let j = 0; j < mainComments[i].secondComments.length; j++) {
+                if (mainComments[i].secondComments[j].mainId === mainId) {
+                    if (mainComments[i].secondComments[j].id === secondId) {
+                        mainComments[i].secondComments.splice(j,1);
+                    }
+                }
+                    
+            }
+        }
+        fs.writeFile('comments.txt',JSON.stringify(mainComments) ,function(err, data){
+            return res.status(200).send(data);
+        })
+    })
+});
+app.put('/editComment', function(req ,res){
+    var body = req.body
+    fs.readFile('comments.txt', function(err, data){
+        let mainComments = JSON.parse(data);
+        for (let i = 0; i < mainComments.length; i++) {
+            if (mainComments[i].id === body.id) {
+                mainComments.splice(i,1,body);
+            }  
+        }
+        fs.writeFile('comments.txt',JSON.stringify(mainComments) ,function(err, data){
+            return res.status(200).send(body);
+        })
+    })
+});
+app.put('/editSecondComment', function(req ,res){
+    var body = req.body
+    fs.readFile('comments.txt', function(err, data){
+        let mainComments = JSON.parse(data);
+        for (let i = 0; i < mainComments.length; i++) {
+            for (let j = 0; j < mainComments[i].secondComments.length; j++) {
+                if (mainComments[i].secondComments[j].mainId === body.mainId) {
+                    if (mainComments[i].secondComments[j].id === body.id) {
+                        mainComments[i].secondComments.splice(j,1,body);
+                    }
+                }
+            }  
+        }
+        fs.writeFile('comments.txt',JSON.stringify(mainComments) ,function(err, data){
+            return res.status(200).send(body);
+        })
+    }) 
+});
+app.post('/img', function(req ,res){
+    var body = req.body;
+    fs.writeFile('img.jpg',JSON.stringify(body), function(err, data){
+        res.status(200).send(body);
+    })
+    
+})
+app.listen(3001);

index.html

@@ -0,0 +1,69 @@
+<!DOCTYPE html>
+<html lang="en" ng-app='crud'>
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Document</title>
+    <link rel="stylesheet" href="./node_modules/bootstrap/dist/css/bootstrap.css">
+    <link rel="stylesheet" href="./app/css/style.css">
+    
+
+</head>
+<body>
+    <div class="container" ng-controller="Form">
+        <form ng-submit="addComment()" enctype="multipart/form-data">
+            <div class="form-group">
+                <textarea placeholder="Comment text" class="form-control form-control-lg" ng-model="newComment.commentText" required></textarea>
+                <input type="text" class="form-control form-control-sm" placeholder="Author name" ng-model="newComment.authorName" required>
+                 <div class="btn-foto btn btn-secondary" ngf-select ng-model="newComment.foto" name="file" ngf-pattern="'.jpg, .png'" ngf-accept="'.jpg, .png'" ngf-max-size="20MB" ngf-min-height="100" ngf-resize="{width: 100, height: 100}">Select foto</div>
+                <button type="submit" class="btn-form-comment btn btn-light">Comment</button>
+            </div>
+        </form>
+        <div  ng-repeat="comment in mainComments track by $index">
+            <div ng-show="!comment.isEditMod" class="main-comments">
+                <img ngf-thumbnail="comment.foto || './app/img/nofoto.jpg'">
+                <div class="comment-form">
+                    <div class="float-right">
+                        <button class="btn btn-info btn-sm" ng-click="editMainComment(comment.id)">Edit</button>
+                        <button class="btn btn-danger btn-sm" ng-click="deleteMainComment(comment.id)">Delete</button>
+                    </div>
+                    <h2>{{comment.authorName}}</h2>
+                    <span class="block">{{comment.commentText}}</span>
+                    <button class="btn btn-warning btn-sm" ng-click="reply(comment.id)">Reply</button>
+                    <ng-include src="'./app/template/reply.template.html'" ng-show="comment.isReplyMod"></ng-include>  
+                </div>    
+        </div>
+        <ng-include src="'./app/template/editComment.template.html'" ng-show="comment.isEditMod"></ng-include> 
+            <div class="second-comments" style="padding-left: 50px" ng-repeat="secondComment in comment.secondComments">
+                <div ng-show="!secondComment.isEditMod">
+                    <img ngf-thumbnail="comment.foto || './app/img/nofoto.jpg'">
+                    <div class="comment-form">
+                        <div class="float-right">
+                            <button class="btn btn-info btn-sm" ng-click="editSecondComment(comment.id, secondComment.id)">Edit</button>
+                            <button class="btn btn-danger btn-sm" ng-click="deleteSecondComment(comment.id, secondComment.id)">Delete</button>
+                        </div>
+                        <h2>{{secondComment.authorName}}</h2>
+                        <span class="block">{{secondComment.commentText}}</span>
+                    </div>
+                </div>
+                <ng-include src="'./app/template/editSecondComment.template.html'" ng-show="secondComment.isEditMod"></ng-include> 
+            </div>
+        </div>
+        
+    </div>
+    <script type="text/javascript" src="./node_modules/angular/angular.js"></script>
+    <script src="./node_modules/ng-file-upload/dist/ng-file-upload-shim.min.js"></script> 
+    <script src="./node_modules/ng-file-upload/dist/ng-file-upload.min.js"></script>
+
+    <script type="text/javascript" src="./app/app.module.js"></script>
+
+    <script type="text/javascript" src="./app/constans/webApi.com.js"></script>
+    <script type="text/javascript" src="./app/services/comment.factory.js"></script>
+
+
+    <script type="text/javascript" src="./app/controller/form.controller.js"></script>
+    <script type="text/javascript" src="./app/controller/edit.controller.js"></script>
+    <script type="text/javascript" src="./app/controller/editSecond.controller.js"></script>
+    <script type="text/javascript" src="./app/controller/reply.controller.js"></script>
+</body>
+</html>

node_modules/.bin/acorn

@@ -0,0 +1 @@
+../acorn/bin/acorn

node_modules/.bin/ansi-html

@@ -0,0 +1 @@
+../ansi-html/bin/ansi-html

node_modules/.bin/atob

@@ -0,0 +1 @@
+../atob/bin/atob.js

node_modules/.bin/babylon

@@ -0,0 +1 @@
+../babylon/bin/babylon.js

node_modules/.bin/envinfo

@@ -0,0 +1 @@
+../envinfo/dist/cli.js

node_modules/.bin/errno

@@ -0,0 +1 @@
+../errno/cli.js

node_modules/.bin/esparse

@@ -0,0 +1 @@
+../esprima/bin/esparse.js

node_modules/.bin/esvalidate

@@ -0,0 +1 @@
+../esprima/bin/esvalidate.js

node_modules/.bin/glob-all

@@ -0,0 +1 @@
+../glob-all/bin/glob-all

node_modules/.bin/he

@@ -0,0 +1 @@
+../he/bin/he

node_modules/.bin/html-minifier

@@ -0,0 +1 @@
+../html-minifier/cli.js

node_modules/.bin/import-local-fixture

@@ -0,0 +1 @@
+../import-local/fixtures/cli.js

node_modules/.bin/internal-ip

@@ -0,0 +1 @@
+../internal-ip/cli.js

node_modules/.bin/jscodeshift

@@ -0,0 +1 @@
+../jscodeshift/bin/jscodeshift.sh

node_modules/.bin/jsesc

@@ -0,0 +1 @@
+../jsesc/bin/jsesc

node_modules/.bin/json5

@@ -0,0 +1 @@
+../json5/lib/cli.js

node_modules/.bin/loose-envify

@@ -0,0 +1 @@
+../loose-envify/cli.js

node_modules/.bin/miller-rabin

@@ -0,0 +1 @@
+../miller-rabin/bin/miller-rabin

node_modules/.bin/mime

@@ -0,0 +1 @@
+../mime/cli.js

node_modules/.bin/mkdirp

@@ -0,0 +1 @@
+../mkdirp/bin/cmd.js

node_modules/.bin/multicast-dns

@@ -0,0 +1 @@
+../multicast-dns/cli.js

node_modules/.bin/prettier

@@ -0,0 +1 @@
+../prettier/bin-prettier.js

node_modules/.bin/regjsparser

@@ -0,0 +1 @@
+../regjsparser/bin/parser

node_modules/.bin/rimraf

@@ -0,0 +1 @@
+../rimraf/bin.js

node_modules/.bin/semver

@@ -0,0 +1 @@
+../semver/bin/semver

node_modules/.bin/sha.js

@@ -0,0 +1 @@
+../sha.js/bin.js

node_modules/.bin/shjs

@@ -0,0 +1 @@
+../shelljs/bin/shjs

node_modules/.bin/strip-indent

@@ -0,0 +1 @@
+../strip-indent/cli.js

node_modules/.bin/uglifyjs

@@ -0,0 +1 @@
+../uglify-js/bin/uglifyjs

node_modules/.bin/uuid

@@ -0,0 +1 @@
+../uuid/bin/uuid

node_modules/.bin/webpack

@@ -0,0 +1 @@
+../webpack/bin/webpack.js

node_modules/.bin/webpack-cli

@@ -0,0 +1 @@
+../webpack-cli/bin/webpack.js

node_modules/.bin/webpack-dev-server

@@ -0,0 +1 @@
+../webpack-dev-server/bin/webpack-dev-server.js

node_modules/.bin/which

@@ -0,0 +1 @@
+../which/bin/which

node_modules/@mrmlnc/readdir-enhanced/CHANGELOG.md

@@ -0,0 +1,49 @@
+# Change Log
+All notable changes will be documented in this file.
+`readdir-enhanced` adheres to [Semantic Versioning](http://semver.org/).
+
+
+## [v2.2.0](https://github.com/BigstickCarpet/readdir-enhanced/tree/v2.2.0) (2018-01-09)
+
+- Refactored the codebase to use ES6 syntax (Node v4.x compatible)
+
+- You can now provide [your own implementation](https://github.com/BigstickCarpet/readdir-enhanced#custom-fs-methods) for the [filesystem module](https://nodejs.org/api/fs.html) that's used by `readdir-enhanced`.  Just set the `fs` option to your implementation.  Thanks to [@mrmlnc](https://github.com/mrmlnc) for the idea and [the PR](https://github.com/BigstickCarpet/readdir-enhanced/pull/10)!
+
+- [Better error handling](https://github.com/BigstickCarpet/readdir-enhanced/commit/0d330b68524bafbdeae11566a3e8af1bc3f184bf), especially around user-specified logic, such as `options.deep`, `options.filter`, and `options.fs`
+
+[Full Changelog](https://github.com/BigstickCarpet/readdir-enhanced/compare/v2.1.0...v2.2.0)
+
+
+## [v2.1.0](https://github.com/BigstickCarpet/readdir-enhanced/tree/v2.1.0) (2017-12-01)
+
+- The `fs.Stats` objects now include a `depth` property, which indicates the number of subdirectories beneath the base path.  Thanks to [@mrmlnc](https://github.com/mrmlnc) for [the PR](https://github.com/BigstickCarpet/readdir-enhanced/pull/8)!
+
+[Full Changelog](https://github.com/BigstickCarpet/readdir-enhanced/compare/v2.0.0...v2.1.0)
+
+
+## [v2.0.0](https://github.com/BigstickCarpet/readdir-enhanced/tree/v2.0.0) (2017-11-15)
+
+- Dropped support for Node v0.x, which is no longer actively maintained.  Please upgrade to Node 4 or newer.
+
+[Full Changelog](https://github.com/BigstickCarpet/readdir-enhanced/compare/v1.5.0...v2.0.0)
+
+
+## [v1.5.0](https://github.com/BigstickCarpet/readdir-enhanced/tree/v1.5.0) (2017-04-10)
+
+The [`deep` option](README.md#deep) can now be set to a [regular expression](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp), a [glob pattern](https://github.com/isaacs/node-glob#glob-primer), or a function, which allows you to customize which subdirectories get crawled.  Of course, you can also still still set the `deep` option to `true` to crawl _all_ subdirectories, or a number if you just want to limit the recursion depth.
+
+[Full Changelog](https://github.com/BigstickCarpet/readdir-enhanced/compare/v1.4.0...v1.5.0)
+
+
+## [v1.4.0](https://github.com/BigstickCarpet/readdir-enhanced/tree/v1.4.0) (2016-08-26)
+
+The [`filter` option](README.md#filter) can now be set to a regular expression or a glob pattern string, which simplifies filtering based on file names. Of course, you can still set the `filter` option to a function if you need to perform more advanced filtering based on the [`fs.Stats`](https://nodejs.org/api/fs.html#fs_class_fs_stats) of each file.
+
+[Full Changelog](https://github.com/BigstickCarpet/readdir-enhanced/compare/v1.3.4...v1.4.0)
+
+
+## [v1.3.4](https://github.com/BigstickCarpet/readdir-enhanced/tree/v1.3.4) (2016-08-26)
+
+As of this release, `readdir-enhanced` is fully tested on all major Node versions (0.x, 4.x, 5.x, 6.x) on [linux](https://travis-ci.org/BigstickCarpet/readdir-enhanced) and [Windows](https://ci.appveyor.com/project/BigstickCarpet/readdir-enhanced/branch/master), with [nearly 100% code coverage](https://coveralls.io/github/BigstickCarpet/readdir-enhanced?branch=master).  I do all of my local development and testing on MacOS, so that's covered too.
+
+[Full Changelog](https://github.com/BigstickCarpet/readdir-enhanced/compare/v1.0.1...v1.3.4)

node_modules/@mrmlnc/readdir-enhanced/LICENSE

@@ -0,0 +1,23 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 James Messinger
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+.

node_modules/@mrmlnc/readdir-enhanced/lib/async/for-each.js

@@ -0,0 +1,29 @@
+'use strict';
+
+module.exports = asyncForEach;
+
+/**
+ * Simultaneously processes all items in the given array.
+ *
+ * @param {array} array - The array to iterate over
+ * @param {function} iterator - The function to call for each item in the array
+ * @param {function} done - The function to call when all iterators have completed
+ */
+function asyncForEach (array, iterator, done) {
+  if (array.length === 0) {
+    // NOTE: Normally a bad idea to mix sync and async, but it's safe here because
+    // of the way that this method is currently used by DirectoryReader.
+    done();
+    return;
+  }
+
+  // Simultaneously process all items in the array.
+  let pending = array.length;
+  array.forEach(item => {
+    iterator(item, () => {
+      if (--pending === 0) {
+        done();
+      }
+    });
+  });
+}

node_modules/@mrmlnc/readdir-enhanced/lib/async/index.js

@@ -0,0 +1,48 @@
+'use strict';
+
+module.exports = readdirAsync;
+
+const maybe = require('call-me-maybe');
+const DirectoryReader = require('../directory-reader');
+
+let asyncFacade = {
+  fs: require('fs'),
+  forEach: require('./for-each'),
+  async: true
+};
+
+/**
+ * Returns the buffered output from an asynchronous {@link DirectoryReader},
+ * via an error-first callback or a {@link Promise}.
+ *
+ * @param {string} dir
+ * @param {object} [options]
+ * @param {function} [callback]
+ * @param {object} internalOptions
+ */
+function readdirAsync (dir, options, callback, internalOptions) {
+  if (typeof options === 'function') {
+    callback = options;
+    options = undefined;
+  }
+
+  return maybe(callback, new Promise(((resolve, reject) => {
+    let results = [];
+
+    internalOptions.facade = asyncFacade;
+
+    let reader = new DirectoryReader(dir, options, internalOptions);
+    let stream = reader.stream;
+
+    stream.on('error', err => {
+      reject(err);
+      stream.pause();
+    });
+    stream.on('data', result => {
+      results.push(result);
+    });
+    stream.on('end', () => {
+      resolve(results);
+    });
+  })));
+}

node_modules/@mrmlnc/readdir-enhanced/lib/call.js

@@ -0,0 +1,54 @@
+'use strict';
+
+let call = module.exports = {
+  safe: safeCall,
+  once: callOnce,
+};
+
+/**
+ * Calls a function with the given arguments, and ensures that the error-first callback is _always_
+ * invoked exactly once, even if the function throws an error.
+ *
+ * @param {function} fn - The function to invoke
+ * @param {...*} args - The arguments to pass to the function. The final argument must be a callback function.
+ */
+function safeCall (fn, args) {
+  // Get the function arguments as an array
+  args = Array.prototype.slice.call(arguments, 1);
+
+  // Replace the callback function with a wrapper that ensures it will only be called once
+  let callback = call.once(args.pop());
+  args.push(callback);
+
+  try {
+    fn.apply(null, args);
+  }
+  catch (err) {
+    callback(err);
+  }
+}
+
+/**
+ * Returns a wrapper function that ensures the given callback function is only called once.
+ * Subsequent calls are ignored, unless the first argument is an Error, in which case the
+ * error is thrown.
+ *
+ * @param {function} fn - The function that should only be called once
+ * @returns {function}
+ */
+function callOnce (fn) {
+  let fulfilled = false;
+
+  return function onceWrapper (err) {
+    if (!fulfilled) {
+      fulfilled = true;
+      return fn.apply(this, arguments);
+    }
+    else if (err) {
+      // The callback has already been called, but now an error has occurred
+      // (most likely inside the callback function). So re-throw the error,
+      // so it gets handled further up the call stack
+      throw err;
+    }
+  };
+}

node_modules/@mrmlnc/readdir-enhanced/lib/directory-reader.js

@@ -0,0 +1,380 @@
+'use strict';
+
+const Readable = require('stream').Readable;
+const EventEmitter = require('events').EventEmitter;
+const path = require('path');
+const normalizeOptions = require('./normalize-options');
+const stat = require('./stat');
+const call = require('./call');
+
+/**
+ * Asynchronously reads the contents of a directory and streams the results
+ * via a {@link stream.Readable}.
+ */
+class DirectoryReader {
+  /**
+   * @param {string} dir - The absolute or relative directory path to read
+   * @param {object} [options] - User-specified options, if any (see {@link normalizeOptions})
+   * @param {object} internalOptions - Internal options that aren't part of the public API
+   * @class
+   */
+  constructor (dir, options, internalOptions) {
+    this.options = options = normalizeOptions(options, internalOptions);
+
+    // Indicates whether we should keep reading
+    // This is set false if stream.Readable.push() returns false.
+    this.shouldRead = true;
+
+    // The directories to read
+    // (initialized with the top-level directory)
+    this.queue = [{
+      path: dir,
+      basePath: options.basePath,
+      posixBasePath: options.posixBasePath,
+      depth: 0
+    }];
+
+    // The number of directories that are currently being processed
+    this.pending = 0;
+
+    // The data that has been read, but not yet emitted
+    this.buffer = [];
+
+    this.stream = new Readable({ objectMode: true });
+    this.stream._read = () => {
+      // Start (or resume) reading
+      this.shouldRead = true;
+
+      // If we have data in the buffer, then send the next chunk
+      if (this.buffer.length > 0) {
+        this.pushFromBuffer();
+      }
+
+      // If we have directories queued, then start processing the next one
+      if (this.queue.length > 0) {
+        if (this.options.facade.sync) {
+          while (this.queue.length > 0) {
+            this.readNextDirectory();
+          }
+        }
+        else {
+          this.readNextDirectory();
+        }
+      }
+
+      this.checkForEOF();
+    };
+  }
+
+  /**
+   * Reads the next directory in the queue
+   */
+  readNextDirectory () {
+    let facade = this.options.facade;
+    let dir = this.queue.shift();
+    this.pending++;
+
+    // Read the directory listing
+    call.safe(facade.fs.readdir, dir.path, (err, items) => {
+      if (err) {
+        // fs.readdir threw an error
+        this.emit('error', err);
+        return this.finishedReadingDirectory();
+      }
+
+      try {
+        // Process each item in the directory (simultaneously, if async)
+        facade.forEach(
+          items,
+          this.processItem.bind(this, dir),
+          this.finishedReadingDirectory.bind(this, dir)
+        );
+      }
+      catch (err2) {
+        // facade.forEach threw an error
+        // (probably because fs.readdir returned an invalid result)
+        this.emit('error', err2);
+        this.finishedReadingDirectory();
+      }
+    });
+  }
+
+  /**
+   * This method is called after all items in a directory have been processed.
+   *
+   * NOTE: This does not necessarily mean that the reader is finished, since there may still
+   * be other directories queued or pending.
+   */
+  finishedReadingDirectory () {
+    this.pending--;
+
+    if (this.shouldRead) {
+      // If we have directories queued, then start processing the next one
+      if (this.queue.length > 0 && this.options.facade.async) {
+        this.readNextDirectory();
+      }
+
+      this.checkForEOF();
+    }
+  }
+
+  /**
+   * Determines whether the reader has finished processing all items in all directories.
+   * If so, then the "end" event is fired (via {@Readable#push})
+   */
+  checkForEOF () {
+    if (this.buffer.length === 0 &&   // The stuff we've already read
+    this.pending === 0 &&             // The stuff we're currently reading
+    this.queue.length === 0) {        // The stuff we haven't read yet
+      // There's no more stuff!
+      this.stream.push(null);
+    }
+  }
+
+  /**
+   * Processes a single item in a directory.
+   *
+   * If the item is a directory, and `option.deep` is enabled, then the item will be added
+   * to the directory queue.
+   *
+   * If the item meets the filter criteria, then it will be emitted to the reader's stream.
+   *
+   * @param {object} dir - A directory object from the queue
+   * @param {string} item - The name of the item (name only, no path)
+   * @param {function} done - A callback function that is called after the item has been processed
+   */
+  processItem (dir, item, done) {
+    let stream = this.stream;
+    let options = this.options;
+
+    let itemPath = dir.basePath + item;
+    let posixPath = dir.posixBasePath + item;
+    let fullPath = path.join(dir.path, item);
+
+    // If `options.deep` is a number, and we've already recursed to the max depth,
+    // then there's no need to check fs.Stats to know if it's a directory.
+    // If `options.deep` is a function, then we'll need fs.Stats
+    let maxDepthReached = dir.depth >= options.recurseDepth;
+
+    // Do we need to call `fs.stat`?
+    let needStats =
+      !maxDepthReached ||                                 // we need the fs.Stats to know if it's a directory
+      options.stats ||                                    // the user wants fs.Stats objects returned
+      options.recurseFn ||                                // we need fs.Stats for the recurse function
+      options.filterFn ||                                 // we need fs.Stats for the filter function
+      EventEmitter.listenerCount(stream, 'file') ||       // we need the fs.Stats to know if it's a file
+      EventEmitter.listenerCount(stream, 'directory') ||  // we need the fs.Stats to know if it's a directory
+      EventEmitter.listenerCount(stream, 'symlink');      // we need the fs.Stats to know if it's a symlink
+
+    // If we don't need stats, then exit early
+    if (!needStats) {
+      if (this.filter(itemPath, posixPath)) {
+        this.pushOrBuffer({ data: itemPath });
+      }
+      return done();
+    }
+
+    // Get the fs.Stats object for this path
+    stat(options.facade.fs, fullPath, (err, stats) => {
+      if (err) {
+        // fs.stat threw an error
+        this.emit('error', err);
+        return done();
+      }
+
+      try {
+        // Add the item's path to the fs.Stats object
+        // The base of this path, and its separators are determined by the options
+        // (i.e. options.basePath and options.sep)
+        stats.path = itemPath;
+
+        // Add depth of the path to the fs.Stats object for use this in the filter function
+        stats.depth = dir.depth;
+
+        if (this.shouldRecurse(stats, posixPath, maxDepthReached)) {
+          // Add this subdirectory to the queue
+          this.queue.push({
+            path: fullPath,
+            basePath: itemPath + options.sep,
+            posixBasePath: posixPath + '/',
+            depth: dir.depth + 1,
+          });
+        }
+
+        // Determine whether this item matches the filter criteria
+        if (this.filter(stats, posixPath)) {
+          this.pushOrBuffer({
+            data: options.stats ? stats : itemPath,
+            file: stats.isFile(),
+            directory: stats.isDirectory(),
+            symlink: stats.isSymbolicLink(),
+          });
+        }
+
+        done();
+      }
+      catch (err2) {
+        // An error occurred while processing the item
+        // (probably during a user-specified function, such as options.deep, options.filter, etc.)
+        this.emit('error', err2);
+        done();
+      }
+    });
+  }
+
+  /**
+   * Pushes the given chunk of data to the stream, or adds it to the buffer,
+   * depending on the state of the stream.
+   *
+   * @param {object} chunk
+   */
+  pushOrBuffer (chunk) {
+    // Add the chunk to the buffer
+    this.buffer.push(chunk);
+
+    // If we're still reading, then immediately emit the next chunk in the buffer
+    // (which may or may not be the chunk that we just added)
+    if (this.shouldRead) {
+      this.pushFromBuffer();
+    }
+  }
+
+  /**
+   * Immediately pushes the next chunk in the buffer to the reader's stream.
+   * The "data" event will always be fired (via {@link Readable#push}).
+   * In addition, the "file", "directory", and/or "symlink" events may be fired,
+   * depending on the type of properties of the chunk.
+   */
+  pushFromBuffer () {
+    let stream = this.stream;
+    let chunk = this.buffer.shift();
+
+    // Stream the data
+    try {
+      this.shouldRead = stream.push(chunk.data);
+    }
+    catch (err) {
+      this.emit('error', err);
+    }
+
+    // Also emit specific events, based on the type of chunk
+    chunk.file && this.emit('file', chunk.data);
+    chunk.symlink && this.emit('symlink', chunk.data);
+    chunk.directory && this.emit('directory', chunk.data);
+  }
+
+  /**
+   * Determines whether the given directory meets the user-specified recursion criteria.
+   * If the user didn't specify recursion criteria, then this function will default to true.
+   *
+   * @param {fs.Stats} stats - The directory's {@link fs.Stats} object
+   * @param {string} posixPath - The item's POSIX path (used for glob matching)
+   * @param {boolean} maxDepthReached - Whether we've already crawled the user-specified depth
+   * @returns {boolean}
+   */
+  shouldRecurse (stats, posixPath, maxDepthReached) {
+    let options = this.options;
+
+    if (maxDepthReached) {
+      // We've already crawled to the maximum depth. So no more recursion.
+      return false;
+    }
+    else if (!stats.isDirectory()) {
+      // It's not a directory. So don't try to crawl it.
+      return false;
+    }
+    else if (options.recurseGlob) {
+      // Glob patterns are always tested against the POSIX path, even on Windows
+      // https://github.com/isaacs/node-glob#windows
+      return options.recurseGlob.test(posixPath);
+    }
+    else if (options.recurseRegExp) {
+      // Regular expressions are tested against the normal path
+      // (based on the OS or options.sep)
+      return options.recurseRegExp.test(stats.path);
+    }
+    else if (options.recurseFn) {
+      try {
+        // Run the user-specified recursion criteria
+        return options.recurseFn.call(null, stats);
+      }
+      catch (err) {
+        // An error occurred in the user's code.
+        // In Sync and Async modes, this will return an error.
+        // In Streaming mode, we emit an "error" event, but continue processing
+        this.emit('error', err);
+      }
+    }
+    else {
+      // No recursion function was specified, and we're within the maximum depth.
+      // So crawl this directory.
+      return true;
+    }
+  }
+
+  /**
+   * Determines whether the given item meets the user-specified filter criteria.
+   * If the user didn't specify a filter, then this function will always return true.
+   *
+   * @param {string|fs.Stats} value - Either the item's path, or the item's {@link fs.Stats} object
+   * @param {string} posixPath - The item's POSIX path (used for glob matching)
+   * @returns {boolean}
+   */
+  filter (value, posixPath) {
+    let options = this.options;
+
+    if (options.filterGlob) {
+      // Glob patterns are always tested against the POSIX path, even on Windows
+      // https://github.com/isaacs/node-glob#windows
+      return options.filterGlob.test(posixPath);
+    }
+    else if (options.filterRegExp) {
+      // Regular expressions are tested against the normal path
+      // (based on the OS or options.sep)
+      return options.filterRegExp.test(value.path || value);
+    }
+    else if (options.filterFn) {
+      try {
+        // Run the user-specified filter function
+        return options.filterFn.call(null, value);
+      }
+      catch (err) {
+        // An error occurred in the user's code.
+        // In Sync and Async modes, this will return an error.
+        // In Streaming mode, we emit an "error" event, but continue processing
+        this.emit('error', err);
+      }
+    }
+    else {
+      // No filter was specified, so match everything
+      return true;
+    }
+  }
+
+  /**
+   * Emits an event.  If one of the event listeners throws an error,
+   * then an "error" event is emitted.
+   *
+   * @param {string} eventName
+   * @param {*} data
+   */
+  emit (eventName, data) {
+    let stream = this.stream;
+
+    try {
+      stream.emit(eventName, data);
+    }
+    catch (err) {
+      if (eventName === 'error') {
+        // Don't recursively emit "error" events.
+        // If the first one fails, then just throw
+        throw err;
+      }
+      else {
+        stream.emit('error', err);
+      }
+    }
+  }
+}
+
+module.exports = DirectoryReader;

node_modules/@mrmlnc/readdir-enhanced/lib/index.js

@@ -0,0 +1,85 @@
+'use strict';
+
+const readdirSync = require('./sync');
+const readdirAsync = require('./async');
+const readdirStream = require('./stream');
+
+module.exports = exports = readdirAsyncPath;
+exports.readdir = exports.readdirAsync = exports.async = readdirAsyncPath;
+exports.readdirAsyncStat = exports.async.stat = readdirAsyncStat;
+exports.readdirStream = exports.stream = readdirStreamPath;
+exports.readdirStreamStat = exports.stream.stat = readdirStreamStat;
+exports.readdirSync = exports.sync = readdirSyncPath;
+exports.readdirSyncStat = exports.sync.stat = readdirSyncStat;
+
+/**
+ * Synchronous readdir that returns an array of string paths.
+ *
+ * @param {string} dir
+ * @param {object} [options]
+ * @returns {string[]}
+ */
+function readdirSyncPath (dir, options) {
+  return readdirSync(dir, options, {});
+}
+
+/**
+ * Synchronous readdir that returns results as an array of {@link fs.Stats} objects
+ *
+ * @param {string} dir
+ * @param {object} [options]
+ * @returns {fs.Stats[]}
+ */
+function readdirSyncStat (dir, options) {
+  return readdirSync(dir, options, { stats: true });
+}
+
+/**
+ * Aynchronous readdir (accepts an error-first callback or returns a {@link Promise}).
+ * Results are an array of path strings.
+ *
+ * @param {string} dir
+ * @param {object} [options]
+ * @param {function} [callback]
+ * @returns {Promise<string[]>}
+ */
+function readdirAsyncPath (dir, options, callback) {
+  return readdirAsync(dir, options, callback, {});
+}
+
+/**
+ * Aynchronous readdir (accepts an error-first callback or returns a {@link Promise}).
+ * Results are an array of {@link fs.Stats} objects.
+ *
+ * @param {string} dir
+ * @param {object} [options]
+ * @param {function} [callback]
+ * @returns {Promise<fs.Stats[]>}
+ */
+function readdirAsyncStat (dir, options, callback) {
+  return readdirAsync(dir, options, callback, { stats: true });
+}
+
+/**
+ * Aynchronous readdir that returns a {@link stream.Readable} (which is also an {@link EventEmitter}).
+ * All stream data events ("data", "file", "directory", "symlink") are passed a path string.
+ *
+ * @param {string} dir
+ * @param {object} [options]
+ * @returns {stream.Readable}
+ */
+function readdirStreamPath (dir, options) {
+  return readdirStream(dir, options, {});
+}
+
+/**
+ * Aynchronous readdir that returns a {@link stream.Readable} (which is also an {@link EventEmitter})
+ * All stream data events ("data", "file", "directory", "symlink") are passed an {@link fs.Stats} object.
+ *
+ * @param {string} dir
+ * @param {object} [options]
+ * @returns {stream.Readable}
+ */
+function readdirStreamStat (dir, options) {
+  return readdirStream(dir, options, { stats: true });
+}

node_modules/@mrmlnc/readdir-enhanced/lib/normalize-options.js

@@ -0,0 +1,177 @@
+'use strict';
+
+const path = require('path');
+const globToRegExp = require('glob-to-regexp');
+
+module.exports = normalizeOptions;
+
+let isWindows = /^win/.test(process.platform);
+
+/**
+ * @typedef {Object} FSFacade
+ * @property {fs.readdir} readdir
+ * @property {fs.stat} stat
+ * @property {fs.lstat} lstat
+ */
+
+/**
+ * Validates and normalizes the options argument
+ *
+ * @param {object} [options] - User-specified options, if any
+ * @param {object} internalOptions - Internal options that aren't part of the public API
+ *
+ * @param {number|boolean|function} [options.deep]
+ * The number of directories to recursively traverse. Any falsy value or negative number will
+ * default to zero, so only the top-level contents will be returned. Set to `true` or `Infinity`
+ * to traverse all subdirectories.  Or provide a function that accepts a {@link fs.Stats} object
+ * and returns a truthy value if the directory's contents should be crawled.
+ *
+ * @param {function|string|RegExp} [options.filter]
+ * A function that accepts a {@link fs.Stats} object and returns a truthy value if the data should
+ * be returned.  Or a RegExp or glob string pattern, to filter by file name.
+ *
+ * @param {string} [options.sep]
+ * The path separator to use. By default, the OS-specific separator will be used, but this can be
+ * set to a specific value to ensure consistency across platforms.
+ *
+ * @param {string} [options.basePath]
+ * The base path to prepend to each result. If empty, then all results will be relative to `dir`.
+ *
+ * @param {FSFacade} [options.fs]
+ * Synchronous or asynchronous facades for Node.js File System module
+ *
+ * @param {object} [internalOptions.facade]
+ * Synchronous or asynchronous facades for various methods, including for the Node.js File System module
+ *
+ * @param {boolean} [internalOptions.emit]
+ * Indicates whether the reader should emit "file", "directory", and "symlink" events
+ *
+ * @param {boolean} [internalOptions.stats]
+ * Indicates whether the reader should emit {@link fs.Stats} objects instead of path strings
+ *
+ * @returns {object}
+ */
+function normalizeOptions (options, internalOptions) {
+  if (options === null || options === undefined) {
+    options = {};
+  }
+  else if (typeof options !== 'object') {
+    throw new TypeError('options must be an object');
+  }
+
+  let recurseDepth, recurseFn, recurseRegExp, recurseGlob, deep = options.deep;
+  if (deep === null || deep === undefined) {
+    recurseDepth = 0;
+  }
+  else if (typeof deep === 'boolean') {
+    recurseDepth = deep ? Infinity : 0;
+  }
+  else if (typeof deep === 'number') {
+    if (deep < 0 || isNaN(deep)) {
+      throw new Error('options.deep must be a positive number');
+    }
+    else if (Math.floor(deep) !== deep) {
+      throw new Error('options.deep must be an integer');
+    }
+    else {
+      recurseDepth = deep;
+    }
+  }
+  else if (typeof deep === 'function') {
+    recurseDepth = Infinity;
+    recurseFn = deep;
+  }
+  else if (deep instanceof RegExp) {
+    recurseDepth = Infinity;
+    recurseRegExp = deep;
+  }
+  else if (typeof deep === 'string' && deep.length > 0) {
+    recurseDepth = Infinity;
+    recurseGlob = globToRegExp(deep, { extended: true, globstar: true });
+  }
+  else {
+    throw new TypeError('options.deep must be a boolean, number, function, regular expression, or glob pattern');
+  }
+
+  let filterFn, filterRegExp, filterGlob, filter = options.filter;
+  if (filter !== null && filter !== undefined) {
+    if (typeof filter === 'function') {
+      filterFn = filter;
+    }
+    else if (filter instanceof RegExp) {
+      filterRegExp = filter;
+    }
+    else if (typeof filter === 'string' && filter.length > 0) {
+      filterGlob = globToRegExp(filter, { extended: true, globstar: true });
+    }
+    else {
+      throw new TypeError('options.filter must be a function, regular expression, or glob pattern');
+    }
+  }
+
+  let sep = options.sep;
+  if (sep === null || sep === undefined) {
+    sep = path.sep;
+  }
+  else if (typeof sep !== 'string') {
+    throw new TypeError('options.sep must be a string');
+  }
+
+  let basePath = options.basePath;
+  if (basePath === null || basePath === undefined) {
+    basePath = '';
+  }
+  else if (typeof basePath === 'string') {
+    // Append a path separator to the basePath, if necessary
+    if (basePath && basePath.substr(-1) !== sep) {
+      basePath += sep;
+    }
+  }
+  else {
+    throw new TypeError('options.basePath must be a string');
+  }
+
+  // Convert the basePath to POSIX (forward slashes)
+  // so that glob pattern matching works consistently, even on Windows
+  let posixBasePath = basePath;
+  if (posixBasePath && sep !== '/') {
+    posixBasePath = posixBasePath.replace(new RegExp('\\' + sep, 'g'), '/');
+
+    /* istanbul ignore if */
+    if (isWindows) {
+      // Convert Windows root paths (C:\) and UNCs (\\) to POSIX root paths
+      posixBasePath = posixBasePath.replace(/^([a-zA-Z]\:\/|\/\/)/, '/');
+    }
+  }
+
+  // Determine which facade methods to use
+  let facade;
+  if (options.fs === null || options.fs === undefined) {
+    // The user didn't provide their own facades, so use our internal ones
+    facade = internalOptions.facade;
+  }
+  else if (typeof options.fs === 'object') {
+    // Merge the internal facade methods with the user-provided `fs` facades
+    facade = Object.assign({}, internalOptions.facade);
+    facade.fs = Object.assign({}, internalOptions.facade.fs, options.fs);
+  }
+  else {
+    throw new TypeError('options.fs must be an object');
+  }
+
+  return {
+    recurseDepth,
+    recurseFn,
+    recurseRegExp,
+    recurseGlob,
+    filterFn,
+    filterRegExp,
+    filterGlob,
+    sep,
+    basePath,
+    posixBasePath,
+    facade,
+    emit: !!internalOptions.emit,
+    stats: !!internalOptions.stats,
+  };
+}

node_modules/@mrmlnc/readdir-enhanced/lib/stat.js

@@ -0,0 +1,74 @@
+'use strict';
+
+const call = require('./call');
+
+module.exports = stat;
+
+/**
+ * Retrieves the {@link fs.Stats} for the given path. If the path is a symbolic link,
+ * then the Stats of the symlink's target are returned instead.  If the symlink is broken,
+ * then the Stats of the symlink itself are returned.
+ *
+ * @param {object} fs - Synchronous or Asynchronouse facade for the "fs" module
+ * @param {string} path - The path to return stats for
+ * @param {function} callback
+ */
+function stat (fs, path, callback) {
+  let isSymLink = false;
+
+  call.safe(fs.lstat, path, (err, lstats) => {
+    if (err) {
+      // fs.lstat threw an eror
+      return callback(err);
+    }
+
+    try {
+      isSymLink = lstats.isSymbolicLink();
+    }
+    catch (err2) {
+      // lstats.isSymbolicLink() threw an error
+      // (probably because fs.lstat returned an invalid result)
+      return callback(err2);
+    }
+
+    if (isSymLink) {
+      // Try to resolve the symlink
+      symlinkStat(fs, path, lstats, callback);
+    }
+    else {
+      // It's not a symlink, so return the stats as-is
+      callback(null, lstats);
+    }
+  });
+}
+
+/**
+ * Retrieves the {@link fs.Stats} for the target of the given symlink.
+ * If the symlink is broken, then the Stats of the symlink itself are returned.
+ *
+ * @param {object} fs - Synchronous or Asynchronouse facade for the "fs" module
+ * @param {string} path - The path of the symlink to return stats for
+ * @param {object} lstats - The stats of the symlink
+ * @param {function} callback
+ */
+function symlinkStat (fs, path, lstats, callback) {
+  call.safe(fs.stat, path, (err, stats) => {
+    if (err) {
+      // The symlink is broken, so return the stats for the link itself
+      return callback(null, lstats);
+    }
+
+    try {
+      // Return the stats for the resolved symlink target,
+      // and override the `isSymbolicLink` method to indicate that it's a symlink
+      stats.isSymbolicLink = () => true;
+    }
+    catch (err2) {
+      // Setting stats.isSymbolicLink threw an error
+      // (probably because fs.stat returned an invalid result)
+      return callback(err2);
+    }
+
+    callback(null, stats);
+  });
+}

node_modules/@mrmlnc/readdir-enhanced/lib/stream/index.js

@@ -0,0 +1,25 @@
+'use strict';
+
+module.exports = readdirStream;
+
+const DirectoryReader = require('../directory-reader');
+
+let streamFacade = {
+  fs: require('fs'),
+  forEach: require('../async/for-each'),
+  async: true
+};
+
+/**
+ * Returns the {@link stream.Readable} of an asynchronous {@link DirectoryReader}.
+ *
+ * @param {string} dir
+ * @param {object} [options]
+ * @param {object} internalOptions
+ */
+function readdirStream (dir, options, internalOptions) {
+  internalOptions.facade = streamFacade;
+
+  let reader = new DirectoryReader(dir, options, internalOptions);
+  return reader.stream;
+}

node_modules/@mrmlnc/readdir-enhanced/lib/sync/for-each.js

@@ -0,0 +1,22 @@
+'use strict';
+
+module.exports = syncForEach;
+
+/**
+ * A facade that allows {@link Array.forEach} to be called as though it were asynchronous.
+ *
+ * @param {array} array - The array to iterate over
+ * @param {function} iterator - The function to call for each item in the array
+ * @param {function} done - The function to call when all iterators have completed
+ */
+function syncForEach (array, iterator, done) {
+  array.forEach(item => {
+    iterator(item, () => {
+      // Note: No error-handling here because this is currently only ever called
+      // by DirectoryReader, which never passes an `error` parameter to the callback.
+      // Instead, DirectoryReader emits an "error" event if an error occurs.
+    });
+  });
+
+  done();
+}

node_modules/@mrmlnc/readdir-enhanced/lib/sync/fs.js

@@ -0,0 +1,64 @@
+'use strict';
+
+const fs = require('fs');
+const call = require('../call');
+
+/**
+ * A facade around {@link fs.readdirSync} that allows it to be called
+ * the same way as {@link fs.readdir}.
+ *
+ * @param {string} dir
+ * @param {function} callback
+ */
+exports.readdir = function (dir, callback) {
+  // Make sure the callback is only called once
+  callback = call.once(callback);
+
+  try {
+    let items = fs.readdirSync(dir);
+    callback(null, items);
+  }
+  catch (err) {
+    callback(err);
+  }
+};
+
+/**
+ * A facade around {@link fs.statSync} that allows it to be called
+ * the same way as {@link fs.stat}.
+ *
+ * @param {string} path
+ * @param {function} callback
+ */
+exports.stat = function (path, callback) {
+  // Make sure the callback is only called once
+  callback = call.once(callback);
+
+  try {
+    let stats = fs.statSync(path);
+    callback(null, stats);
+  }
+  catch (err) {
+    callback(err);
+  }
+};
+
+/**
+ * A facade around {@link fs.lstatSync} that allows it to be called
+ * the same way as {@link fs.lstat}.
+ *
+ * @param {string} path
+ * @param {function} callback
+ */
+exports.lstat = function (path, callback) {
+  // Make sure the callback is only called once
+  callback = call.once(callback);
+
+  try {
+    let stats = fs.lstatSync(path);
+    callback(null, stats);
+  }
+  catch (err) {
+    callback(err);
+  }
+};

node_modules/@mrmlnc/readdir-enhanced/lib/sync/index.js

@@ -0,0 +1,34 @@
+'use strict';
+
+module.exports = readdirSync;
+
+const DirectoryReader = require('../directory-reader');
+
+let syncFacade = {
+  fs: require('./fs'),
+  forEach: require('./for-each'),
+  sync: true
+};
+
+/**
+ * Returns the buffered output from a synchronous {@link DirectoryReader}.
+ *
+ * @param {string} dir
+ * @param {object} [options]
+ * @param {object} internalOptions
+ */
+function readdirSync (dir, options, internalOptions) {
+  internalOptions.facade = syncFacade;
+
+  let reader = new DirectoryReader(dir, options, internalOptions);
+  let stream = reader.stream;
+
+  let results = [];
+  let data = stream.read();
+  while (data !== null) {
+    results.push(data);
+    data = stream.read();
+  }
+
+  return results;
+}

node_modules/@mrmlnc/readdir-enhanced/package.json

@@ -0,0 +1,118 @@
+{
+  "_args": [
+    [
+      "@mrmlnc/readdir-enhanced@^2.2.1",
+      "/home/seleznev/project Angular/Quality system/node_modules/fast-glob"
+    ]
+  ],
+  "_from": "@mrmlnc/readdir-enhanced@>=2.2.1 <3.0.0",
+  "_id": "@mrmlnc/readdir-enhanced@2.2.1",
+  "_inCache": true,
+  "_installable": true,
+  "_location": "/@mrmlnc/readdir-enhanced",
+  "_nodeVersion": "9.4.0",
+  "_npmOperationalInternal": {
+    "host": "s3://npm-registry-packages",
+    "tmp": "tmp/readdir-enhanced_2.2.1_1518542538843_0.9963591147462021"
+  },
+  "_npmUser": {
+    "email": "dmalinochkin@rambler.ru",
+    "name": "mrmlnc"
+  },
+  "_npmVersion": "5.6.0",
+  "_phantomChildren": {},
+  "_requested": {
+    "name": "@mrmlnc/readdir-enhanced",
+    "raw": "@mrmlnc/readdir-enhanced@^2.2.1",
+    "rawSpec": "^2.2.1",
+    "scope": "@mrmlnc",
+    "spec": ">=2.2.1 <3.0.0",
+    "type": "range"
+  },
+  "_requiredBy": [
+    "/fast-glob"
+  ],
+  "_resolved": "https://registry.npmjs.org/@mrmlnc/readdir-enhanced/-/readdir-enhanced-2.2.1.tgz",
+  "_shasum": "524af240d1a360527b730475ecfa1344aa540dde",
+  "_shrinkwrap": null,
+  "_spec": "@mrmlnc/readdir-enhanced@^2.2.1",
+  "_where": "/home/seleznev/project Angular/Quality system/node_modules/fast-glob",
+  "author": {
+    "name": "James Messinger",
+    "url": "http://bigstickcarpet.com"
+  },
+  "bugs": {
+    "url": "https://github.com/bigstickcarpet/readdir-enhanced/issues"
+  },
+  "dependencies": {
+    "call-me-maybe": "^1.0.1",
+    "glob-to-regexp": "^0.3.0"
+  },
+  "description": "fs.readdir with sync, async, and streaming APIs + filtering, recursion, absolute paths, etc.",
+  "devDependencies": {
+    "chai": "^4.1.2",
+    "codacy-coverage": "^2.0.3",
+    "coveralls": "^3.0.0",
+    "del": "^3.0.0",
+    "eslint": "^4.15.0",
+    "eslint-config-modular": "^4.1.1",
+    "istanbul": "^0.4.5",
+    "mkdirp": "^0.5.1",
+    "mocha": "^4.1.0",
+    "npm-check": "^5.5.2",
+    "through2": "^2.0.3",
+    "version-bump-prompt": "^4.0.0"
+  },
+  "directories": {},
+  "dist": {
+    "fileCount": 16,
+    "integrity": "sha512-bPHp6Ji8b41szTOcaP63VlnbbO5Ny6dwAATtY6JTjh5N2OLrb5Qk/Th5cRkRQhkWCt+EJsYrNB0MiL+Gpn6e3g==",
+    "shasum": "524af240d1a360527b730475ecfa1344aa540dde",
+    "tarball": "https://registry.npmjs.org/@mrmlnc/readdir-enhanced/-/readdir-enhanced-2.2.1.tgz",
+    "unpackedSize": 53874
+  },
+  "engines": {
+    "node": ">=4"
+  },
+  "files": [
+    "lib",
+    "types.d.ts"
+  ],
+  "gitHead": "1580afe4fdf21cd191c202ec599d1ca7d0ab062d",
+  "homepage": "https://github.com/bigstickcarpet/readdir-enhanced",
+  "keywords": [
+    "absolute",
+    "deep",
+    "event",
+    "filter",
+    "fs",
+    "readdir",
+    "recursive",
+    "stream"
+  ],
+  "license": "MIT",
+  "main": "lib/index.js",
+  "maintainers": [
+    {
+      "name": "mrmlnc",
+      "email": "dmalinochkin@rambler.ru"
+    }
+  ],
+  "name": "@mrmlnc/readdir-enhanced",
+  "optionalDependencies": {},
+  "readme": "ERROR: No README data found!",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bigstickcarpet/readdir-enhanced.git"
+  },
+  "scripts": {
+    "bump": "bump --prompt --tag --push --all",
+    "cover": "istanbul cover _mocha",
+    "lint": "eslint lib test --fix",
+    "release": "npm run upgrade && npm test && npm run bump && npm publish",
+    "test": "mocha && npm run lint",
+    "upgrade": "npm-check -u"
+  },
+  "typings": "types.d.ts",
+  "version": "2.2.1"
+}

node_modules/@mrmlnc/readdir-enhanced/types.d.ts

@@ -0,0 +1,67 @@
+/// <reference types="node" />
+
+import fs = require('fs');
+
+declare namespace re {
+    interface Entry extends fs.Stats {
+        path: string;
+        depth: number;
+    }
+
+    type FilterFunction = (stat: Entry) => boolean;
+    type Callback<T> = (err: NodeJS.ErrnoException, result: T) => void;
+    type CallbackString = Callback<string[]>;
+    type CallbackEntry = Callback<Entry[]>;
+
+    interface FileSystem {
+        readdir?: (path: string, callback: Callback<string[]>) => void;
+        lstat?: (path: string, callback: Callback<fs.Stats>) => void;
+        stat?: (path: string, callback: Callback<fs.Stats>) => void;
+    }
+
+    interface Options {
+        filter?: string | RegExp | FilterFunction;
+        deep?: boolean | number | RegExp | FilterFunction;
+        sep?: string;
+        basePath?: string;
+        fs?: FileSystem;
+    }
+
+    function stat(root: string, options?: Options): Promise<Entry[]>;
+    function stat(root: string, callback: CallbackEntry): void;
+    function stat(root: string, options: Options, callback: CallbackEntry): void;
+
+    function async(root: string, options?: Options): Promise<string[]>;
+    function async(root: string, callback: CallbackString): void;
+    function async(root: string, options: Options, callback: CallbackString): void;
+
+    function readdirAsyncStat(root: string, options?: Options): Promise<Entry[]>;
+    function readdirAsyncStat(root: string, callback: CallbackEntry): void;
+    function readdirAsyncStat(root: string, options: Options, callback: CallbackEntry): void;
+
+    namespace async {
+        function stat(root: string, options?: Options): Promise<Entry[]>;
+        function stat(root: string, callback: CallbackEntry): void;
+        function stat(root: string, options: Options, callback: CallbackEntry): void;
+    }
+
+    function stream(root: string, options?: Options): NodeJS.ReadableStream;
+    function readdirStreamStat(root: string, options?: Options): NodeJS.ReadableStream;
+
+    namespace stream {
+        function stat(root: string, options?: Options): NodeJS.ReadableStream;
+    }
+
+    function sync(root: string, options?: Options): string[];
+    function readdirSyncStat(root: string, options?: Options): Entry[];
+
+    namespace sync {
+        function stat(root: string, options?: Options): Entry[];
+    }
+}
+
+declare function re(root: string, options?: re.Options): Promise<string[]>;
+declare function re(root: string, callback: re.CallbackString): void;
+declare function re(root: string, options: re.Options, callback: re.CallbackString): void;
+
+export = re;

node_modules/@nodelib/fs.stat/README.md

@@ -0,0 +1,92 @@
+# @nodelib/fs.stat
+
+> Get the status of a file with some features.
+
+## :bulb: Highlights
+
+Wrapper over standard methods ([`fs.lstat`](https://nodejs.org/dist/latest/docs/api/fs.html#fs_fs_lstat_path_callback), [`fs.stat`](https://nodejs.org/dist/latest/docs/api/fs.html#fs_fs_stat_path_callback)) with some features.
+
+  * :beginner: Normally follows symlinks.
+  * :gear: Can safely work with broken symlinks (returns information about symlink instead of generating an error).
+
+## Install
+
+```
+$ npm install @nodelib/fs.stat
+```
+
+## Usage
+
+```js
+const fsStat = require('@nodelib/fs.stat');
+
+fsStat.stat('path').then((stat) => {
+    console.log(stat); // => fs.Stats
+});
+```
+
+## API
+
+### fsStat.stat(path, [options])
+
+Returns a [`Promise<fs.Stats>`](https://nodejs.org/dist/latest/docs/api/fs.html#fs_class_fs_stats) for provided path.
+
+### fsStat.statSync(path, [options])
+
+Returns a [`fs.Stats`](https://nodejs.org/dist/latest/docs/api/fs.html#fs_class_fs_stats) for provided path.
+
+### fsStat.statCallback(path, [options], callback)
+
+Returns a [`fs.Stats`](https://nodejs.org/dist/latest/docs/api/fs.html#fs_class_fs_stats) for provided path with standard callback-style.
+
+#### path
+
+  * Type: `string | Buffer | URL`
+
+The `path` argument for [`fs.lstat`](https://nodejs.org/dist/latest/docs/api/fs.html#fs_fs_lstat_path_callback) or [`fs.stat`](https://nodejs.org/dist/latest/docs/api/fs.html#fs_fs_stat_path_callback) method.
+
+#### options
+
+  * Type: `Object`
+
+See [options](#options-1) section for more detailed information.
+
+## Options
+
+### throwErrorOnBrokenSymlinks
+
+  * Type: `boolean`
+  * Default: `true`
+
+Throw an error or return information about symlink, when symlink is broken. When `false`, methods will be return lstat call for broken symlinks.
+
+### followSymlinks
+
+  * Type: `boolean`
+  * Default: `true`
+
+By default, the methods of this package follows symlinks. If you do not want it, set this option to `false` or use the standard method [`fs.lstat`](https://nodejs.org/dist/latest/docs/api/fs.html#fs_fs_lstat_path_callback).
+
+### fs
+
+  * Type: `FileSystemAdapter`
+  * Default: `built-in FS methods`
+
+By default, the built-in Node.js module (`fs`) is used to work with the file system. You can replace each method with your own.
+
+```ts
+interface FileSystemAdapter {
+	lstat?: typeof fs.lstat;
+	stat?: typeof fs.stat;
+	lstatSync?: typeof fs.lstatSync;
+	statSync?: typeof fs.statSync;
+}
+```
+
+## Changelog
+
+See the [Releases section of our GitHub project](https://github.com/nodelib/nodelib/releases) for changelogs for each release version.
+
+## License
+
+This software is released under the terms of the MIT license.

node_modules/@nodelib/fs.stat/out/adapters/fs.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import * as fs from 'fs';
+export interface FileSystemAdapter {
+    lstat: typeof fs.lstat;
+    stat: typeof fs.stat;
+    lstatSync: typeof fs.lstatSync;
+    statSync: typeof fs.statSync;
+}
+export declare const FILE_SYSTEM_ADAPTER: FileSystemAdapter;
+export declare function getFileSystemAdapter(fsMethods?: Partial<FileSystemAdapter>): FileSystemAdapter;

node_modules/@nodelib/fs.stat/out/adapters/fs.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("fs");
+exports.FILE_SYSTEM_ADAPTER = {
+    lstat: fs.lstat,
+    stat: fs.stat,
+    lstatSync: fs.lstatSync,
+    statSync: fs.statSync
+};
+function getFileSystemAdapter(fsMethods) {
+    if (!fsMethods) {
+        return exports.FILE_SYSTEM_ADAPTER;
+    }
+    return Object.assign({}, exports.FILE_SYSTEM_ADAPTER, fsMethods);
+}
+exports.getFileSystemAdapter = getFileSystemAdapter;

node_modules/@nodelib/fs.stat/out/index.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="node" />
+import * as fs from 'fs';
+import { FileSystemAdapter } from './adapters/fs';
+import { Options } from './managers/options';
+import { AsyncCallback } from './providers/stat';
+/**
+ * Asynchronous API.
+ */
+export declare function stat(path: fs.PathLike, opts?: Options): Promise<fs.Stats>;
+/**
+ * Callback API.
+ */
+export declare function statCallback(path: fs.PathLike, callback: AsyncCallback): void;
+export declare function statCallback(path: fs.PathLike, opts: Options, callback: AsyncCallback): void;
+/**
+ * Synchronous API.
+ */
+export declare function statSync(path: fs.PathLike, opts?: Options): fs.Stats;
+export declare type Options = Options;
+export declare type StatAsyncCallback = AsyncCallback;
+export declare type FileSystemAdapter = FileSystemAdapter;

node_modules/@nodelib/fs.stat/out/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const optionsManager = require("./managers/options");
+const statProvider = require("./providers/stat");
+/**
+ * Asynchronous API.
+ */
+function stat(path, opts) {
+    return new Promise((resolve, reject) => {
+        statProvider.async(path, optionsManager.prepare(opts), (err, stats) => err ? reject(err) : resolve(stats));
+    });
+}
+exports.stat = stat;
+function statCallback(path, optsOrCallback, callback) {
+    if (typeof optsOrCallback === 'function') {
+        callback = optsOrCallback; /* tslint:disable-line: no-parameter-reassignment */
+        optsOrCallback = undefined; /* tslint:disable-line: no-parameter-reassignment */
+    }
+    if (typeof callback === 'undefined') {
+        throw new TypeError('The "callback" argument must be of type Function.');
+    }
+    statProvider.async(path, optionsManager.prepare(optsOrCallback), callback);
+}
+exports.statCallback = statCallback;
+/**
+ * Synchronous API.
+ */
+function statSync(path, opts) {
+    return statProvider.sync(path, optionsManager.prepare(opts));
+}
+exports.statSync = statSync;

node_modules/@nodelib/fs.stat/out/managers/options.d.ts

@@ -0,0 +1,10 @@
+import { FileSystemAdapter } from '../adapters/fs';
+export interface Options {
+    fs?: Partial<FileSystemAdapter>;
+    throwErrorOnBrokenSymlinks?: boolean;
+    followSymlinks?: boolean;
+}
+export declare type StrictOptions = {
+    fs: FileSystemAdapter;
+} & Required<Options>;
+export declare function prepare(opts?: Options): StrictOptions;

node_modules/@nodelib/fs.stat/out/managers/options.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fsAdapter = require("../adapters/fs");
+function prepare(opts) {
+    const options = Object.assign({
+        fs: fsAdapter.getFileSystemAdapter(opts ? opts.fs : undefined),
+        throwErrorOnBrokenSymlinks: true,
+        followSymlinks: true
+    }, opts);
+    return options;
+}
+exports.prepare = prepare;

node_modules/@nodelib/fs.stat/out/providers/stat.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import * as fs from 'fs';
+import { StrictOptions } from '../managers/options';
+export declare function sync(path: fs.PathLike, options: StrictOptions): fs.Stats;
+export declare type AsyncCallback = (err: NodeJS.ErrnoException | null, stats?: fs.Stats) => void;
+export declare function async(path: fs.PathLike, options: StrictOptions, callback: AsyncCallback): void;
+/**
+ * Returns `true` for followed symlink.
+ */
+export declare function isFollowedSymlink(stat: fs.Stats, options: StrictOptions): boolean;

node_modules/@nodelib/fs.stat/out/providers/stat.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function sync(path, options) {
+    const lstat = options.fs.lstatSync(path);
+    if (!isFollowedSymlink(lstat, options)) {
+        return lstat;
+    }
+    try {
+        const stat = options.fs.statSync(path);
+        stat.isSymbolicLink = () => true;
+        return stat;
+    }
+    catch (err) {
+        if (!options.throwErrorOnBrokenSymlinks) {
+            return lstat;
+        }
+        throw err;
+    }
+}
+exports.sync = sync;
+function async(path, options, callback) {
+    options.fs.lstat(path, (err0, lstat) => {
+        if (err0) {
+            return callback(err0, undefined);
+        }
+        if (!isFollowedSymlink(lstat, options)) {
+            return callback(null, lstat);
+        }
+        options.fs.stat(path, (err1, stat) => {
+            if (err1) {
+                return options.throwErrorOnBrokenSymlinks ? callback(err1) : callback(null, lstat);
+            }
+            stat.isSymbolicLink = () => true;
+            callback(null, stat);
+        });
+    });
+}
+exports.async = async;
+/**
+ * Returns `true` for followed symlink.
+ */
+function isFollowedSymlink(stat, options) {
+    return stat.isSymbolicLink() && options.followSymlinks;
+}
+exports.isFollowedSymlink = isFollowedSymlink;

node_modules/@samverschueren/stream-to-observable/index.js

@@ -0,0 +1,92 @@
+'use strict';
+const Observable = require('any-observable');
+
+function or(option, alternate, required) {
+	const result = option === false ? false : option || alternate;
+
+	if ((required && !result) || (result && typeof result !== 'string')) {
+		throw new TypeError(alternate + 'Event must be a string.');
+	}
+
+	return result;
+}
+
+module.exports = (stream, opts) => {
+	opts = opts || {};
+
+	let complete = false;
+	let dataListeners = [];
+	const awaited = opts.await;
+	const dataEvent = or(opts.dataEvent, 'data', true);
+	const errorEvent = or(opts.errorEvent, 'error');
+	const endEvent = or(opts.endEvent, 'end');
+
+	function cleanup() {
+		complete = true;
+		dataListeners.forEach(listener => {
+			stream.removeListener(dataEvent, listener);
+		});
+		dataListeners = null;
+	}
+
+	const completion = new Promise((resolve, reject) => {
+		function onEnd(result) {
+			if (awaited) {
+				awaited.then(resolve);
+			} else {
+				resolve(result);
+			}
+		}
+
+		if (endEvent) {
+			stream.once(endEvent, onEnd);
+		} else if (awaited) {
+			onEnd();
+		}
+
+		if (errorEvent) {
+			stream.once(errorEvent, reject);
+		}
+
+		if (awaited) {
+			awaited.catch(reject);
+		}
+	}).catch(err => {
+		cleanup();
+		throw err;
+	}).then(result => {
+		cleanup();
+		return result;
+	});
+
+	return new Observable(observer => {
+		completion
+			.then(observer.complete.bind(observer))
+			.catch(observer.error.bind(observer));
+
+		if (complete) {
+			return null;
+		}
+
+		const onData = data => {
+			observer.next(data);
+		};
+
+		stream.on(dataEvent, onData);
+		dataListeners.push(onData);
+
+		return () => {
+			stream.removeListener(dataEvent, onData);
+
+			if (complete) {
+				return;
+			}
+
+			const idx = dataListeners.indexOf(onData);
+
+			if (idx !== -1) {
+				dataListeners.splice(idx, 1);
+			}
+		};
+	});
+};

node_modules/@samverschueren/stream-to-observable/license

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) James Talmage <james@talmage.io> (github.com/jamestalmage), Sam Verschueren <sam.verschueren@gmail.com> (github.com/SamVerschueren)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

node_modules/@sindresorhus/is/dist/example.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=example.js.map

node_modules/@sindresorhus/is/dist/example.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"example.js","sourceRoot":"","sources":["../example.ts"],"names":[],"mappings":""}

node_modules/@sindresorhus/is/dist/index.d.ts

@@ -0,0 +1,95 @@
+/// <reference types="node" />
+export declare const enum TypeName {
+    null = "null",
+    boolean = "boolean",
+    undefined = "undefined",
+    string = "string",
+    number = "number",
+    symbol = "symbol",
+    Function = "Function",
+    Array = "Array",
+    Buffer = "Buffer",
+    Object = "Object",
+    RegExp = "RegExp",
+    Date = "Date",
+    Error = "Error",
+    Map = "Map",
+    Set = "Set",
+    WeakMap = "WeakMap",
+    WeakSet = "WeakSet",
+    Int8Array = "Int8Array",
+    Uint8Array = "Uint8Array",
+    Uint8ClampedArray = "Uint8ClampedArray",
+    Int16Array = "Int16Array",
+    Uint16Array = "Uint16Array",
+    Int32Array = "Int32Array",
+    Uint32Array = "Uint32Array",
+    Float32Array = "Float32Array",
+    Float64Array = "Float64Array",
+    ArrayBuffer = "ArrayBuffer",
+    SharedArrayBuffer = "SharedArrayBuffer",
+    DataView = "DataView",
+    Promise = "Promise",
+}
+declare function is(value: any): TypeName;
+declare namespace is {
+    const undefined: (value: any) => boolean;
+    const string: (value: any) => boolean;
+    const number: (value: any) => boolean;
+    const function_: (value: any) => boolean;
+    const null_: (value: any) => boolean;
+    const class_: (value: any) => any;
+    const boolean: (value: any) => boolean;
+    const symbol: (value: any) => boolean;
+    const array: (arg: any) => arg is any[];
+    const buffer: (obj: any) => obj is Buffer;
+    const nullOrUndefined: (value: any) => boolean;
+    const object: (value: any) => boolean;
+    const iterable: (value: any) => boolean;
+    const generator: (value: any) => boolean;
+    const nativePromise: (value: any) => boolean;
+    const promise: (value: any) => boolean;
+    const generatorFunction: (value: any) => boolean;
+    const asyncFunction: (value: any) => boolean;
+    const boundFunction: (value: any) => boolean;
+    const regExp: (value: any) => boolean;
+    const date: (value: any) => boolean;
+    const error: (value: any) => boolean;
+    const map: (value: any) => boolean;
+    const set: (value: any) => boolean;
+    const weakMap: (value: any) => boolean;
+    const weakSet: (value: any) => boolean;
+    const int8Array: (value: any) => boolean;
+    const uint8Array: (value: any) => boolean;
+    const uint8ClampedArray: (value: any) => boolean;
+    const int16Array: (value: any) => boolean;
+    const uint16Array: (value: any) => boolean;
+    const int32Array: (value: any) => boolean;
+    const uint32Array: (value: any) => boolean;
+    const float32Array: (value: any) => boolean;
+    const float64Array: (value: any) => boolean;
+    const arrayBuffer: (value: any) => boolean;
+    const sharedArrayBuffer: (value: any) => boolean;
+    const dataView: (value: any) => boolean;
+    const directInstanceOf: (instance: any, klass: any) => boolean;
+    const truthy: (value: any) => boolean;
+    const falsy: (value: any) => boolean;
+    const nan: (value: any) => boolean;
+    const primitive: (value: any) => boolean;
+    const integer: (value: any) => boolean;
+    const safeInteger: (value: any) => boolean;
+    const plainObject: (value: any) => boolean;
+    const typedArray: (value: any) => boolean;
+    const arrayLike: (value: any) => boolean;
+    const inRange: (value: number, range: number | number[]) => boolean;
+    const domElement: (value: any) => boolean;
+    const nodeStream: (value: any) => boolean;
+    const infinite: (value: any) => boolean;
+    const even: (rem: number) => boolean;
+    const odd: (rem: number) => boolean;
+    const empty: (value: any) => boolean;
+    const emptyOrWhitespace: (value: any) => boolean;
+    function any(...predicate: any[]): any;
+    function all(...predicate: any[]): any;
+}
+export default is;

node_modules/@sindresorhus/is/dist/index.js

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util = require("util");
+const toString = Object.prototype.toString;
+const isOfType = (type) => (value) => typeof value === type; // tslint:disable-line:strict-type-predicates
+const getObjectType = (value) => {
+    const objectName = toString.call(value).slice(8, -1);
+    if (objectName) {
+        return objectName;
+    }
+    return null;
+};
+const isObjectOfType = (typeName) => (value) => {
+    return getObjectType(value) === typeName;
+};
+function is(value) {
+    if (value === null) {
+        return "null" /* null */;
+    }
+    if (value === true || value === false) {
+        return "boolean" /* boolean */;
+    }
+    const type = typeof value;
+    if (type === 'undefined') {
+        return "undefined" /* undefined */;
+    }
+    if (type === 'string') {
+        return "string" /* string */;
+    }
+    if (type === 'number') {
+        return "number" /* number */;
+    }
+    if (type === 'symbol') {
+        return "symbol" /* symbol */;
+    }
+    if (is.function_(value)) {
+        return "Function" /* Function */;
+    }
+    if (Array.isArray(value)) {
+        return "Array" /* Array */;
+    }
+    if (Buffer.isBuffer(value)) {
+        return "Buffer" /* Buffer */;
+    }
+    const tagType = getObjectType(value);
+    if (tagType) {
+        return tagType;
+    }
+    if (value instanceof String || value instanceof Boolean || value instanceof Number) {
+        throw new TypeError('Please don\'t use object wrappers for primitive types');
+    }
+    return "Object" /* Object */;
+}
+(function (is) {
+    const isObject = (value) => typeof value === 'object';
+    // tslint:disable:variable-name
+    is.undefined = isOfType('undefined');
+    is.string = isOfType('string');
+    is.number = isOfType('number');
+    is.function_ = isOfType('function');
+    is.null_ = (value) => value === null;
+    is.class_ = (value) => is.function_(value) && value.toString().startsWith('class ');
+    is.boolean = (value) => value === true || value === false;
+    // tslint:enable:variable-name
+    is.symbol = isOfType('symbol');
+    is.array = Array.isArray;
+    is.buffer = Buffer.isBuffer;
+    is.nullOrUndefined = (value) => is.null_(value) || is.undefined(value);
+    is.object = (value) => !is.nullOrUndefined(value) && (is.function_(value) || isObject(value));
+    is.iterable = (value) => !is.nullOrUndefined(value) && is.function_(value[Symbol.iterator]);
+    is.generator = (value) => is.iterable(value) && is.function_(value.next) && is.function_(value.throw);
+    is.nativePromise = isObjectOfType("Promise" /* Promise */);
+    const hasPromiseAPI = (value) => !is.null_(value) &&
+        isObject(value) &&
+        is.function_(value.then) &&
+        is.function_(value.catch);
+    is.promise = (value) => is.nativePromise(value) || hasPromiseAPI(value);
+    // TODO: Change to use `isObjectOfType` once Node.js 6 or higher is targeted
+    const isFunctionOfType = (type) => (value) => is.function_(value) && is.function_(value.constructor) && value.constructor.name === type;
+    is.generatorFunction = isFunctionOfType('GeneratorFunction');
+    is.asyncFunction = isFunctionOfType('AsyncFunction');
+    is.boundFunction = (value) => is.function_(value) && !value.hasOwnProperty('prototype');
+    is.regExp = isObjectOfType("RegExp" /* RegExp */);
+    is.date = isObjectOfType("Date" /* Date */);
+    is.error = isObjectOfType("Error" /* Error */);
+    is.map = isObjectOfType("Map" /* Map */);
+    is.set = isObjectOfType("Set" /* Set */);
+    is.weakMap = isObjectOfType("WeakMap" /* WeakMap */);
+    is.weakSet = isObjectOfType("WeakSet" /* WeakSet */);
+    is.int8Array = isObjectOfType("Int8Array" /* Int8Array */);
+    is.uint8Array = isObjectOfType("Uint8Array" /* Uint8Array */);
+    is.uint8ClampedArray = isObjectOfType("Uint8ClampedArray" /* Uint8ClampedArray */);
+    is.int16Array = isObjectOfType("Int16Array" /* Int16Array */);
+    is.uint16Array = isObjectOfType("Uint16Array" /* Uint16Array */);
+    is.int32Array = isObjectOfType("Int32Array" /* Int32Array */);
+    is.uint32Array = isObjectOfType("Uint32Array" /* Uint32Array */);
+    is.float32Array = isObjectOfType("Float32Array" /* Float32Array */);
+    is.float64Array = isObjectOfType("Float64Array" /* Float64Array */);
+    is.arrayBuffer = isObjectOfType("ArrayBuffer" /* ArrayBuffer */);
+    is.sharedArrayBuffer = isObjectOfType("SharedArrayBuffer" /* SharedArrayBuffer */);
+    is.dataView = isObjectOfType("DataView" /* DataView */);
+    // TODO: Remove `object` checks when targeting ES2015 or higher
+    // See `Notes`: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getPrototypeOf
+    is.directInstanceOf = (instance, klass) => is.object(instance) && is.object(klass) && Object.getPrototypeOf(instance) === klass.prototype;
+    is.truthy = (value) => Boolean(value);
+    is.falsy = (value) => !value;
+    is.nan = (value) => Number.isNaN(value);
+    const primitiveTypes = new Set([
+        'undefined',
+        'string',
+        'number',
+        'boolean',
+        'symbol'
+    ]);
+    is.primitive = (value) => is.null_(value) || primitiveTypes.has(typeof value);
+    is.integer = (value) => Number.isInteger(value);
+    is.safeInteger = (value) => Number.isSafeInteger(value);
+    is.plainObject = (value) => {
+        // From: https://github.com/sindresorhus/is-plain-obj/blob/master/index.js
+        let prototype;
+        return getObjectType(value) === "Object" /* Object */ &&
+            (prototype = Object.getPrototypeOf(value), prototype === null || // tslint:disable-line:ban-comma-operator
+                prototype === Object.getPrototypeOf({}));
+    };
+    const typedArrayTypes = new Set([
+        "Int8Array" /* Int8Array */,
+        "Uint8Array" /* Uint8Array */,
+        "Uint8ClampedArray" /* Uint8ClampedArray */,
+        "Int16Array" /* Int16Array */,
+        "Uint16Array" /* Uint16Array */,
+        "Int32Array" /* Int32Array */,
+        "Uint32Array" /* Uint32Array */,
+        "Float32Array" /* Float32Array */,
+        "Float64Array" /* Float64Array */
+    ]);
+    is.typedArray = (value) => {
+        const objectType = getObjectType(value);
+        if (objectType === null) {
+            return false;
+        }
+        return typedArrayTypes.has(objectType);
+    };
+    const isValidLength = (value) => is.safeInteger(value) && value > -1;
+    is.arrayLike = (value) => !is.nullOrUndefined(value) && !is.function_(value) && isValidLength(value.length);
+    is.inRange = (value, range) => {
+        if (is.number(range)) {
+            return value >= Math.min(0, range) && value <= Math.max(range, 0);
+        }
+        if (is.array(range) && range.length === 2) {
+            // TODO: Use spread operator here when targeting Node.js 6 or higher
+            return value >= Math.min.apply(null, range) && value <= Math.max.apply(null, range);
+        }
+        throw new TypeError(`Invalid range: ${util.inspect(range)}`);
+    };
+    const NODE_TYPE_ELEMENT = 1;
+    const DOM_PROPERTIES_TO_CHECK = [
+        'innerHTML',
+        'ownerDocument',
+        'style',
+        'attributes',
+        'nodeValue'
+    ];
+    is.domElement = (value) => is.object(value) && value.nodeType === NODE_TYPE_ELEMENT && is.string(value.nodeName) &&
+        !is.plainObject(value) && DOM_PROPERTIES_TO_CHECK.every(property => property in value);
+    is.nodeStream = (value) => !is.nullOrUndefined(value) && isObject(value) && is.function_(value.pipe);
+    is.infinite = (value) => value === Infinity || value === -Infinity;
+    const isAbsoluteMod2 = (value) => (rem) => is.integer(rem) && Math.abs(rem % 2) === value;
+    is.even = isAbsoluteMod2(0);
+    is.odd = isAbsoluteMod2(1);
+    const isWhiteSpaceString = (value) => is.string(value) && /\S/.test(value) === false;
+    const isEmptyStringOrArray = (value) => (is.string(value) || is.array(value)) && value.length === 0;
+    const isEmptyObject = (value) => !is.map(value) && !is.set(value) && is.object(value) && Object.keys(value).length === 0;
+    const isEmptyMapOrSet = (value) => (is.map(value) || is.set(value)) && value.size === 0;
+    is.empty = (value) => is.falsy(value) || isEmptyStringOrArray(value) || isEmptyObject(value) || isEmptyMapOrSet(value);
+    is.emptyOrWhitespace = (value) => is.empty(value) || isWhiteSpaceString(value);
+    const predicateOnArray = (method, predicate, args) => {
+        // `args` is the calling function's "arguments object".
+        // We have to do it this way to keep node v4 support.
+        // So here we convert it to an array and slice off the first item.
+        const values = Array.prototype.slice.call(args, 1);
+        if (is.function_(predicate) === false) {
+            throw new TypeError(`Invalid predicate: ${util.inspect(predicate)}`);
+        }
+        if (values.length === 0) {
+            throw new TypeError('Invalid number of values');
+        }
+        return method.call(values, predicate);
+    };
+    function any(predicate) {
+        return predicateOnArray(Array.prototype.some, predicate, arguments);
+    }
+    is.any = any;
+    function all(predicate) {
+        return predicateOnArray(Array.prototype.every, predicate, arguments);
+    }
+    is.all = all;
+    // tslint:enable:only-arrow-functions no-function-expression
+})(is || (is = {}));
+// Some few keywords are reserved, but we'll populate them for Node.js users
+// See https://github.com/Microsoft/TypeScript/issues/2536
+Object.defineProperties(is, {
+    class: {
+        value: is.class_
+    },
+    function: {
+        value: is.function_
+    },
+    null: {
+        value: is.null_
+    }
+});
+exports.default = is;
+// For CommonJS default export support
+module.exports = is;
+module.exports.default = is;

node_modules/@sindresorhus/is/dist/source/index.d.ts

@@ -0,0 +1,59 @@
+/// <reference types="node" />
+declare function is(value: any): string;
+declare namespace is {
+    const undefined: (value: any) => boolean;
+    const string: (value: any) => boolean;
+    const number: (value: any) => boolean;
+    const function_: (value: any) => boolean;
+    const null_: (value: any) => boolean;
+    const class_: (value: any) => any;
+    const boolean: (value: any) => boolean;
+    const symbol: (value: any) => boolean;
+    const array: (arg: any) => arg is any[];
+    const buffer: (obj: any) => obj is Buffer;
+    const nullOrUndefined: (value: any) => boolean;
+    const object: (value: any) => boolean;
+    const iterable: (value: any) => boolean;
+    const generator: (value: any) => boolean;
+    const nativePromise: (value: any) => boolean;
+    const promise: (value: any) => boolean;
+    const generatorFunction: (value: any) => boolean;
+    const asyncFunction: (value: any) => boolean;
+    const regExp: (value: any) => boolean;
+    const date: (value: any) => boolean;
+    const error: (value: any) => boolean;
+    const map: (value: any) => boolean;
+    const set: (value: any) => boolean;
+    const weakMap: (value: any) => boolean;
+    const weakSet: (value: any) => boolean;
+    const int8Array: (value: any) => boolean;
+    const uint8Array: (value: any) => boolean;
+    const uint8ClampedArray: (value: any) => boolean;
+    const int16Array: (value: any) => boolean;
+    const uint16Array: (value: any) => boolean;
+    const int32Array: (value: any) => boolean;
+    const uint32Array: (value: any) => boolean;
+    const float32Array: (value: any) => boolean;
+    const float64Array: (value: any) => boolean;
+    const arrayBuffer: (value: any) => boolean;
+    const sharedArrayBuffer: (value: any) => boolean;
+    const truthy: (value: any) => boolean;
+    const falsy: (value: any) => boolean;
+    const nan: (value: any) => boolean;
+    const primitive: (value: any) => boolean;
+    const integer: (value: any) => boolean;
+    const safeInteger: (value: any) => boolean;
+    const plainObject: (value: any) => boolean;
+    const typedArray: (value: any) => boolean;
+    const arrayLike: (value: any) => boolean;
+    const inRange: (value: number, range: number | number[]) => boolean;
+    const domElement: (value: any) => boolean;
+    const infinite: (value: any) => boolean;
+    const even: (rem: number) => boolean;
+    const odd: (rem: number) => boolean;
+    const empty: (value: any) => boolean;
+    const emptyOrWhitespace: (value: any) => boolean;
+    function any(...predicate: any[]): any;
+    function all(...predicate: any[]): any;
+}
+export default is;

node_modules/@sindresorhus/is/dist/source/index.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util = require("util");
+const toString = Object.prototype.toString;
+const getObjectType = (value) => toString.call(value).slice(8, -1);
+const isOfType = (type) => (value) => typeof value === type;
+const isObjectOfType = (type) => (value) => getObjectType(value) === type;
+function is(value) {
+    if (value === null) {
+        return 'null';
+    }
+    if (value === true || value === false) {
+        return 'boolean';
+    }
+    const type = typeof value;
+    if (type === 'undefined') {
+        return 'undefined';
+    }
+    if (type === 'string') {
+        return 'string';
+    }
+    if (type === 'number') {
+        return 'number';
+    }
+    if (type === 'symbol') {
+        return 'symbol';
+    }
+    if (is.function_(value)) {
+        return 'Function';
+    }
+    if (Array.isArray(value)) {
+        return 'Array';
+    }
+    if (Buffer.isBuffer(value)) {
+        return 'Buffer';
+    }
+    const tagType = getObjectType(value);
+    if (tagType) {
+        return tagType;
+    }
+    if (value instanceof String || value instanceof Boolean || value instanceof Number) {
+        throw new TypeError('Please don\'t use object wrappers for primitive types');
+    }
+    return 'Object';
+}
+(function (is) {
+    const isObject = (value) => typeof value === 'object';
+    is.undefined = isOfType('undefined');
+    is.string = isOfType('string');
+    is.number = isOfType('number');
+    is.function_ = isOfType('function');
+    is.null_ = (value) => value === null;
+    is.class_ = (value) => is.function_(value) && value.toString().startsWith('class ');
+    is.boolean = (value) => value === true || value === false;
+    is.symbol = isOfType('symbol');
+    is.array = Array.isArray;
+    is.buffer = Buffer.isBuffer;
+    is.nullOrUndefined = (value) => is.null_(value) || is.undefined(value);
+    is.object = (value) => !is.nullOrUndefined(value) && (is.function_(value) || isObject(value));
+    is.iterable = (value) => !is.nullOrUndefined(value) && is.function_(value[Symbol.iterator]);
+    is.generator = (value) => is.iterable(value) && is.function_(value.next) && is.function_(value.throw);
+    is.nativePromise = isObjectOfType('Promise');
+    const hasPromiseAPI = (value) => !is.null_(value) &&
+        isObject(value) &&
+        is.function_(value.then) &&
+        is.function_(value.catch);
+    is.promise = (value) => is.nativePromise(value) || hasPromiseAPI(value);
+    const isFunctionOfType = (type) => (value) => is.function_(value) && is.function_(value.constructor) && value.constructor.name === type;
+    is.generatorFunction = isFunctionOfType('GeneratorFunction');
+    is.asyncFunction = isFunctionOfType('AsyncFunction');
+    is.regExp = isObjectOfType('RegExp');
+    is.date = isObjectOfType('Date');
+    is.error = isObjectOfType('Error');
+    is.map = isObjectOfType('Map');
+    is.set = isObjectOfType('Set');
+    is.weakMap = isObjectOfType('WeakMap');
+    is.weakSet = isObjectOfType('WeakSet');
+    is.int8Array = isObjectOfType('Int8Array');
+    is.uint8Array = isObjectOfType('Uint8Array');
+    is.uint8ClampedArray = isObjectOfType('Uint8ClampedArray');
+    is.int16Array = isObjectOfType('Int16Array');
+    is.uint16Array = isObjectOfType('Uint16Array');
+    is.int32Array = isObjectOfType('Int32Array');
+    is.uint32Array = isObjectOfType('Uint32Array');
+    is.float32Array = isObjectOfType('Float32Array');
+    is.float64Array = isObjectOfType('Float64Array');
+    is.arrayBuffer = isObjectOfType('ArrayBuffer');
+    is.sharedArrayBuffer = isObjectOfType('SharedArrayBuffer');
+    is.truthy = (value) => Boolean(value);
+    is.falsy = (value) => !value;
+    is.nan = (value) => Number.isNaN(value);
+    const primitiveTypes = new Set([
+        'undefined',
+        'string',
+        'number',
+        'boolean',
+        'symbol'
+    ]);
+    is.primitive = (value) => is.null_(value) || primitiveTypes.has(typeof value);
+    is.integer = (value) => Number.isInteger(value);
+    is.safeInteger = (value) => Number.isSafeInteger(value);
+    is.plainObject = (value) => {
+        let prototype;
+        return getObjectType(value) === 'Object' &&
+            (prototype = Object.getPrototypeOf(value), prototype === null ||
+                prototype === Object.getPrototypeOf({}));
+    };
+    const typedArrayTypes = new Set([
+        'Int8Array',
+        'Uint8Array',
+        'Uint8ClampedArray',
+        'Int16Array',
+        'Uint16Array',
+        'Int32Array',
+        'Uint32Array',
+        'Float32Array',
+        'Float64Array'
+    ]);
+    is.typedArray = (value) => typedArrayTypes.has(getObjectType(value));
+    const isValidLength = (value) => is.safeInteger(value) && value > -1;
+    is.arrayLike = (value) => !is.nullOrUndefined(value) && !is.function_(value) && isValidLength(value.length);
+    is.inRange = (value, range) => {
+        if (is.number(range)) {
+            return value >= Math.min(0, range) && value <= Math.max(range, 0);
+        }
+        if (is.array(range) && range.length === 2) {
+            return value >= Math.min.apply(null, range) && value <= Math.max.apply(null, range);
+        }
+        throw new TypeError(`Invalid range: ${util.inspect(range)}`);
+    };
+    const NODE_TYPE_ELEMENT = 1;
+    const DOM_PROPERTIES_TO_CHECK = [
+        'innerHTML',
+        'ownerDocument',
+        'style',
+        'attributes',
+        'nodeValue'
+    ];
+    is.domElement = (value) => is.object(value) && value.nodeType === NODE_TYPE_ELEMENT && is.string(value.nodeName) &&
+        !is.plainObject(value) && DOM_PROPERTIES_TO_CHECK.every(property => property in value);
+    is.infinite = (value) => value === Infinity || value === -Infinity;
+    const isAbsoluteMod2 = (value) => (rem) => is.integer(rem) && Math.abs(rem % 2) === value;
+    is.even = isAbsoluteMod2(0);
+    is.odd = isAbsoluteMod2(1);
+    const isWhiteSpaceString = (value) => is.string(value) && /\S/.test(value) === false;
+    const isEmptyStringOrArray = (value) => (is.string(value) || is.array(value)) && value.length === 0;
+    const isEmptyObject = (value) => !is.map(value) && !is.set(value) && is.object(value) && Object.keys(value).length === 0;
+    const isEmptyMapOrSet = (value) => (is.map(value) || is.set(value)) && value.size === 0;
+    is.empty = (value) => is.falsy(value) || isEmptyStringOrArray(value) || isEmptyObject(value) || isEmptyMapOrSet(value);
+    is.emptyOrWhitespace = (value) => is.empty(value) || isWhiteSpaceString(value);
+    const predicateOnArray = (method, predicate, args) => {
+        const values = Array.prototype.slice.call(args, 1);
+        if (is.function_(predicate) === false) {
+            throw new TypeError(`Invalid predicate: ${util.inspect(predicate)}`);
+        }
+        if (values.length === 0) {
+            throw new TypeError('Invalid number of values');
+        }
+        return method.call(values, predicate);
+    };
+    function any(predicate) {
+        return predicateOnArray(Array.prototype.some, predicate, arguments);
+    }
+    is.any = any;
+    function all(predicate) {
+        return predicateOnArray(Array.prototype.every, predicate, arguments);
+    }
+    is.all = all;
+})(is || (is = {}));
+Object.defineProperties(is, {
+    class: {
+        value: is.class_
+    },
+    function: {
+        value: is.function_
+    },
+    null: {
+        value: is.null_
+    }
+});
+exports.default = is;
+//# sourceMappingURL=index.js.map

node_modules/@sindresorhus/is/dist/source/tests/test.js

@@ -0,0 +1,622 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const util = require("util");
+const ava_1 = require("ava");
+const jsdom_1 = require("jsdom");
+const __1 = require("..");
+const isNode8orHigher = Number(process.versions.node.split('.')[0]) >= 8;
+class ErrorSubclassFixture extends Error {
+}
+const document = jsdom_1.jsdom();
+const createDomElement = (el) => document.createElement(el);
+const types = new Map([
+    ['undefined', {
+            is: __1.default.undefined,
+            fixtures: [
+                undefined
+            ]
+        }],
+    ['null', {
+            is: __1.default.null_,
+            fixtures: [
+                null
+            ]
+        }],
+    ['string', {
+            is: __1.default.string,
+            fixtures: [
+                '🦄',
+                'hello world',
+                ''
+            ]
+        }],
+    ['number', {
+            is: __1.default.number,
+            fixtures: [
+                6,
+                1.4,
+                0,
+                -0,
+                Infinity,
+                -Infinity
+            ]
+        }],
+    ['boolean', {
+            is: __1.default.boolean,
+            fixtures: [
+                true, false
+            ]
+        }],
+    ['symbol', {
+            is: __1.default.symbol,
+            fixtures: [
+                Symbol('🦄')
+            ]
+        }],
+    ['array', {
+            is: __1.default.array,
+            fixtures: [
+                [1, 2],
+                new Array(2)
+            ]
+        }],
+    ['function', {
+            is: __1.default.function_,
+            fixtures: [
+                function foo() { },
+                function () { },
+                () => { },
+                function () {
+                    return __awaiter(this, void 0, void 0, function* () { });
+                },
+                function* () { }
+            ]
+        }],
+    ['buffer', {
+            is: __1.default.buffer,
+            fixtures: [
+                Buffer.from('🦄')
+            ]
+        }],
+    ['object', {
+            is: __1.default.object,
+            fixtures: [
+                { x: 1 },
+                Object.create({ x: 1 })
+            ]
+        }],
+    ['regExp', {
+            is: __1.default.regExp,
+            fixtures: [
+                /\w/,
+                new RegExp('\\w')
+            ]
+        }],
+    ['date', {
+            is: __1.default.date,
+            fixtures: [
+                new Date()
+            ]
+        }],
+    ['error', {
+            is: __1.default.error,
+            fixtures: [
+                new Error('🦄'),
+                new ErrorSubclassFixture()
+            ]
+        }],
+    ['nativePromise', {
+            is: __1.default.nativePromise,
+            fixtures: [
+                Promise.resolve(),
+            ]
+        }],
+    ['promise', {
+            is: __1.default.promise,
+            fixtures: [
+                { then() { }, catch() { } }
+            ]
+        }],
+    ['generator', {
+            is: __1.default.generator,
+            fixtures: [
+                (function* () { yield 4; })()
+            ]
+        }],
+    ['generatorFunction', {
+            is: __1.default.generatorFunction,
+            fixtures: [
+                function* () { yield 4; }
+            ]
+        }],
+    ['asyncFunction', {
+            is: __1.default.asyncFunction,
+            fixtures: [
+                function () {
+                    return __awaiter(this, void 0, void 0, function* () { });
+                },
+                () => __awaiter(this, void 0, void 0, function* () { })
+            ]
+        }],
+    ['map', {
+            is: __1.default.map,
+            fixtures: [
+                new Map()
+            ]
+        }],
+    ['set', {
+            is: __1.default.set,
+            fixtures: [
+                new Set()
+            ]
+        }],
+    ['weakSet', {
+            is: __1.default.weakSet,
+            fixtures: [
+                new WeakSet()
+            ]
+        }],
+    ['weakMap', {
+            is: __1.default.weakMap,
+            fixtures: [
+                new WeakMap()
+            ]
+        }],
+    ['int8Array', {
+            is: __1.default.int8Array,
+            fixtures: [
+                new Int8Array(0)
+            ]
+        }],
+    ['uint8Array', {
+            is: __1.default.uint8Array,
+            fixtures: [
+                new Uint8Array(0)
+            ]
+        }],
+    ['uint8ClampedArray', {
+            is: __1.default.uint8ClampedArray,
+            fixtures: [
+                new Uint8ClampedArray(0)
+            ]
+        }],
+    ['int16Array', {
+            is: __1.default.int16Array,
+            fixtures: [
+                new Int16Array(0)
+            ]
+        }],
+    ['uint16Array', {
+            is: __1.default.uint16Array,
+            fixtures: [
+                new Uint16Array(0)
+            ]
+        }],
+    ['int32Array', {
+            is: __1.default.int32Array,
+            fixtures: [
+                new Int32Array(0)
+            ]
+        }],
+    ['uint32Array', {
+            is: __1.default.uint32Array,
+            fixtures: [
+                new Uint32Array(0)
+            ]
+        }],
+    ['float32Array', {
+            is: __1.default.float32Array,
+            fixtures: [
+                new Float32Array(0)
+            ]
+        }],
+    ['float64Array', {
+            is: __1.default.float64Array,
+            fixtures: [
+                new Float64Array(0)
+            ]
+        }],
+    ['arrayBuffer', {
+            is: __1.default.arrayBuffer,
+            fixtures: [
+                new ArrayBuffer(10)
+            ]
+        }],
+    ['nan', {
+            is: __1.default.nan,
+            fixtures: [
+                NaN,
+                Number.NaN
+            ]
+        }],
+    ['nullOrUndefined', {
+            is: __1.default.nullOrUndefined,
+            fixtures: [
+                null,
+                undefined
+            ]
+        }],
+    ['plainObject', {
+            is: __1.default.plainObject,
+            fixtures: [
+                { x: 1 },
+                Object.create(null),
+                new Object()
+            ]
+        }],
+    ['integer', {
+            is: __1.default.integer,
+            fixtures: [
+                6
+            ]
+        }],
+    ['safeInteger', {
+            is: __1.default.safeInteger,
+            fixtures: [
+                Math.pow(2, 53) - 1,
+                -Math.pow(2, 53) + 1
+            ]
+        }],
+    ['domElement', {
+            is: __1.default.domElement,
+            fixtures: [
+                'div',
+                'input',
+                'span',
+                'img',
+                'canvas',
+                'script'
+            ].map(createDomElement)
+        }
+    ], ['non-domElements', {
+            is: value => !__1.default.domElement(value),
+            fixtures: [
+                document.createTextNode('data'),
+                document.createProcessingInstruction('xml-stylesheet', 'href="mycss.css" type="text/css"'),
+                document.createComment('This is a comment'),
+                document,
+                document.implementation.createDocumentType('svg:svg', '-//W3C//DTD SVG 1.1//EN', 'http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd'),
+                document.createDocumentFragment()
+            ]
+        }],
+    ['infinite', {
+            is: __1.default.infinite,
+            fixtures: [
+                Infinity,
+                -Infinity
+            ]
+        }]
+]);
+const testType = (t, type, exclude) => {
+    const testData = types.get(type);
+    if (testData === undefined) {
+        t.fail(`is.${type} not defined`);
+        return;
+    }
+    const { is } = testData;
+    for (const [key, { fixtures }] of types) {
+        if (exclude && exclude.indexOf(key) !== -1) {
+            continue;
+        }
+        const assert = key === type ? t.true.bind(t) : t.false.bind(t);
+        for (const fixture of fixtures) {
+            assert(is(fixture), `Value: ${util.inspect(fixture)}`);
+        }
+    }
+};
+ava_1.default('is', t => {
+    t.is(__1.default(null), 'null');
+    t.is(__1.default(undefined), 'undefined');
+});
+ava_1.default('is.undefined', t => {
+    testType(t, 'undefined', ['nullOrUndefined']);
+});
+ava_1.default('is.null', t => {
+    testType(t, 'null', ['nullOrUndefined']);
+});
+ava_1.default('is.string', t => {
+    testType(t, 'string');
+});
+ava_1.default('is.number', t => {
+    testType(t, 'number', ['nan', 'integer', 'safeInteger', 'infinite']);
+});
+ava_1.default('is.boolean', t => {
+    testType(t, 'boolean');
+});
+ava_1.default('is.symbol', t => {
+    testType(t, 'symbol');
+});
+ava_1.default('is.array', t => {
+    testType(t, 'array');
+});
+ava_1.default('is.function', t => {
+    testType(t, 'function', ['generatorFunction', 'asyncFunction']);
+});
+ava_1.default('is.buffer', t => {
+    testType(t, 'buffer');
+});
+ava_1.default('is.object', t => {
+    const testData = types.get('object');
+    if (testData === undefined) {
+        t.fail('is.object not defined');
+        return;
+    }
+    for (const el of testData.fixtures) {
+        t.true(__1.default.object(el));
+    }
+});
+ava_1.default('is.regExp', t => {
+    testType(t, 'regExp');
+});
+ava_1.default('is.date', t => {
+    testType(t, 'date');
+});
+ava_1.default('is.error', t => {
+    testType(t, 'error');
+});
+if (isNode8orHigher) {
+    ava_1.default('is.nativePromise', t => {
+        testType(t, 'nativePromise');
+    });
+    ava_1.default('is.promise', t => {
+        testType(t, 'promise', ['nativePromise']);
+    });
+}
+ava_1.default('is.generator', t => {
+    testType(t, 'generator');
+});
+ava_1.default('is.generatorFunction', t => {
+    testType(t, 'generatorFunction', ['function']);
+});
+ava_1.default('is.map', t => {
+    testType(t, 'map');
+});
+ava_1.default('is.set', t => {
+    testType(t, 'set');
+});
+ava_1.default('is.weakMap', t => {
+    testType(t, 'weakMap');
+});
+ava_1.default('is.weakSet', t => {
+    testType(t, 'weakSet');
+});
+ava_1.default('is.int8Array', t => {
+    testType(t, 'int8Array');
+});
+ava_1.default('is.uint8Array', t => {
+    testType(t, 'uint8Array', ['buffer']);
+});
+ava_1.default('is.uint8ClampedArray', t => {
+    testType(t, 'uint8ClampedArray');
+});
+ava_1.default('is.int16Array', t => {
+    testType(t, 'int16Array');
+});
+ava_1.default('is.uint16Array', t => {
+    testType(t, 'uint16Array');
+});
+ava_1.default('is.int32Array', t => {
+    testType(t, 'int32Array');
+});
+ava_1.default('is.uint32Array', t => {
+    testType(t, 'uint32Array');
+});
+ava_1.default('is.float32Array', t => {
+    testType(t, 'float32Array');
+});
+ava_1.default('is.float64Array', t => {
+    testType(t, 'float64Array');
+});
+ava_1.default('is.arrayBuffer', t => {
+    testType(t, 'arrayBuffer');
+});
+ava_1.default('is.dataView', t => {
+    testType(t, 'arrayBuffer');
+});
+ava_1.default('is.truthy', t => {
+    t.true(__1.default.truthy('unicorn'));
+    t.true(__1.default.truthy('🦄'));
+    t.true(__1.default.truthy(new Set()));
+    t.true(__1.default.truthy(Symbol('🦄')));
+    t.true(__1.default.truthy(true));
+});
+ava_1.default('is.falsy', t => {
+    t.true(__1.default.falsy(false));
+    t.true(__1.default.falsy(0));
+    t.true(__1.default.falsy(''));
+    t.true(__1.default.falsy(null));
+    t.true(__1.default.falsy(undefined));
+    t.true(__1.default.falsy(NaN));
+});
+ava_1.default('is.nan', t => {
+    testType(t, 'nan');
+});
+ava_1.default('is.nullOrUndefined', t => {
+    testType(t, 'nullOrUndefined', ['undefined', 'null']);
+});
+ava_1.default('is.primitive', t => {
+    const primitives = [
+        undefined,
+        null,
+        '🦄',
+        6,
+        Infinity,
+        -Infinity,
+        true,
+        false,
+        Symbol('🦄')
+    ];
+    for (const el of primitives) {
+        t.true(__1.default.primitive(el));
+    }
+});
+ava_1.default('is.integer', t => {
+    testType(t, 'integer', ['number', 'safeInteger']);
+    t.false(__1.default.integer(1.4));
+});
+ava_1.default('is.safeInteger', t => {
+    testType(t, 'safeInteger', ['number', 'integer']);
+    t.false(__1.default.safeInteger(Math.pow(2, 53)));
+    t.false(__1.default.safeInteger(-Math.pow(2, 53)));
+});
+ava_1.default('is.plainObject', t => {
+    testType(t, 'plainObject', ['object', 'promise']);
+});
+ava_1.default('is.iterable', t => {
+    t.true(__1.default.iterable(''));
+    t.true(__1.default.iterable([]));
+    t.true(__1.default.iterable(new Map()));
+    t.false(__1.default.iterable(null));
+    t.false(__1.default.iterable(undefined));
+    t.false(__1.default.iterable(0));
+    t.false(__1.default.iterable(NaN));
+    t.false(__1.default.iterable(Infinity));
+    t.false(__1.default.iterable({}));
+});
+ava_1.default('is.class', t => {
+    class Foo {
+    }
+    const classDeclarations = [
+        Foo,
+        class Bar extends Foo {
+        }
+    ];
+    for (const x of classDeclarations) {
+        t.true(__1.default.class_(x));
+    }
+});
+ava_1.default('is.typedArray', t => {
+    const typedArrays = [
+        new Int8Array(0),
+        new Uint8Array(0),
+        new Uint8ClampedArray(0),
+        new Uint16Array(0),
+        new Int32Array(0),
+        new Uint32Array(0),
+        new Float32Array(0),
+        new Float64Array(0)
+    ];
+    for (const el of typedArrays) {
+        t.true(__1.default.typedArray(el));
+    }
+    t.false(__1.default.typedArray(new ArrayBuffer(1)));
+    t.false(__1.default.typedArray([]));
+    t.false(__1.default.typedArray({}));
+});
+ava_1.default('is.arrayLike', t => {
+    (() => {
+        t.true(__1.default.arrayLike(arguments));
+    })();
+    t.true(__1.default.arrayLike([]));
+    t.true(__1.default.arrayLike('unicorn'));
+    t.false(__1.default.arrayLike({}));
+    t.false(__1.default.arrayLike(() => { }));
+    t.false(__1.default.arrayLike(new Map()));
+});
+ava_1.default('is.inRange', t => {
+    const x = 3;
+    t.true(__1.default.inRange(x, [0, 5]));
+    t.true(__1.default.inRange(x, [5, 0]));
+    t.true(__1.default.inRange(x, [-5, 5]));
+    t.true(__1.default.inRange(x, [5, -5]));
+    t.false(__1.default.inRange(x, [4, 8]));
+    t.true(__1.default.inRange(-7, [-5, -10]));
+    t.true(__1.default.inRange(-5, [-5, -10]));
+    t.true(__1.default.inRange(-10, [-5, -10]));
+    t.true(__1.default.inRange(x, 10));
+    t.true(__1.default.inRange(0, 0));
+    t.true(__1.default.inRange(-2, -3));
+    t.false(__1.default.inRange(x, 2));
+    t.false(__1.default.inRange(-3, -2));
+    t.throws(() => {
+        __1.default.inRange(0, []);
+    });
+    t.throws(() => {
+        __1.default.inRange(0, [5]);
+    });
+    t.throws(() => {
+        __1.default.inRange(0, [1, 2, 3]);
+    });
+});
+ava_1.default('is.domElement', t => {
+    testType(t, 'domElement');
+    t.false(__1.default.domElement({ nodeType: 1, nodeName: 'div' }));
+});
+ava_1.default('is.infinite', t => {
+    testType(t, 'infinite', ['number']);
+});
+ava_1.default('is.even', t => {
+    for (const el of [-6, 2, 4]) {
+        t.true(__1.default.even(el));
+    }
+    for (const el of [-3, 1, 5]) {
+        t.false(__1.default.even(el));
+    }
+});
+ava_1.default('is.odd', t => {
+    for (const el of [-5, 7, 13]) {
+        t.true(__1.default.odd(el));
+    }
+    for (const el of [-8, 8, 10]) {
+        t.false(__1.default.odd(el));
+    }
+});
+ava_1.default('is.empty', t => {
+    t.true(__1.default.empty(null));
+    t.true(__1.default.empty(undefined));
+    t.true(__1.default.empty(false));
+    t.false(__1.default.empty(true));
+    t.true(__1.default.empty(''));
+    t.false(__1.default.empty('🦄'));
+    t.true(__1.default.empty([]));
+    t.false(__1.default.empty(['🦄']));
+    t.true(__1.default.empty({}));
+    t.false(__1.default.empty({ unicorn: '🦄' }));
+    const tempMap = new Map();
+    t.true(__1.default.empty(tempMap));
+    tempMap.set('unicorn', '🦄');
+    t.false(__1.default.empty(tempMap));
+    const tempSet = new Set();
+    t.true(__1.default.empty(tempSet));
+    tempSet.add(1);
+    t.false(__1.default.empty(tempSet));
+});
+ava_1.default('is.emptyOrWhitespace', t => {
+    t.true(__1.default.emptyOrWhitespace(''));
+    t.true(__1.default.emptyOrWhitespace('  '));
+    t.false(__1.default.emptyOrWhitespace('🦄'));
+    t.false(__1.default.emptyOrWhitespace('unicorn'));
+});
+ava_1.default('is.any', t => {
+    t.true(__1.default.any(__1.default.string, {}, true, '🦄'));
+    t.true(__1.default.any(__1.default.object, false, {}, 'unicorns'));
+    t.false(__1.default.any(__1.default.boolean, '🦄', [], 3));
+    t.false(__1.default.any(__1.default.integer, true, 'lol', {}));
+    t.throws(() => {
+        __1.default.any(null, true);
+    });
+    t.throws(() => {
+        __1.default.any(__1.default.string);
+    });
+});
+ava_1.default('is.all', t => {
+    t.true(__1.default.all(__1.default.object, {}, new Set(), new Map()));
+    t.true(__1.default.all(__1.default.boolean, true, false));
+    t.false(__1.default.all(__1.default.string, '🦄', []));
+    t.false(__1.default.all(__1.default.set, new Map(), {}));
+    t.throws(() => {
+        __1.default.all(null, true);
+    });
+    t.throws(() => {
+        __1.default.all(__1.default.string);
+    });
+});
+//# sourceMappingURL=test.js.map

node_modules/@sindresorhus/is/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/@sindresorhus/is/package.json

@@ -0,0 +1,123 @@
+{
+  "_args": [
+    [
+      "@sindresorhus/is@^0.7.0",
+      "/home/seleznev/project Angular/Quality system/node_modules/got"
+    ]
+  ],
+  "_from": "@sindresorhus/is@>=0.7.0 <0.8.0",
+  "_id": "@sindresorhus/is@0.7.0",
+  "_inCache": true,
+  "_installable": true,
+  "_location": "/@sindresorhus/is",
+  "_nodeVersion": "8.9.0",
+  "_npmOperationalInternal": {
+    "host": "s3://npm-registry-packages",
+    "tmp": "tmp/is-0.7.0.tgz_1513024821800_0.9983615970704705"
+  },
+  "_npmUser": {
+    "email": "sindresorhus@gmail.com",
+    "name": "sindresorhus"
+  },
+  "_npmVersion": "5.5.1",
+  "_phantomChildren": {},
+  "_requested": {
+    "name": "@sindresorhus/is",
+    "raw": "@sindresorhus/is@^0.7.0",
+    "rawSpec": "^0.7.0",
+    "scope": "@sindresorhus",
+    "spec": ">=0.7.0 <0.8.0",
+    "type": "range"
+  },
+  "_requiredBy": [
+    "/got"
+  ],
+  "_resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-0.7.0.tgz",
+  "_shasum": "9a06f4f137ee84d7df0460c1fdb1135ffa6c50fd",
+  "_shrinkwrap": null,
+  "_spec": "@sindresorhus/is@^0.7.0",
+  "_where": "/home/seleznev/project Angular/Quality system/node_modules/got",
+  "author": {
+    "email": "sindresorhus@gmail.com",
+    "name": "Sindre Sorhus",
+    "url": "sindresorhus.com"
+  },
+  "bugs": {
+    "url": "https://github.com/sindresorhus/is/issues"
+  },
+  "dependencies": {},
+  "description": "Type check values: `is.string('🦄') //=> true`",
+  "devDependencies": {
+    "@types/jsdom": "^2.0.31",
+    "@types/node": "^8.0.47",
+    "@types/tempy": "^0.1.0",
+    "ava": "*",
+    "del-cli": "^1.1.0",
+    "jsdom": "^9.12.0",
+    "tempy": "^0.2.1",
+    "tslint": "^5.8.0",
+    "tslint-xo": "^0.3.0",
+    "typescript": "^2.6.1"
+  },
+  "directories": {},
+  "dist": {
+    "integrity": "sha512-ONhaKPIufzzrlNbqtWFFd+jlnemX6lJAgq9ZeiZtS7I1PIf/la7CW4m83rTXRnVnsMbW2k56pGYu7AUFJD9Pow==",
+    "shasum": "9a06f4f137ee84d7df0460c1fdb1135ffa6c50fd",
+    "tarball": "https://registry.npmjs.org/@sindresorhus/is/-/is-0.7.0.tgz"
+  },
+  "engines": {
+    "node": ">=4"
+  },
+  "files": [
+    "dist"
+  ],
+  "gitHead": "828a5b3088804f32fec824a2fbff0396d4cd13b3",
+  "homepage": "https://github.com/sindresorhus/is#readme",
+  "keywords": [
+    "assert",
+    "assertion",
+    "check",
+    "checking",
+    "compare",
+    "instanceof",
+    "is",
+    "kind",
+    "object",
+    "primitive",
+    "test",
+    "type",
+    "typeof",
+    "types",
+    "util",
+    "utility",
+    "validate",
+    "validation",
+    "verify"
+  ],
+  "license": "MIT",
+  "main": "dist/index.js",
+  "maintainers": [
+    {
+      "name": "sindresorhus",
+      "email": "sindresorhus@gmail.com"
+    }
+  ],
+  "name": "@sindresorhus/is",
+  "optionalDependencies": {},
+  "publishConfig": {
+    "access": "public"
+  },
+  "readme": "ERROR: No README data found!",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sindresorhus/is.git"
+  },
+  "scripts": {
+    "build": "tsc",
+    "lint": "tslint --format stylish --project .",
+    "prepublish": "npm run build && del dist/tests",
+    "test": "npm run lint && npm run build && ava dist/tests"
+  },
+  "types": "dist/index.d.ts",
+  "version": "0.7.0"
+}

node_modules/@sindresorhus/is/readme.md

@@ -0,0 +1,323 @@
+# is [![Build Status](https://travis-ci.org/sindresorhus/is.svg?branch=master)](https://travis-ci.org/sindresorhus/is)
+
+> Type check values: `is.string('🦄') //=> true`
+
+<img src="header.gif" width="182" align="right">
+
+
+## Install
+
+```
+$ npm install @sindresorhus/is
+```
+
+
+## Usage
+
+```js
+const is = require('@sindresorhus/is');
+
+is('🦄');
+//=> 'string'
+
+is(new Map());
+//=> 'Map'
+
+is.number(6);
+//=> true
+```
+
+
+## API
+
+### is(value)
+
+Returns the type of `value`.
+
+Primitives are lowercase and object types are camelcase.
+
+Example:
+
+- `'undefined'`
+- `'null'`
+- `'string'`
+- `'symbol'`
+- `'Array'`
+- `'Function'`
+- `'Object'`
+
+Note: It will throw if you try to feed it object-wrapped primitives, as that's a bad practice. For example `new String('foo')`.
+
+### is.{method}
+
+All the below methods accept a value and returns a boolean for whether the value is of the desired type.
+
+#### Primitives
+
+##### .undefined(value)
+##### .null(value)
+##### .string(value)
+##### .number(value)
+##### .boolean(value)
+##### .symbol(value)
+
+#### Built-in types
+
+##### .array(value)
+##### .function(value)
+##### .buffer(value)
+##### .object(value)
+
+Keep in mind that [functions are objects too](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions).
+
+##### .regExp(value)
+##### .date(value)
+##### .error(value)
+##### .nativePromise(value)
+##### .promise(value)
+
+Returns `true` for any object with a `.then()` and `.catch()` method. Prefer this one over `.nativePromise()` as you usually want to allow userland promise implementations too.
+
+##### .generator(value)
+
+Returns `true` for any object that implements its own `.next()` and `.throw()` methods and has a function definition for `Symbol.iterator`.
+
+##### .generatorFunction(value)
+
+##### .asyncFunction(value)
+
+Returns `true` for any `async` function that can be called with the `await` operator.
+
+```js
+is.asyncFunction(async () => {});
+// => true
+
+is.asyncFunction(() => {});
+// => false
+```
+
+##### .boundFunction(value)
+
+Returns `true` for any `bound` function.
+
+```js
+is.boundFunction(() => {});
+// => true
+
+is.boundFunction(function () {}.bind(null));
+// => true
+
+is.boundFunction(function () {});
+// => false
+```
+
+##### .map(value)
+##### .set(value)
+##### .weakMap(value)
+##### .weakSet(value)
+
+#### Typed arrays
+
+##### .int8Array(value)
+##### .uint8Array(value)
+##### .uint8ClampedArray(value)
+##### .int16Array(value)
+##### .uint16Array(value)
+##### .int32Array(value)
+##### .uint32Array(value)
+##### .float32Array(value)
+##### .float64Array(value)
+
+#### Structured data
+
+##### .arrayBuffer(value)
+##### .sharedArrayBuffer(value)
+##### .dataView(value)
+
+#### Miscellaneous
+
+##### .directInstanceOf(value, class)
+
+Returns `true` if `value` is a direct instance of `class`.
+
+```js
+is.directInstanceOf(new Error(), Error);
+//=> true
+
+class UnicornError extends Error {};
+
+is.directInstanceOf(new UnicornError(), Error);
+//=> false
+```
+
+##### .truthy(value)
+
+Returns `true` for all values that evaluate to true in a boolean context:
+
+```js
+is.truthy('🦄');
+//=> true
+
+is.truthy(undefined);
+//=> false
+```
+
+##### .falsy(value)
+
+Returns `true` if `value` is one of: `false`, `0`, `''`, `null`, `undefined`, `NaN`.
+
+##### .nan(value)
+##### .nullOrUndefined(value)
+##### .primitive(value)
+
+JavaScript primitives are as follows: `null`, `undefined`, `string`, `number`, `boolean`, `symbol`.
+
+##### .integer(value)
+
+##### .safeInteger(value)
+
+Returns `true` if `value` is a [safe integer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger).
+
+##### .plainObject(value)
+
+An object is plain if it's created by either `{}`, `new Object()`, or `Object.create(null)`.
+
+##### .iterable(value)
+##### .class(value)
+
+Returns `true` for instances created by a ES2015 class.
+
+##### .typedArray(value)
+
+##### .arrayLike(value)
+
+A `value` is array-like if it is not a function and has a `value.length` that is a safe integer greater than or equal to 0.
+
+```js
+is.arrayLike(document.forms);
+//=> true
+
+function () {
+    is.arrayLike(arguments);
+    //=> true
+}
+```
+
+##### .inRange(value, range)
+
+Check if `value` (number) is in the given `range`. The range is an array of two values, lower bound and upper bound, in no specific order.
+
+```js
+is.inRange(3, [0, 5]);
+is.inRange(3, [5, 0]);
+is.inRange(0, [-2, 2]);
+```
+
+##### .inRange(value, upperBound)
+
+Check if `value` (number) is in the range of `0` to `upperBound`.
+
+```js
+is.inRange(3, 10);
+```
+
+##### .domElement(value)
+
+Returns `true` if `value` is a DOM Element.
+
+##### .nodeStream(value)
+
+Returns `true` if `value` is a Node.js [stream](https://nodejs.org/api/stream.html).
+
+```js
+const fs = require('fs');
+is.nodeStream(fs.createReadStream('unicorn.png'));
+//=> true
+```
+
+##### .infinite(value)
+
+Check if `value` is `Infinity` or `-Infinity`.
+
+##### .even(value)
+
+Returns `true` if `value` is an even integer.
+
+##### .odd(value)
+
+Returns `true` if `value` is an odd integer.
+
+##### .empty(value)
+
+Returns `true` if `value` is falsy or an empty string, array, object, map, or set.
+
+##### .emptyOrWhitespace(value)
+
+Returns `true` if `is.empty(value)` or a string that is all whitespace.
+
+
+##### .any(predicate, ...values)
+
+Returns `true` if **any** of the input `values` returns true in the `predicate`:
+
+```js
+is.any(is.string, {}, true, '🦄');
+//=> true
+
+is.any(is.boolean, 'unicorns', [], new Map());
+//=> false
+```
+
+##### .all(predicate, ...values)
+
+Returns `true` if **all** of the input `values` returns true in the `predicate`:
+
+```js
+is.all(is.object, {}, new Map(), new Set());
+//=> true
+
+is.all(is.string, '🦄', [], 'unicorns');
+//=> false
+```
+
+## FAQ
+
+### Why yet another type checking module?
+
+There are hundreds of type checking modules on npm, unfortunately, I couldn't find any that fit my needs:
+
+- Includes both type methods and ability to get the type
+- Types of primitives returned as lowercase and object types as camelcase
+- Covers all built-ins
+- Unsurprising behavior
+- Well-maintained
+- Comprehensive test suite
+
+For the ones I found, pick 3 of these.
+
+The most common mistakes I noticed in these modules was using `instanceof` for type checking, forgetting that functions are objects, and omitting `symbol` as a primitive.
+
+
+## Related
+
+- [is-stream](https://github.com/sindresorhus/is-stream) - Check if something is a Node.js stream
+- [is-observable](https://github.com/sindresorhus/is-observable) - Check if a value is an Observable
+- [file-type](https://github.com/sindresorhus/file-type) - Detect the file type of a Buffer/Uint8Array
+- [is-ip](https://github.com/sindresorhus/is-ip) - Check if a string is an IP address
+- [is-array-sorted](https://github.com/sindresorhus/is-array-sorted) - Check if an Array is sorted
+- [is-error-constructor](https://github.com/sindresorhus/is-error-constructor) - Check if a value is an error constructor
+- [is-empty-iterable](https://github.com/sindresorhus/is-empty-iterable) - Check if an Iterable is empty
+- [is-blob](https://github.com/sindresorhus/is-blob) - Check if a value is a Blob - File-like object of immutable, raw data
+- [has-emoji](https://github.com/sindresorhus/has-emoji) - Check whether a string has any emoji
+
+
+## Created by
+
+- [Sindre Sorhus](https://github.com/sindresorhus)
+- [Giora Guttsait](https://github.com/gioragutt)
+- [Brandon Smith](https://github.com/brandon93s)
+
+
+## License
+
+MIT

node_modules/accepts/HISTORY.md

@@ -0,0 +1,224 @@
+1.3.5 / 2018-02-28
+==================
+
+  * deps: mime-types@~2.1.18
+    - deps: mime-db@~1.33.0
+
+1.3.4 / 2017-08-22
+==================
+
+  * deps: mime-types@~2.1.16
+    - deps: mime-db@~1.29.0
+
+1.3.3 / 2016-05-02
+==================
+
+  * deps: mime-types@~2.1.11
+    - deps: mime-db@~1.23.0
+  * deps: negotiator@0.6.1
+    - perf: improve `Accept` parsing speed
+    - perf: improve `Accept-Charset` parsing speed
+    - perf: improve `Accept-Encoding` parsing speed
+    - perf: improve `Accept-Language` parsing speed
+
+1.3.2 / 2016-03-08
+==================
+
+  * deps: mime-types@~2.1.10
+    - Fix extension of `application/dash+xml`
+    - Update primary extension for `audio/mp4`
+    - deps: mime-db@~1.22.0
+
+1.3.1 / 2016-01-19
+==================
+
+  * deps: mime-types@~2.1.9
+    - deps: mime-db@~1.21.0
+
+1.3.0 / 2015-09-29
+==================
+
+  * deps: mime-types@~2.1.7
+    - deps: mime-db@~1.19.0
+  * deps: negotiator@0.6.0
+    - Fix including type extensions in parameters in `Accept` parsing
+    - Fix parsing `Accept` parameters with quoted equals
+    - Fix parsing `Accept` parameters with quoted semicolons
+    - Lazy-load modules from main entry point
+    - perf: delay type concatenation until needed
+    - perf: enable strict mode
+    - perf: hoist regular expressions
+    - perf: remove closures getting spec properties
+    - perf: remove a closure from media type parsing
+    - perf: remove property delete from media type parsing
+
+1.2.13 / 2015-09-06
+===================
+
+  * deps: mime-types@~2.1.6
+    - deps: mime-db@~1.18.0
+
+1.2.12 / 2015-07-30
+===================
+
+  * deps: mime-types@~2.1.4
+    - deps: mime-db@~1.16.0
+
+1.2.11 / 2015-07-16
+===================
+
+  * deps: mime-types@~2.1.3
+    - deps: mime-db@~1.15.0
+
+1.2.10 / 2015-07-01
+===================
+
+  * deps: mime-types@~2.1.2
+    - deps: mime-db@~1.14.0
+
+1.2.9 / 2015-06-08
+==================
+
+  * deps: mime-types@~2.1.1
+    - perf: fix deopt during mapping
+
+1.2.8 / 2015-06-07
+==================
+
+  * deps: mime-types@~2.1.0
+    - deps: mime-db@~1.13.0
+  * perf: avoid argument reassignment & argument slice
+  * perf: avoid negotiator recursive construction
+  * perf: enable strict mode
+  * perf: remove unnecessary bitwise operator
+
+1.2.7 / 2015-05-10
+==================
+
+  * deps: negotiator@0.5.3
+    - Fix media type parameter matching to be case-insensitive
+
+1.2.6 / 2015-05-07
+==================
+
+  * deps: mime-types@~2.0.11
+    - deps: mime-db@~1.9.1
+  * deps: negotiator@0.5.2
+    - Fix comparing media types with quoted values
+    - Fix splitting media types with quoted commas
+
+1.2.5 / 2015-03-13
+==================
+
+  * deps: mime-types@~2.0.10
+    - deps: mime-db@~1.8.0
+
+1.2.4 / 2015-02-14
+==================
+
+  * Support Node.js 0.6
+  * deps: mime-types@~2.0.9
+    - deps: mime-db@~1.7.0
+  * deps: negotiator@0.5.1
+    - Fix preference sorting to be stable for long acceptable lists
+
+1.2.3 / 2015-01-31
+==================
+
+  * deps: mime-types@~2.0.8
+    - deps: mime-db@~1.6.0
+
+1.2.2 / 2014-12-30
+==================
+
+  * deps: mime-types@~2.0.7
+    - deps: mime-db@~1.5.0
+
+1.2.1 / 2014-12-30
+==================
+
+  * deps: mime-types@~2.0.5
+    - deps: mime-db@~1.3.1
+
+1.2.0 / 2014-12-19
+==================
+
+  * deps: negotiator@0.5.0
+    - Fix list return order when large accepted list
+    - Fix missing identity encoding when q=0 exists
+    - Remove dynamic building of Negotiator class
+
+1.1.4 / 2014-12-10
+==================
+
+  * deps: mime-types@~2.0.4
+    - deps: mime-db@~1.3.0
+
+1.1.3 / 2014-11-09
+==================
+
+  * deps: mime-types@~2.0.3
+    - deps: mime-db@~1.2.0
+
+1.1.2 / 2014-10-14
+==================
+
+  * deps: negotiator@0.4.9
+    - Fix error when media type has invalid parameter
+
+1.1.1 / 2014-09-28
+==================
+
+  * deps: mime-types@~2.0.2
+    - deps: mime-db@~1.1.0
+  * deps: negotiator@0.4.8
+    - Fix all negotiations to be case-insensitive
+    - Stable sort preferences of same quality according to client order
+
+1.1.0 / 2014-09-02
+==================
+
+  * update `mime-types`
+
+1.0.7 / 2014-07-04
+==================
+
+  * Fix wrong type returned from `type` when match after unknown extension
+
+1.0.6 / 2014-06-24
+==================
+
+  * deps: negotiator@0.4.7
+
+1.0.5 / 2014-06-20
+==================
+
+ * fix crash when unknown extension given
+
+1.0.4 / 2014-06-19
+==================
+
+  * use `mime-types`
+
+1.0.3 / 2014-06-11
+==================
+
+  * deps: negotiator@0.4.6
+    - Order by specificity when quality is the same
+
+1.0.2 / 2014-05-29
+==================
+
+  * Fix interpretation when header not in request
+  * deps: pin negotiator@0.4.5
+
+1.0.1 / 2014-01-18
+==================
+
+  * Identity encoding isn't always acceptable
+  * deps: negotiator@~0.4.0
+
+1.0.0 / 2013-12-27
+==================
+
+  * Genesis

node_modules/accepts/LICENSE

@@ -0,0 +1,23 @@
+(The MIT License)
+
+Copyright (c) 2014 Jonathan Ong <me@jongleberry.com>
+Copyright (c) 2015 Douglas Christopher Wilson <doug@somethingdoug.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/accepts/README.md

@@ -0,0 +1,143 @@
+# accepts
+
+[![NPM Version][npm-image]][npm-url]
+[![NPM Downloads][downloads-image]][downloads-url]
+[![Node.js Version][node-version-image]][node-version-url]
+[![Build Status][travis-image]][travis-url]
+[![Test Coverage][coveralls-image]][coveralls-url]
+
+Higher level content negotiation based on [negotiator](https://www.npmjs.com/package/negotiator).
+Extracted from [koa](https://www.npmjs.com/package/koa) for general use.
+
+In addition to negotiator, it allows:
+
+- Allows types as an array or arguments list, ie `(['text/html', 'application/json'])`
+  as well as `('text/html', 'application/json')`.
+- Allows type shorthands such as `json`.
+- Returns `false` when no types match
+- Treats non-existent headers as `*`
+
+## Installation
+
+This is a [Node.js](https://nodejs.org/en/) module available through the
+[npm registry](https://www.npmjs.com/). Installation is done using the
+[`npm install` command](https://docs.npmjs.com/getting-started/installing-npm-packages-locally):
+
+```sh
+$ npm install accepts
+```
+
+## API
+
+<!-- eslint-disable no-unused-vars -->
+
+```js
+var accepts = require('accepts')
+```
+
+### accepts(req)
+
+Create a new `Accepts` object for the given `req`.
+
+#### .charset(charsets)
+
+Return the first accepted charset. If nothing in `charsets` is accepted,
+then `false` is returned.
+
+#### .charsets()
+
+Return the charsets that the request accepts, in the order of the client's
+preference (most preferred first).
+
+#### .encoding(encodings)
+
+Return the first accepted encoding. If nothing in `encodings` is accepted,
+then `false` is returned.
+
+#### .encodings()
+
+Return the encodings that the request accepts, in the order of the client's
+preference (most preferred first).
+
+#### .language(languages)
+
+Return the first accepted language. If nothing in `languages` is accepted,
+then `false` is returned.
+
+#### .languages()
+
+Return the languages that the request accepts, in the order of the client's
+preference (most preferred first).
+
+#### .type(types)
+
+Return the first accepted type (and it is returned as the same text as what
+appears in the `types` array). If nothing in `types` is accepted, then `false`
+is returned.
+
+The `types` array can contain full MIME types or file extensions. Any value
+that is not a full MIME types is passed to `require('mime-types').lookup`.
+
+#### .types()
+
+Return the types that the request accepts, in the order of the client's
+preference (most preferred first).
+
+## Examples
+
+### Simple type negotiation
+
+This simple example shows how to use `accepts` to return a different typed
+respond body based on what the client wants to accept. The server lists it's
+preferences in order and will get back the best match between the client and
+server.
+
+```js
+var accepts = require('accepts')
+var http = require('http')
+
+function app (req, res) {
+  var accept = accepts(req)
+
+  // the order of this list is significant; should be server preferred order
+  switch (accept.type(['json', 'html'])) {
+    case 'json':
+      res.setHeader('Content-Type', 'application/json')
+      res.write('{"hello":"world!"}')
+      break
+    case 'html':
+      res.setHeader('Content-Type', 'text/html')
+      res.write('<b>hello, world!</b>')
+      break
+    default:
+      // the fallback is text/plain, so no need to specify it above
+      res.setHeader('Content-Type', 'text/plain')
+      res.write('hello, world!')
+      break
+  }
+
+  res.end()
+}
+
+http.createServer(app).listen(3000)
+```
+
+You can test this out with the cURL program:
+```sh
+curl -I -H'Accept: text/html' http://localhost:3000/
+```
+
+## License
+
+[MIT](LICENSE)
+
+[npm-image]: https://img.shields.io/npm/v/accepts.svg
+[npm-url]: https://npmjs.org/package/accepts
+[node-version-image]: https://img.shields.io/node/v/accepts.svg
+[node-version-url]: https://nodejs.org/en/download/
+[travis-image]: https://img.shields.io/travis/jshttp/accepts/master.svg
+[travis-url]: https://travis-ci.org/jshttp/accepts
+[coveralls-image]: https://img.shields.io/coveralls/jshttp/accepts/master.svg
+[coveralls-url]: https://coveralls.io/r/jshttp/accepts
+[downloads-image]: https://img.shields.io/npm/dm/accepts.svg
+[downloads-url]: https://npmjs.org/package/accepts