fsevents 1.2.3 → 1.2.10

package/node_modules/minipass/index.js

@@ -1,36 +1,62 @@
 'use strict'
 const EE = require('events')
 const Yallist = require('yallist')
+const SD = require('string_decoder').StringDecoder
+
 const EOF = Symbol('EOF')
 const MAYBE_EMIT_END = Symbol('maybeEmitEnd')
 const EMITTED_END = Symbol('emittedEnd')
+const EMITTING_END = Symbol('emittingEnd')
 const CLOSED = Symbol('closed')
 const READ = Symbol('read')
 const FLUSH = Symbol('flush')
 const FLUSHCHUNK = Symbol('flushChunk')
-const SD = require('string_decoder').StringDecoder
 const ENCODING = Symbol('encoding')
 const DECODER = Symbol('decoder')
 const FLOWING = Symbol('flowing')
+const PAUSED = Symbol('paused')
 const RESUME = Symbol('resume')
 const BUFFERLENGTH = Symbol('bufferLength')
 const BUFFERPUSH = Symbol('bufferPush')
 const BUFFERSHIFT = Symbol('bufferShift')
 const OBJECTMODE = Symbol('objectMode')
+const DESTROYED = Symbol('destroyed')
+
+// TODO remove when Node v8 support drops
+const doIter = global._MP_NO_ITERATOR_SYMBOLS_  !== '1'
+const ASYNCITERATOR = doIter && Symbol.asyncIterator
+  || Symbol('asyncIterator not implemented')
+const ITERATOR = doIter && Symbol.iterator
+  || Symbol('iterator not implemented')
 
 // Buffer in node 4.x < 4.5.0 doesn't have working Buffer.from
 // or Buffer.alloc, and Buffer in node 10 deprecated the ctor.
 // .M, this is fine .\^/M..
-let B = Buffer
-/* istanbul ignore next */
-if (!B.alloc) {
-  B = require('safe-buffer').Buffer
-}
-
-class MiniPass extends EE {
+const B = Buffer.alloc ? Buffer
+  : /* istanbul ignore next */ require('safe-buffer').Buffer
+
+// events that mean 'the stream is over'
+// these are treated specially, and re-emitted
+// if they are listened for after emitting.
+const isEndish = ev =>
+  ev === 'end' ||
+  ev === 'finish' ||
+  ev === 'prefinish'
+
+const isArrayBuffer = b => b instanceof ArrayBuffer ||
+  typeof b === 'object' &&
+  b.constructor &&
+  b.constructor.name === 'ArrayBuffer' &&
+  b.byteLength >= 0
+
+const isArrayBufferView = b => !B.isBuffer(b) && ArrayBuffer.isView(b)
+
+module.exports = class Minipass extends EE {
   constructor (options) {
     super()
     this[FLOWING] = false
+    // whether we're explicitly paused
+    this[PAUSED] = false
     this.pipes = new Yallist()
     this.buffer = new Yallist()
     this[OBJECTMODE] = options && options.objectMode || false
@@ -43,10 +69,12 @@ class MiniPass extends EE {
     this[DECODER] = this[ENCODING] ? new SD(this[ENCODING]) : null
     this[EOF] = false
     this[EMITTED_END] = false
+    this[EMITTING_END] = false
     this[CLOSED] = false
     this.writable = true
     this.readable = true
     this[BUFFERLENGTH] = 0
+    this[DESTROYED] = false
   }
 
   get bufferLength () { return this[BUFFERLENGTH] }
@@ -73,16 +101,52 @@ class MiniPass extends EE {
     this.encoding = enc
   }
 
+  get objectMode () { return this[OBJECTMODE] }
+  set objectMode (ॐ ) { this[OBJECTMODE] = this[OBJECTMODE] || !!ॐ  }
+
   write (chunk, encoding, cb) {
     if (this[EOF])
       throw new Error('write after end')
 
+    if (this[DESTROYED]) {
+      this.emit('error', Object.assign(
+        new Error('Cannot call write after a stream was destroyed'),
+        { code: 'ERR_STREAM_DESTROYED' }
+      ))
+      return true
+    }
+
     if (typeof encoding === 'function')
       cb = encoding, encoding = 'utf8'
 
     if (!encoding)
       encoding = 'utf8'
 
+    // convert array buffers and typed array views into buffers
+    // at some point in the future, we may want to do the opposite!
+    // leave strings and buffers as-is
+    // anything else switches us into object mode
+    if (!this[OBJECTMODE] && !B.isBuffer(chunk)) {
+      if (isArrayBufferView(chunk))
+        chunk = B.from(chunk.buffer, chunk.byteOffset, chunk.byteLength)
+      else if (isArrayBuffer(chunk))
+        chunk = B.from(chunk)
+      else if (typeof chunk !== 'string')
+        // use the setter so we throw if we have encoding set
+        this.objectMode = true
+    }
+
+    // this ensures at this point that the chunk is a buffer or string
+    // don't buffer it up or send it to the decoder
+    if (!this.objectMode && !chunk.length) {
+      const ret = this.flowing
+      if (this[BUFFERLENGTH] !== 0)
+        this.emit('readable')
+      if (cb)
+        cb()
+      return ret
+    }
+
     // fast-path writing strings of same encoding to a stream with
     // an empty buffer, skipping the buffer/decoder dance
     if (typeof chunk === 'string' && !this[OBJECTMODE] &&
@@ -99,13 +163,17 @@ class MiniPass extends EE {
         ? (this.emit('data', chunk), this.flowing)
         : (this[BUFFERPUSH](chunk), false)
     } finally {
-      this.emit('readable')
+      if (this[BUFFERLENGTH] !== 0)
+        this.emit('readable')
       if (cb)
         cb()
     }
   }
 
   read (n) {
+    if (this[DESTROYED])
+      return null
+
     try {
       if (this[BUFFERLENGTH] === 0 || n === 0 || n > this[BUFFERLENGTH])
         return null
@@ -158,12 +226,22 @@ class MiniPass extends EE {
       this.once('end', cb)
     this[EOF] = true
     this.writable = false
-    if (this.flowing)
+
+    // if we haven't written anything, then go ahead and emit,
+    // even if we're not reading.
+    // we'll re-emit if a new 'end' listener is added anyway.
+    // This makes MP more suitable to write-only use cases.
+    if (this.flowing || !this[PAUSED])
       this[MAYBE_EMIT_END]()
+    return this
   }
 
   // don't let the internal resume be overwritten
   [RESUME] () {
+    if (this[DESTROYED])
+      return
+
+    this[PAUSED] = false
     this[FLOWING] = true
     this.emit('resume')
     if (this.buffer.length)
@@ -180,12 +258,21 @@ class MiniPass extends EE {
 
   pause () {
     this[FLOWING] = false
+    this[PAUSED] = true
+  }
+
+  get destroyed () {
+    return this[DESTROYED]
   }
 
   get flowing () {
     return this[FLOWING]
   }
 
+  get paused () {
+    return this[PAUSED]
+  }
+
   [BUFFERPUSH] (chunk) {
     if (this[OBJECTMODE])
       this[BUFFERLENGTH] += 1
@@ -216,13 +303,24 @@ class MiniPass extends EE {
   }
 
   pipe (dest, opts) {
+    if (this[DESTROYED])
+      return
+
+    const ended = this[EMITTED_END]
+    opts = opts || {}
     if (dest === process.stdout || dest === process.stderr)
-      (opts = opts || {}).end = false
+      opts.end = false
+    else
+      opts.end = opts.end !== false
+
     const p = { dest: dest, opts: opts, ondrain: _ => this[RESUME]() }
     this.pipes.push(p)
 
     dest.on('drain', p.ondrain)
     this[RESUME]()
+    // piping an ended stream ends immediately
+    if (ended && p.opts.end)
+      p.dest.end()
     return dest
   }
 
@@ -234,8 +332,11 @@ class MiniPass extends EE {
     try {
       return super.on(ev, fn)
     } finally {
-      if (ev === 'data' && !this.pipes.length && !this.flowing) {
+      if (ev === 'data' && !this.pipes.length && !this.flowing)
         this[RESUME]()
+      else if (isEndish(ev) && this[EMITTED_END]) {
+        super.emit(ev)
+        this.removeAllListeners(ev)
       }
     }
   }
@@ -245,23 +346,40 @@ class MiniPass extends EE {
   }
 
   [MAYBE_EMIT_END] () {
-    if (!this[EMITTED_END] && this.buffer.length === 0 && this[EOF]) {
+    if (!this[EMITTING_END] &&
+        !this[EMITTED_END] &&
+        !this[DESTROYED] &&
+        this.buffer.length === 0 &&
+        this[EOF]) {
+      this[EMITTING_END] = true
       this.emit('end')
       this.emit('prefinish')
       this.emit('finish')
       if (this[CLOSED])
         this.emit('close')
+      this[EMITTING_END] = false
     }
   }
 
   emit (ev, data) {
-    if (ev === 'data') {
+    // error and close are only events allowed after calling destroy()
+    if (ev !== 'error' && ev !== 'close' && ev !== DESTROYED && this[DESTROYED])
+      return
+    else if (ev === 'data') {
       if (!data)
         return
 
       if (this.pipes.length)
-        this.pipes.forEach(p => p.dest.write(data) || this.pause())
+        this.pipes.forEach(p =>
+          p.dest.write(data) === false && this.pause())
     } else if (ev === 'end') {
+      // only actual end gets this treatment
+      if (this[EMITTED_END] === true)
+        return
+
+      this[EMITTED_END] = true
+      this.readable = false
+
       if (this[DECODER]) {
         data = this[DECODER].end()
         if (data) {
@@ -269,20 +387,20 @@ class MiniPass extends EE {
           super.emit('data', data)
         }
       }
+
       this.pipes.forEach(p => {
         p.dest.removeListener('drain', p.ondrain)
-        if (!p.opts || p.opts.end !== false)
+        if (p.opts.end)
           p.dest.end()
       })
-      this[EMITTED_END] = true
-      this.readable = false
     } else if (ev === 'close') {
       this[CLOSED] = true
       // don't emit close before 'end' and 'finish'
-      if (!this[EMITTED_END])
+      if (!this[EMITTED_END] && !this[DESTROYED])
         return
     }
 
+    // TODO: replace with a spread operator when Node v4 support drops
     const args = new Array(arguments.length)
     args[0] = ev
     args[1] = data
@@ -295,10 +413,125 @@ class MiniPass extends EE {
     try {
       return super.emit.apply(this, args)
     } finally {
-      if (ev !== 'end')
+      if (!isEndish(ev))
         this[MAYBE_EMIT_END]()
+      else
+        this.removeAllListeners(ev)
     }
   }
-}
 
-module.exports = MiniPass
+  // const all = await stream.collect()
+  collect () {
+    const buf = []
+    buf.dataLength = 0
+    this.on('data', c => {
+      buf.push(c)
+      buf.dataLength += c.length
+    })
+    return this.promise().then(() => buf)
+  }
+
+  // const data = await stream.concat()
+  concat () {
+    return this[OBJECTMODE]
+      ? Promise.reject(new Error('cannot concat in objectMode'))
+      : this.collect().then(buf =>
+          this[OBJECTMODE]
+            ? Promise.reject(new Error('cannot concat in objectMode'))
+            : this[ENCODING] ? buf.join('') : B.concat(buf, buf.dataLength))
+  }
+
+  // stream.promise().then(() => done, er => emitted error)
+  promise () {
+    return new Promise((resolve, reject) => {
+      this.on(DESTROYED, () => reject(new Error('stream destroyed')))
+      this.on('end', () => resolve())
+      this.on('error', er => reject(er))
+    })
+  }
+
+  // for await (let chunk of stream)
+  [ASYNCITERATOR] () {
+    const next = () => {
+      const res = this.read()
+      if (res !== null)
+        return Promise.resolve({ done: false, value: res })
+
+      if (this[EOF])
+        return Promise.resolve({ done: true })
+
+      let resolve = null
+      let reject = null
+      const onerr = er => {
+        this.removeListener('data', ondata)
+        this.removeListener('end', onend)
+        reject(er)
+      }
+      const ondata = value => {
+        this.removeListener('error', onerr)
+        this.removeListener('end', onend)
+        this.pause()
+        resolve({ value: value, done: !!this[EOF] })
+      }
+      const onend = () => {
+        this.removeListener('error', onerr)
+        this.removeListener('data', ondata)
+        resolve({ done: true })
+      }
+      const ondestroy = () => onerr(new Error('stream destroyed'))
+      return new Promise((res, rej) => {
+        reject = rej
+        resolve = res
+        this.once(DESTROYED, ondestroy)
+        this.once('error', onerr)
+        this.once('end', onend)
+        this.once('data', ondata)
+      })
+    }
+
+    return { next }
+  }
+
+  // for (let chunk of stream)
+  [ITERATOR] () {
+    const next = () => {
+      const value = this.read()
+      const done = value === null
+      return { value, done }
+    }
+    return { next }
+  }
+
+  destroy (er) {
+    if (this[DESTROYED]) {
+      if (er)
+        this.emit('error', er)
+      else
+        this.emit(DESTROYED)
+      return this
+    }
+
+    this[DESTROYED] = true
+
+    // throw away all buffered data, it's never coming out
+    this.buffer = new Yallist()
+    this[BUFFERLENGTH] = 0
+
+    if (typeof this.close === 'function' && !this[CLOSED])
+      this.close()
+
+    if (er)
+      this.emit('error', er)
+    else // if no error to emit, still reject pending promises
+      this.emit(DESTROYED)
+
+    return this
+  }
+
+  static isStream (s) {
+    return !!s && (s instanceof Minipass || s instanceof EE && (
+      typeof s.pipe === 'function' || // readable
+      (typeof s.write === 'function' && typeof s.end === 'function') // writable
+    ))
+  }
+}

package/node_modules/minipass/package.json

@@ -1,30 +1,29 @@
 {
-  "_args": [
-    [
-      "minipass@2.2.4",
-      "/Users/eshanker/Code/fsevents"
-    ]
-  ],
-  "_from": "minipass@2.2.4",
-  "_id": "minipass@2.2.4",
+  "_from": "minipass@^2.8.6",
+  "_id": "minipass@2.9.0",
   "_inBundle": false,
-  "_integrity": "sha512-hzXIWWet/BzWhYs2b+u7dRHlruXhwdgvlTMDKC6Cb1U7ps6Ac6yQlR39xsbjWJE377YTCtKwIXIpJ5oP+j5y8g==",
+  "_integrity": "sha512-wxfUjg9WebH+CUDX/CdbRlh5SmfZiy/hpkxaRI16Y9W56Pa75sWgd/rvFilSgrauD9NyFymP/+JFV3KwzIsJeg==",
   "_location": "/minipass",
   "_phantomChildren": {},
   "_requested": {
-    "type": "version",
+    "type": "range",
     "registry": true,
-    "raw": "minipass@2.2.4",
+    "raw": "minipass@^2.8.6",
     "name": "minipass",
     "escapedName": "minipass",
-    "rawSpec": "2.2.4",
+    "rawSpec": "^2.8.6",
     "saveSpec": null,
-    "fetchSpec": "2.2.4"
+    "fetchSpec": "^2.8.6"
   },
-  "_requiredBy": [],
-  "_resolved": "https://registry.npmjs.org/minipass/-/minipass-2.2.4.tgz",
-  "_spec": "2.2.4",
-  "_where": "/Users/eshanker/Code/fsevents",
+  "_requiredBy": [
+    "/fs-minipass",
+    "/minizlib",
+    "/tar"
+  ],
+  "_resolved": "https://registry.npmjs.org/minipass/-/minipass-2.9.0.tgz",
+  "_shasum": "e713762e7d3e32fed803115cf93e04bca9fcc9a6",
+  "_spec": "minipass@^2.8.6",
+  "_where": "/Users/pipobscure/fsevents/node_modules/tar",
   "author": {
     "name": "Isaac Z. Schlueter",
     "email": "i@izs.me",
@@ -33,14 +32,16 @@
   "bugs": {
     "url": "https://github.com/isaacs/minipass/issues"
   },
+  "bundleDependencies": false,
   "dependencies": {
-    "safe-buffer": "^5.1.1",
+    "safe-buffer": "^5.1.2",
     "yallist": "^3.0.0"
   },
+  "deprecated": false,
   "description": "minimal implementation of a PassThrough stream",
   "devDependencies": {
     "end-of-stream": "^1.4.0",
-    "tap": "^10.7.0",
+    "tap": "^14.6.5",
     "through2": "^2.0.3"
   },
   "files": [
@@ -59,10 +60,13 @@
     "url": "git+https://github.com/isaacs/minipass.git"
   },
   "scripts": {
-    "postpublish": "git push origin --all; git push origin --tags",
+    "postpublish": "git push origin --follow-tags",
     "postversion": "npm publish",
     "preversion": "npm test",
-    "test": "tap test/*.js --100"
+    "test": "tap"
+  },
+  "tap": {
+    "check-coverage": true
   },
-  "version": "2.2.4"
+  "version": "2.9.0"
 }

package/node_modules/minizlib/README.md

@@ -1,44 +1,53 @@
 # minizlib
 
-A tiny fast zlib stream built on [minipass](http://npm.im/minipass)
-and Node.js's zlib binding.
+A fast zlib stream built on [minipass](http://npm.im/minipass) and
+Node.js's zlib binding.
 
 This module was created to serve the needs of
-[node-tar](http://npm.im/tar) v2.  If your needs are different, then
-it may not be for you.
+[node-tar](http://npm.im/tar) and
+[minipass-fetch](http://npm.im/minipass-fetch).
+
+Brotli is supported in versions of node with a Brotli binding.
 
 ## How does this differ from the streams in `require('zlib')`?
 
 First, there are no convenience methods to compress or decompress a
 buffer.  If you want those, use the built-in `zlib` module.  This is
-only streams.
+only streams.  That being said, Minipass streams to make it fairly easy to
+use as one-liners: `new zlib.Deflate().end(data).read()` will return the
+deflate compressed result.
 
 This module compresses and decompresses the data as fast as you feed
 it in.  It is synchronous, and runs on the main process thread.  Zlib
-operations can be high CPU, but they're very fast, and doing it this
-way means much less bookkeeping and artificial deferral.
+and Brotli operations can be high CPU, but they're very fast, and doing it
+this way means much less bookkeeping and artificial deferral.
 
 Node's built in zlib streams are built on top of `stream.Transform`.
 They do the maximally safe thing with respect to consistent
 asynchrony, buffering, and backpressure.
 
-This module _does_ support backpressure, and will buffer output chunks
-that are not consumed, but is less of a mediator between the input and
-output.  There is no high or low watermarks, no state objects, and so
-artificial async deferrals.  It will not protect you from Zalgo.
-
-If you write, data will be emitted right away.  If you write
-everything synchronously in one tick, and you are listening to the
-`data` event to consume it, then it'll all be emitted right away in
-that same tick.  If you want data to be emitted in the next tick, then
-write it in the next tick.
-
-It is thus the responsibility of the reader and writer to manage their
-own consumption and process execution flow.
-
-The goal is to compress and decompress as fast as possible, even for
-files that are too large to store all in one buffer.
-
-The API is very similar to the built-in zlib module.  There are
-classes that you instantiate with `new` and they are streams that can
-be piped together.
+See [Minipass](http://npm.im/minipass) for more on the differences between
+Node.js core streams and Minipass streams, and the convenience methods
+provided by that class.
+
+## Classes
+
+- Deflate
+- Inflate
+- Gzip
+- Gunzip
+- DeflateRaw
+- InflateRaw
+- Unzip
+- BrotliCompress (Node v10 and higher)
+- BrotliDecompress (Node v10 and higher)
+
+## USAGE
+
+```js
+const zlib = require('minizlib')
+const input = sourceOfCompressedData()
+const decode = new zlib.BrotliDecompress()
+const output = whereToWriteTheDecodedData()
+input.pipe(decode).pipe(output)
+```

package/node_modules/minizlib/constants.js

@@ -1,4 +1,11 @@
-module.exports = Object.freeze({
+// Update with any zlib constants that are added or changed in the future.
+// Node v6 didn't export this, so we just hard code the version and rely
+// on all the other hard-coded values from zlib v4736.  When node v6
+// support drops, we can just export the realZlibConstants object.
+const realZlibConstants = require('zlib').constants ||
+  /* istanbul ignore next */ { ZLIB_VERNUM: 4736 }
+
+module.exports = Object.freeze(Object.assign(Object.create(null), {
   Z_NO_FLUSH: 0,
   Z_PARTIAL_FLUSH: 1,
   Z_SYNC_FLUSH: 2,
@@ -23,7 +30,6 @@ module.exports = Object.freeze({
   Z_RLE: 3,
   Z_FIXED: 4,
   Z_DEFAULT_STRATEGY: 0,
-  ZLIB_VERNUM: 4736,
   DEFLATE: 1,
   INFLATE: 2,
   GZIP: 3,
@@ -31,6 +37,8 @@ module.exports = Object.freeze({
   DEFLATERAW: 5,
   INFLATERAW: 6,
   UNZIP: 7,
+  BROTLI_DECODE: 8,
+  BROTLI_ENCODE: 9,
   Z_MIN_WINDOWBITS: 8,
   Z_MAX_WINDOWBITS: 15,
   Z_DEFAULT_WINDOWBITS: 15,
@@ -42,5 +50,66 @@ module.exports = Object.freeze({
   Z_DEFAULT_MEMLEVEL: 8,
   Z_MIN_LEVEL: -1,
   Z_MAX_LEVEL: 9,
-  Z_DEFAULT_LEVEL: -1
-})
+  Z_DEFAULT_LEVEL: -1,
+  BROTLI_OPERATION_PROCESS: 0,
+  BROTLI_OPERATION_FLUSH: 1,
+  BROTLI_OPERATION_FINISH: 2,
+  BROTLI_OPERATION_EMIT_METADATA: 3,
+  BROTLI_MODE_GENERIC: 0,
+  BROTLI_MODE_TEXT: 1,
+  BROTLI_MODE_FONT: 2,
+  BROTLI_DEFAULT_MODE: 0,
+  BROTLI_MIN_QUALITY: 0,
+  BROTLI_MAX_QUALITY: 11,
+  BROTLI_DEFAULT_QUALITY: 11,
+  BROTLI_MIN_WINDOW_BITS: 10,
+  BROTLI_MAX_WINDOW_BITS: 24,
+  BROTLI_LARGE_MAX_WINDOW_BITS: 30,
+  BROTLI_DEFAULT_WINDOW: 22,
+  BROTLI_MIN_INPUT_BLOCK_BITS: 16,
+  BROTLI_MAX_INPUT_BLOCK_BITS: 24,
+  BROTLI_PARAM_MODE: 0,
+  BROTLI_PARAM_QUALITY: 1,
+  BROTLI_PARAM_LGWIN: 2,
+  BROTLI_PARAM_LGBLOCK: 3,
+  BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING: 4,
+  BROTLI_PARAM_SIZE_HINT: 5,
+  BROTLI_PARAM_LARGE_WINDOW: 6,
+  BROTLI_PARAM_NPOSTFIX: 7,
+  BROTLI_PARAM_NDIRECT: 8,
+  BROTLI_DECODER_RESULT_ERROR: 0,
+  BROTLI_DECODER_RESULT_SUCCESS: 1,
+  BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT: 2,
+  BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT: 3,
+  BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION: 0,
+  BROTLI_DECODER_PARAM_LARGE_WINDOW: 1,
+  BROTLI_DECODER_NO_ERROR: 0,
+  BROTLI_DECODER_SUCCESS: 1,
+  BROTLI_DECODER_NEEDS_MORE_INPUT: 2,
+  BROTLI_DECODER_NEEDS_MORE_OUTPUT: 3,
+  BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE: -1,
+  BROTLI_DECODER_ERROR_FORMAT_RESERVED: -2,
+  BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE: -3,
+  BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET: -4,
+  BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME: -5,
+  BROTLI_DECODER_ERROR_FORMAT_CL_SPACE: -6,
+  BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE: -7,
+  BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT: -8,
+  BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1: -9,
+  BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2: -10,
+  BROTLI_DECODER_ERROR_FORMAT_TRANSFORM: -11,
+  BROTLI_DECODER_ERROR_FORMAT_DICTIONARY: -12,
+  BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS: -13,
+  BROTLI_DECODER_ERROR_FORMAT_PADDING_1: -14,
+  BROTLI_DECODER_ERROR_FORMAT_PADDING_2: -15,
+  BROTLI_DECODER_ERROR_FORMAT_DISTANCE: -16,
+  BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET: -19,
+  BROTLI_DECODER_ERROR_INVALID_ARGUMENTS: -20,
+  BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES: -21,
+  BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS: -22,
+  BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP: -25,
+  BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1: -26,
+  BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2: -27,
+  BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES: -30,
+  BROTLI_DECODER_ERROR_UNREACHABLE: -31,
+}, realZlibConstants))