fsevents 1.2.4 → 1.2.6

package/node_modules/minizlib/index.js

@@ -1,364 +0,0 @@
-'use strict'
-
-const assert = require('assert')
-const Buffer = require('buffer').Buffer
-const binding = process.binding('zlib')
-
-const constants = exports.constants = require('./constants.js')
-const MiniPass = require('minipass')
-
-class ZlibError extends Error {
-  constructor (msg, errno) {
-    super('zlib: ' + msg)
-    this.errno = errno
-    this.code = codes.get(errno)
-  }
-
-  get name () {
-    return 'ZlibError'
-  }
-}
-
-// translation table for return codes.
-const codes = new Map([
-  [constants.Z_OK, 'Z_OK'],
-  [constants.Z_STREAM_END, 'Z_STREAM_END'],
-  [constants.Z_NEED_DICT, 'Z_NEED_DICT'],
-  [constants.Z_ERRNO, 'Z_ERRNO'],
-  [constants.Z_STREAM_ERROR, 'Z_STREAM_ERROR'],
-  [constants.Z_DATA_ERROR, 'Z_DATA_ERROR'],
-  [constants.Z_MEM_ERROR, 'Z_MEM_ERROR'],
-  [constants.Z_BUF_ERROR, 'Z_BUF_ERROR'],
-  [constants.Z_VERSION_ERROR, 'Z_VERSION_ERROR']
-])
-
-const validFlushFlags = new Set([
-  constants.Z_NO_FLUSH,
-  constants.Z_PARTIAL_FLUSH,
-  constants.Z_SYNC_FLUSH,
-  constants.Z_FULL_FLUSH,
-  constants.Z_FINISH,
-  constants.Z_BLOCK
-])
-
-const strategies = new Set([
-  constants.Z_FILTERED,
-  constants.Z_HUFFMAN_ONLY,
-  constants.Z_RLE,
-  constants.Z_FIXED,
-  constants.Z_DEFAULT_STRATEGY
-])
-
-// the Zlib class they all inherit from
-// This thing manages the queue of requests, and returns
-// true or false if there is anything in the queue when
-// you call the .write() method.
-const _opts = Symbol('opts')
-const _chunkSize = Symbol('chunkSize')
-const _flushFlag = Symbol('flushFlag')
-const _finishFlush = Symbol('finishFlush')
-const _handle = Symbol('handle')
-const _hadError = Symbol('hadError')
-const _buffer = Symbol('buffer')
-const _offset = Symbol('offset')
-const _level = Symbol('level')
-const _strategy = Symbol('strategy')
-const _ended = Symbol('ended')
-const _writeState = Symbol('writeState')
-
-class Zlib extends MiniPass {
-  constructor (opts, mode) {
-    super(opts)
-    this[_ended] = false
-    this[_opts] = opts = opts || {}
-    this[_chunkSize] = opts.chunkSize || constants.Z_DEFAULT_CHUNK
-    if (opts.flush && !validFlushFlags.has(opts.flush)) {
-      throw new TypeError('Invalid flush flag: ' + opts.flush)
-    }
-    if (opts.finishFlush && !validFlushFlags.has(opts.finishFlush)) {
-      throw new TypeError('Invalid flush flag: ' + opts.finishFlush)
-    }
-
-    this[_flushFlag] = opts.flush || constants.Z_NO_FLUSH
-    this[_finishFlush] = typeof opts.finishFlush !== 'undefined' ?
-      opts.finishFlush : constants.Z_FINISH
-
-    if (opts.chunkSize) {
-      if (opts.chunkSize < constants.Z_MIN_CHUNK) {
-        throw new RangeError('Invalid chunk size: ' + opts.chunkSize)
-      }
-    }
-
-    if (opts.windowBits) {
-      if (opts.windowBits < constants.Z_MIN_WINDOWBITS ||
-          opts.windowBits > constants.Z_MAX_WINDOWBITS) {
-        throw new RangeError('Invalid windowBits: ' + opts.windowBits)
-      }
-    }
-
-    if (opts.level) {
-      if (opts.level < constants.Z_MIN_LEVEL ||
-          opts.level > constants.Z_MAX_LEVEL) {
-        throw new RangeError('Invalid compression level: ' + opts.level)
-      }
-    }
-
-    if (opts.memLevel) {
-      if (opts.memLevel < constants.Z_MIN_MEMLEVEL ||
-          opts.memLevel > constants.Z_MAX_MEMLEVEL) {
-        throw new RangeError('Invalid memLevel: ' + opts.memLevel)
-      }
-    }
-
-    if (opts.strategy && !(strategies.has(opts.strategy)))
-      throw new TypeError('Invalid strategy: ' + opts.strategy)
-
-    if (opts.dictionary) {
-      if (!(opts.dictionary instanceof Buffer)) {
-        throw new TypeError('Invalid dictionary: it should be a Buffer instance')
-      }
-    }
-
-    this[_handle] = new binding.Zlib(mode)
-
-    this[_hadError] = false
-    this[_handle].onerror = (message, errno) => {
-      // there is no way to cleanly recover.
-      // continuing only obscures problems.
-      this.close()
-      this[_hadError] = true
-
-      const error = new ZlibError(message, errno)
-      this.emit('error', error)
-    }
-
-    const level = typeof opts.level === 'number' ? opts.level
-                : constants.Z_DEFAULT_COMPRESSION
-
-    var strategy = typeof opts.strategy === 'number' ? opts.strategy
-                 : constants.Z_DEFAULT_STRATEGY
-
-    this[_writeState] = new Uint32Array(2);
-    const window = opts.windowBits || constants.Z_DEFAULT_WINDOWBITS
-    const memLevel = opts.memLevel || constants.Z_DEFAULT_MEMLEVEL
-
-    // API changed in node v9
-    /* istanbul ignore next */
-    if (/^v[0-8]\./.test(process.version)) {
-      this[_handle].init(window,
-                         level,
-                         memLevel,
-                         strategy,
-                         opts.dictionary)
-    } else {
-      this[_handle].init(window,
-                         level,
-                         memLevel,
-                         strategy,
-                         this[_writeState],
-                         () => {},
-                         opts.dictionary)
-    }
-
-    this[_buffer] = Buffer.allocUnsafe(this[_chunkSize])
-    this[_offset] = 0
-    this[_level] = level
-    this[_strategy] = strategy
-
-    this.once('end', this.close)
-  }
-
-  close () {
-    if (this[_handle]) {
-      this[_handle].close()
-      this[_handle] = null
-      this.emit('close')
-    }
-  }
-
-  params (level, strategy) {
-    if (!this[_handle])
-      throw new Error('cannot switch params when binding is closed')
-
-    // no way to test this without also not supporting params at all
-    /* istanbul ignore if */
-    if (!this[_handle].params)
-      throw new Error('not supported in this implementation')
-
-    if (level < constants.Z_MIN_LEVEL ||
-        level > constants.Z_MAX_LEVEL) {
-      throw new RangeError('Invalid compression level: ' + level)
-    }
-
-    if (!(strategies.has(strategy)))
-      throw new TypeError('Invalid strategy: ' + strategy)
-
-    if (this[_level] !== level || this[_strategy] !== strategy) {
-      this.flush(constants.Z_SYNC_FLUSH)
-      assert(this[_handle], 'zlib binding closed')
-      this[_handle].params(level, strategy)
-      /* istanbul ignore else */
-      if (!this[_hadError]) {
-        this[_level] = level
-        this[_strategy] = strategy
-      }
-    }
-  }
-
-  reset () {
-    assert(this[_handle], 'zlib binding closed')
-    return this[_handle].reset()
-  }
-
-  flush (kind) {
-    if (kind === undefined)
-      kind = constants.Z_FULL_FLUSH
-
-    if (this.ended)
-      return
-
-    const flushFlag = this[_flushFlag]
-    this[_flushFlag] = kind
-    this.write(Buffer.alloc(0))
-    this[_flushFlag] = flushFlag
-  }
-
-  end (chunk, encoding, cb) {
-    if (chunk)
-      this.write(chunk, encoding)
-    this.flush(this[_finishFlush])
-    this[_ended] = true
-    return super.end(null, null, cb)
-  }
-
-  get ended () {
-    return this[_ended]
-  }
-
-  write (chunk, encoding, cb) {
-    // process the chunk using the sync process
-    // then super.write() all the outputted chunks
-    if (typeof encoding === 'function')
-      cb = encoding, encoding = 'utf8'
-
-    if (typeof chunk === 'string')
-      chunk = new Buffer(chunk, encoding)
-
-    let availInBefore = chunk && chunk.length
-    let availOutBefore = this[_chunkSize] - this[_offset]
-    let inOff = 0 // the offset of the input buffer
-    const flushFlag = this[_flushFlag]
-    let writeReturn = true
-
-    assert(this[_handle], 'zlib binding closed')
-    do {
-      let res = this[_handle].writeSync(
-        flushFlag,
-        chunk, // in
-        inOff, // in_off
-        availInBefore, // in_len
-        this[_buffer], // out
-        this[_offset], //out_off
-        availOutBefore // out_len
-      )
-
-      if (this[_hadError])
-        break
-
-      // API changed in v9
-      /* istanbul ignore next */
-      let availInAfter = res ? res[0] : this[_writeState][1]
-      /* istanbul ignore next */
-      let availOutAfter = res ? res[1] : this[_writeState][0]
-
-      const have = availOutBefore - availOutAfter
-      assert(have >= 0, 'have should not go down')
-
-      if (have > 0) {
-        const out = this[_buffer].slice(
-          this[_offset], this[_offset] + have
-        )
-
-        this[_offset] += have
-        // serve some output to the consumer.
-        writeReturn = super.write(out) && writeReturn
-      }
-
-      // exhausted the output buffer, or used all the input create a new one.
-      if (availOutAfter === 0 || this[_offset] >= this[_chunkSize]) {
-        availOutBefore = this[_chunkSize]
-        this[_offset] = 0
-        this[_buffer] = Buffer.allocUnsafe(this[_chunkSize])
-      }
-
-      if (availOutAfter === 0) {
-        // Not actually done.  Need to reprocess.
-        // Also, update the availInBefore to the availInAfter value,
-        // so that if we have to hit it a third (fourth, etc.) time,
-        // it'll have the correct byte counts.
-        inOff += (availInBefore - availInAfter)
-        availInBefore = availInAfter
-        continue
-      }
-      break
-    } while (!this[_hadError])
-
-    if (cb)
-      cb()
-    return writeReturn
-  }
-}
-
-// minimal 2-byte header
-class Deflate extends Zlib {
-  constructor (opts) {
-    super(opts, constants.DEFLATE)
-  }
-}
-
-class Inflate extends Zlib {
-  constructor (opts) {
-    super(opts, constants.INFLATE)
-  }
-}
-
-// gzip - bigger header, same deflate compression
-class Gzip extends Zlib {
-  constructor (opts) {
-    super(opts, constants.GZIP)
-  }
-}
-
-class Gunzip extends Zlib {
-  constructor (opts) {
-    super(opts, constants.GUNZIP)
-  }
-}
-
-// raw - no header
-class DeflateRaw extends Zlib {
-  constructor (opts) {
-    super(opts, constants.DEFLATERAW)
-  }
-}
-
-class InflateRaw extends Zlib {
-  constructor (opts) {
-    super(opts, constants.INFLATERAW)
-  }
-}
-
-// auto-detect header.
-class Unzip extends Zlib {
-  constructor (opts) {
-    super(opts, constants.UNZIP)
-  }
-}
-
-exports.Deflate = Deflate
-exports.Inflate = Inflate
-exports.Gzip = Gzip
-exports.Gunzip = Gunzip
-exports.DeflateRaw = DeflateRaw
-exports.InflateRaw = InflateRaw
-exports.Unzip = Unzip

package/node_modules/minizlib/package.json

@@ -1,74 +0,0 @@
-{
-  "_args": [
-    [
-      "minizlib@1.1.0",
-      "/Users/eshanker/Code/fsevents"
-    ]
-  ],
-  "_from": "minizlib@1.1.0",
-  "_id": "minizlib@1.1.0",
-  "_inBundle": false,
-  "_integrity": "sha512-4T6Ur/GctZ27nHfpt9THOdRZNgyJ9FZchYO1ceg5S8Q3DNLCKYy44nCZzgCJgcvx2UM8czmqak5BCxJMrq37lA==",
-  "_location": "/minizlib",
-  "_phantomChildren": {},
-  "_requested": {
-    "type": "version",
-    "registry": true,
-    "raw": "minizlib@1.1.0",
-    "name": "minizlib",
-    "escapedName": "minizlib",
-    "rawSpec": "1.1.0",
-    "saveSpec": null,
-    "fetchSpec": "1.1.0"
-  },
-  "_requiredBy": [
-    "/tar"
-  ],
-  "_resolved": "https://registry.npmjs.org/minizlib/-/minizlib-1.1.0.tgz",
-  "_spec": "1.1.0",
-  "_where": "/Users/eshanker/Code/fsevents",
-  "author": {
-    "name": "Isaac Z. Schlueter",
-    "email": "i@izs.me",
-    "url": "http://blog.izs.me/"
-  },
-  "bugs": {
-    "url": "https://github.com/isaacs/minizlib/issues"
-  },
-  "dependencies": {
-    "minipass": "^2.2.1"
-  },
-  "description": "A small fast zlib stream built on [minipass](http://npm.im/minipass) and Node.js's zlib binding.",
-  "devDependencies": {
-    "tap": "^10.7.2"
-  },
-  "files": [
-    "index.js",
-    "constants.js"
-  ],
-  "homepage": "https://github.com/isaacs/minizlib#readme",
-  "keywords": [
-    "zlib",
-    "gzip",
-    "gunzip",
-    "deflate",
-    "inflate",
-    "compression",
-    "zip",
-    "unzip"
-  ],
-  "license": "MIT",
-  "main": "index.js",
-  "name": "minizlib",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/isaacs/minizlib.git"
-  },
-  "scripts": {
-    "postpublish": "git push origin --all; git push origin --tags",
-    "postversion": "npm publish",
-    "preversion": "npm test",
-    "test": "tap test/*.js --100 -J"
-  },
-  "version": "1.1.0"
-}

package/node_modules/mkdirp/.travis.yml

@@ -1,8 +0,0 @@
-language: node_js
-node_js:
-  - "0.8"
-  - "0.10"
-  - "0.12"
-  - "iojs"
-before_install:
-  - npm install -g npm@~1.4.6

package/node_modules/mkdirp/LICENSE

@@ -1,21 +0,0 @@
-Copyright 2010 James Halliday (mail@substack.net)
-
-This project is free software released under the MIT/X11 license:
-
-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.

package/node_modules/mkdirp/bin/cmd.js

@@ -1,33 +0,0 @@
-#!/usr/bin/env node
-
-var mkdirp = require('../');
-var minimist = require('minimist');
-var fs = require('fs');
-
-var argv = minimist(process.argv.slice(2), {
-    alias: { m: 'mode', h: 'help' },
-    string: [ 'mode' ]
-});
-if (argv.help) {
-    fs.createReadStream(__dirname + '/usage.txt').pipe(process.stdout);
-    return;
-}
-
-var paths = argv._.slice();
-var mode = argv.mode ? parseInt(argv.mode, 8) : undefined;
-
-(function next () {
-    if (paths.length === 0) return;
-    var p = paths.shift();
-    
-    if (mode === undefined) mkdirp(p, cb)
-    else mkdirp(p, mode, cb)
-    
-    function cb (err) {
-        if (err) {
-            console.error(err.message);
-            process.exit(1);
-        }
-        else next();
-    }
-})();

package/node_modules/mkdirp/bin/usage.txt

@@ -1,12 +0,0 @@
-usage: mkdirp [DIR1,DIR2..] {OPTIONS}
-
-  Create each supplied directory including any necessary parent directories that
-  don't yet exist.
-  
-  If the directory already exists, do nothing.
-
-OPTIONS are:
-
-  -m, --mode   If a directory needs to be created, set the mode as an octal
-               permission string.
-

package/node_modules/mkdirp/examples/pow.js

@@ -1,6 +0,0 @@
-var mkdirp = require('mkdirp');
-
-mkdirp('/tmp/foo/bar/baz', function (err) {
-    if (err) console.error(err)
-    else console.log('pow!')
-});

package/node_modules/mkdirp/index.js

@@ -1,98 +0,0 @@
-var path = require('path');
-var fs = require('fs');
-var _0777 = parseInt('0777', 8);
-
-module.exports = mkdirP.mkdirp = mkdirP.mkdirP = mkdirP;
-
-function mkdirP (p, opts, f, made) {
-    if (typeof opts === 'function') {
-        f = opts;
-        opts = {};
-    }
-    else if (!opts || typeof opts !== 'object') {
-        opts = { mode: opts };
-    }
-    
-    var mode = opts.mode;
-    var xfs = opts.fs || fs;
-    
-    if (mode === undefined) {
-        mode = _0777 & (~process.umask());
-    }
-    if (!made) made = null;
-    
-    var cb = f || function () {};
-    p = path.resolve(p);
-    
-    xfs.mkdir(p, mode, function (er) {
-        if (!er) {
-            made = made || p;
-            return cb(null, made);
-        }
-        switch (er.code) {
-            case 'ENOENT':
-                mkdirP(path.dirname(p), opts, function (er, made) {
-                    if (er) cb(er, made);
-                    else mkdirP(p, opts, cb, made);
-                });
-                break;
-
-            // In the case of any other error, just see if there's a dir
-            // there already.  If so, then hooray!  If not, then something
-            // is borked.
-            default:
-                xfs.stat(p, function (er2, stat) {
-                    // if the stat fails, then that's super weird.
-                    // let the original error be the failure reason.
-                    if (er2 || !stat.isDirectory()) cb(er, made)
-                    else cb(null, made);
-                });
-                break;
-        }
-    });
-}
-
-mkdirP.sync = function sync (p, opts, made) {
-    if (!opts || typeof opts !== 'object') {
-        opts = { mode: opts };
-    }
-    
-    var mode = opts.mode;
-    var xfs = opts.fs || fs;
-    
-    if (mode === undefined) {
-        mode = _0777 & (~process.umask());
-    }
-    if (!made) made = null;
-
-    p = path.resolve(p);
-
-    try {
-        xfs.mkdirSync(p, mode);
-        made = made || p;
-    }
-    catch (err0) {
-        switch (err0.code) {
-            case 'ENOENT' :
-                made = sync(path.dirname(p), opts, made);
-                sync(p, opts, made);
-                break;
-
-            // In the case of any other error, just see if there's a dir
-            // there already.  If so, then hooray!  If not, then something
-            // is borked.
-            default:
-                var stat;
-                try {
-                    stat = xfs.statSync(p);
-                }
-                catch (err1) {
-                    throw err0;
-                }
-                if (!stat.isDirectory()) throw err0;
-                break;
-        }
-    }
-
-    return made;
-};

package/node_modules/mkdirp/package.json

@@ -1,67 +0,0 @@
-{
-  "_args": [
-    [
-      "mkdirp@0.5.1",
-      "/Users/eshanker/Code/fsevents"
-    ]
-  ],
-  "_from": "mkdirp@0.5.1",
-  "_id": "mkdirp@0.5.1",
-  "_inBundle": false,
-  "_integrity": "sha1-MAV0OOrGz3+MR2fzhkjWaX11yQM=",
-  "_location": "/mkdirp",
-  "_phantomChildren": {},
-  "_requested": {
-    "type": "version",
-    "registry": true,
-    "raw": "mkdirp@0.5.1",
-    "name": "mkdirp",
-    "escapedName": "mkdirp",
-    "rawSpec": "0.5.1",
-    "saveSpec": null,
-    "fetchSpec": "0.5.1"
-  },
-  "_requiredBy": [
-    "/node-pre-gyp",
-    "/tap",
-    "/tar"
-  ],
-  "_resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.1.tgz",
-  "_spec": "0.5.1",
-  "_where": "/Users/eshanker/Code/fsevents",
-  "author": {
-    "name": "James Halliday",
-    "email": "mail@substack.net",
-    "url": "http://substack.net"
-  },
-  "bin": {
-    "mkdirp": "bin/cmd.js"
-  },
-  "bugs": {
-    "url": "https://github.com/substack/node-mkdirp/issues"
-  },
-  "dependencies": {
-    "minimist": "0.0.8"
-  },
-  "description": "Recursively mkdir, like `mkdir -p`",
-  "devDependencies": {
-    "mock-fs": "2 >=2.7.0",
-    "tap": "1"
-  },
-  "homepage": "https://github.com/substack/node-mkdirp#readme",
-  "keywords": [
-    "mkdir",
-    "directory"
-  ],
-  "license": "MIT",
-  "main": "index.js",
-  "name": "mkdirp",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/substack/node-mkdirp.git"
-  },
-  "scripts": {
-    "test": "tap test/*.js"
-  },
-  "version": "0.5.1"
-}