fsevents 1.1.2 → 1.2.3

package/node_modules/minizlib/index.js

@@ -0,0 +1,364 @@
+'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

@@ -0,0 +1,72 @@
+{
+  "_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": [],
+  "_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"
+}