appium-mac2-driver 4.5.0 → 4.6.0

package/node_modules/hpack.js/node_modules/string_decoder/lib/string_decoder.js

@@ -0,0 +1,296 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+'use strict';
+
+/*<replacement>*/
+
+var Buffer = require('safe-buffer').Buffer;
+/*</replacement>*/
+
+var isEncoding = Buffer.isEncoding || function (encoding) {
+  encoding = '' + encoding;
+  switch (encoding && encoding.toLowerCase()) {
+    case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw':
+      return true;
+    default:
+      return false;
+  }
+};
+
+function _normalizeEncoding(enc) {
+  if (!enc) return 'utf8';
+  var retried;
+  while (true) {
+    switch (enc) {
+      case 'utf8':
+      case 'utf-8':
+        return 'utf8';
+      case 'ucs2':
+      case 'ucs-2':
+      case 'utf16le':
+      case 'utf-16le':
+        return 'utf16le';
+      case 'latin1':
+      case 'binary':
+        return 'latin1';
+      case 'base64':
+      case 'ascii':
+      case 'hex':
+        return enc;
+      default:
+        if (retried) return; // undefined
+        enc = ('' + enc).toLowerCase();
+        retried = true;
+    }
+  }
+};
+
+// Do not cache `Buffer.isEncoding` when checking encoding names as some
+// modules monkey-patch it to support additional encodings
+function normalizeEncoding(enc) {
+  var nenc = _normalizeEncoding(enc);
+  if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);
+  return nenc || enc;
+}
+
+// StringDecoder provides an interface for efficiently splitting a series of
+// buffers into a series of JS strings without breaking apart multi-byte
+// characters.
+exports.StringDecoder = StringDecoder;
+function StringDecoder(encoding) {
+  this.encoding = normalizeEncoding(encoding);
+  var nb;
+  switch (this.encoding) {
+    case 'utf16le':
+      this.text = utf16Text;
+      this.end = utf16End;
+      nb = 4;
+      break;
+    case 'utf8':
+      this.fillLast = utf8FillLast;
+      nb = 4;
+      break;
+    case 'base64':
+      this.text = base64Text;
+      this.end = base64End;
+      nb = 3;
+      break;
+    default:
+      this.write = simpleWrite;
+      this.end = simpleEnd;
+      return;
+  }
+  this.lastNeed = 0;
+  this.lastTotal = 0;
+  this.lastChar = Buffer.allocUnsafe(nb);
+}
+
+StringDecoder.prototype.write = function (buf) {
+  if (buf.length === 0) return '';
+  var r;
+  var i;
+  if (this.lastNeed) {
+    r = this.fillLast(buf);
+    if (r === undefined) return '';
+    i = this.lastNeed;
+    this.lastNeed = 0;
+  } else {
+    i = 0;
+  }
+  if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);
+  return r || '';
+};
+
+StringDecoder.prototype.end = utf8End;
+
+// Returns only complete characters in a Buffer
+StringDecoder.prototype.text = utf8Text;
+
+// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer
+StringDecoder.prototype.fillLast = function (buf) {
+  if (this.lastNeed <= buf.length) {
+    buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);
+    return this.lastChar.toString(this.encoding, 0, this.lastTotal);
+  }
+  buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);
+  this.lastNeed -= buf.length;
+};
+
+// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a
+// continuation byte. If an invalid byte is detected, -2 is returned.
+function utf8CheckByte(byte) {
+  if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4;
+  return byte >> 6 === 0x02 ? -1 : -2;
+}
+
+// Checks at most 3 bytes at the end of a Buffer in order to detect an
+// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)
+// needed to complete the UTF-8 character (if applicable) are returned.
+function utf8CheckIncomplete(self, buf, i) {
+  var j = buf.length - 1;
+  if (j < i) return 0;
+  var nb = utf8CheckByte(buf[j]);
+  if (nb >= 0) {
+    if (nb > 0) self.lastNeed = nb - 1;
+    return nb;
+  }
+  if (--j < i || nb === -2) return 0;
+  nb = utf8CheckByte(buf[j]);
+  if (nb >= 0) {
+    if (nb > 0) self.lastNeed = nb - 2;
+    return nb;
+  }
+  if (--j < i || nb === -2) return 0;
+  nb = utf8CheckByte(buf[j]);
+  if (nb >= 0) {
+    if (nb > 0) {
+      if (nb === 2) nb = 0;else self.lastNeed = nb - 3;
+    }
+    return nb;
+  }
+  return 0;
+}
+
+// Validates as many continuation bytes for a multi-byte UTF-8 character as
+// needed or are available. If we see a non-continuation byte where we expect
+// one, we "replace" the validated continuation bytes we've seen so far with
+// a single UTF-8 replacement character ('\ufffd'), to match v8's UTF-8 decoding
+// behavior. The continuation byte check is included three times in the case
+// where all of the continuation bytes for a character exist in the same buffer.
+// It is also done this way as a slight performance increase instead of using a
+// loop.
+function utf8CheckExtraBytes(self, buf, p) {
+  if ((buf[0] & 0xC0) !== 0x80) {
+    self.lastNeed = 0;
+    return '\ufffd';
+  }
+  if (self.lastNeed > 1 && buf.length > 1) {
+    if ((buf[1] & 0xC0) !== 0x80) {
+      self.lastNeed = 1;
+      return '\ufffd';
+    }
+    if (self.lastNeed > 2 && buf.length > 2) {
+      if ((buf[2] & 0xC0) !== 0x80) {
+        self.lastNeed = 2;
+        return '\ufffd';
+      }
+    }
+  }
+}
+
+// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.
+function utf8FillLast(buf) {
+  var p = this.lastTotal - this.lastNeed;
+  var r = utf8CheckExtraBytes(this, buf, p);
+  if (r !== undefined) return r;
+  if (this.lastNeed <= buf.length) {
+    buf.copy(this.lastChar, p, 0, this.lastNeed);
+    return this.lastChar.toString(this.encoding, 0, this.lastTotal);
+  }
+  buf.copy(this.lastChar, p, 0, buf.length);
+  this.lastNeed -= buf.length;
+}
+
+// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a
+// partial character, the character's bytes are buffered until the required
+// number of bytes are available.
+function utf8Text(buf, i) {
+  var total = utf8CheckIncomplete(this, buf, i);
+  if (!this.lastNeed) return buf.toString('utf8', i);
+  this.lastTotal = total;
+  var end = buf.length - (total - this.lastNeed);
+  buf.copy(this.lastChar, 0, end);
+  return buf.toString('utf8', i, end);
+}
+
+// For UTF-8, a replacement character is added when ending on a partial
+// character.
+function utf8End(buf) {
+  var r = buf && buf.length ? this.write(buf) : '';
+  if (this.lastNeed) return r + '\ufffd';
+  return r;
+}
+
+// UTF-16LE typically needs two bytes per character, but even if we have an even
+// number of bytes available, we need to check if we end on a leading/high
+// surrogate. In that case, we need to wait for the next two bytes in order to
+// decode the last character properly.
+function utf16Text(buf, i) {
+  if ((buf.length - i) % 2 === 0) {
+    var r = buf.toString('utf16le', i);
+    if (r) {
+      var c = r.charCodeAt(r.length - 1);
+      if (c >= 0xD800 && c <= 0xDBFF) {
+        this.lastNeed = 2;
+        this.lastTotal = 4;
+        this.lastChar[0] = buf[buf.length - 2];
+        this.lastChar[1] = buf[buf.length - 1];
+        return r.slice(0, -1);
+      }
+    }
+    return r;
+  }
+  this.lastNeed = 1;
+  this.lastTotal = 2;
+  this.lastChar[0] = buf[buf.length - 1];
+  return buf.toString('utf16le', i, buf.length - 1);
+}
+
+// For UTF-16LE we do not explicitly append special replacement characters if we
+// end on a partial character, we simply let v8 handle that.
+function utf16End(buf) {
+  var r = buf && buf.length ? this.write(buf) : '';
+  if (this.lastNeed) {
+    var end = this.lastTotal - this.lastNeed;
+    return r + this.lastChar.toString('utf16le', 0, end);
+  }
+  return r;
+}
+
+function base64Text(buf, i) {
+  var n = (buf.length - i) % 3;
+  if (n === 0) return buf.toString('base64', i);
+  this.lastNeed = 3 - n;
+  this.lastTotal = 3;
+  if (n === 1) {
+    this.lastChar[0] = buf[buf.length - 1];
+  } else {
+    this.lastChar[0] = buf[buf.length - 2];
+    this.lastChar[1] = buf[buf.length - 1];
+  }
+  return buf.toString('base64', i, buf.length - n);
+}
+
+function base64End(buf) {
+  var r = buf && buf.length ? this.write(buf) : '';
+  if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);
+  return r;
+}
+
+// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)
+function simpleWrite(buf) {
+  return buf.toString(this.encoding);
+}
+
+function simpleEnd(buf) {
+  return buf && buf.length ? this.write(buf) : '';
+}

package/node_modules/hpack.js/node_modules/string_decoder/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "string_decoder",
+  "version": "1.1.1",
+  "description": "The string_decoder module from Node core",
+  "main": "lib/string_decoder.js",
+  "dependencies": {
+    "safe-buffer": "~5.1.0"
+  },
+  "devDependencies": {
+    "babel-polyfill": "^6.23.0",
+    "core-util-is": "^1.0.2",
+    "inherits": "^2.0.3",
+    "tap": "~0.4.8"
+  },
+  "scripts": {
+    "test": "tap test/parallel/*.js && node test/verify-dependencies",
+    "ci": "tap test/parallel/*.js test/ours/*.js --tap | tee test.tap && node test/verify-dependencies.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/nodejs/string_decoder.git"
+  },
+  "homepage": "https://github.com/nodejs/string_decoder",
+  "keywords": [
+    "string",
+    "decoder",
+    "browser",
+    "browserify"
+  ],
+  "license": "MIT"
+}

package/node_modules/hpack.js/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "hpack.js",
+  "version": "2.1.6",
+  "description": "HPACK implementation",
+  "main": "lib/hpack.js",
+  "scripts": {
+    "test": "mocha test/*-test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/indutny/hpack.js.git"
+  },
+  "keywords": [
+    "HPACK",
+    "HTTP2",
+    "compress",
+    "decompress",
+    "headers"
+  ],
+  "author": "Fedor Indutny <fedor@indutny.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/indutny/hpack.js/issues"
+  },
+  "homepage": "https://github.com/indutny/hpack.js#readme",
+  "devDependencies": {
+    "mocha": "^2.2.5"
+  },
+  "dependencies": {
+    "inherits": "^2.0.1",
+    "obuf": "^1.0.0",
+    "readable-stream": "^2.0.1",
+    "wbuf": "^1.1.0"
+  }
+}

package/node_modules/hpack.js/test/compressor-test.js

@@ -0,0 +1,136 @@
+var assert = require('assert');
+var hpack = require('../');
+var fixtures = require('./fixtures');
+
+describe('hpack/compressor', function() {
+  var comp;
+
+  beforeEach(function() {
+    comp = hpack.compressor.create({
+      table: {
+        maxSize: 1024
+      }
+    });
+  });
+
+  function expect(arr, enc) {
+    function isNumber(num) {
+      return typeof num === 'number';
+    }
+
+    var out = comp.read().toString('hex');
+    if (Array.isArray(arr) && !arr.every(isNumber)) {
+      arr = arr.map(function(item) {
+        return new Buffer(item, enc);
+      });
+      arr = Buffer.concat(arr);
+    } else {
+      arr = new Buffer(arr, enc);
+    }
+    var actual = arr.toString('hex');
+    assert.equal(out, actual);
+  }
+
+  describe('indexed field', function() {
+    it('should lookup entry from static table', function() {
+      comp.write([{ name: ':method', value: 'GET' }]);
+      expect([ 0b10000000 | 2 ]);
+    });
+
+    it('should fetch entry from the end of the static table', function() {
+      comp.write([{ name: 'www-authenticate', value: '' }]);
+      expect([ 0b10000000 | 61 ]);
+    });
+  });
+
+  describe('literal field', function() {
+    it('should lookup name in the table (incremental)', function() {
+      comp.write([{ name: 'host', value: 'localhost' }]);
+      expect('6686a0e41d139d09', 'hex');
+
+      comp.write([{ name: 'host', value: 'localhost' }]);
+      expect([ 0b10000000 | 62 ]);
+    });
+
+    it('should lookup name in the table (not-incremental)', function() {
+      comp.write([{ name: 'host', value: 'localhost', incremental: false }]);
+      expect('0f1786a0e41d139d09', 'hex');
+
+      // Should not use the table
+      comp.write([{ name: 'host', value: 'localhost' }]);
+      expect('6686a0e41d139d09', 'hex');
+    });
+
+    it('should evict header field from the table', function() {
+      for (var i = 0; i < 1000; i++) {
+        comp.write([{ name: 'host', value: 'localhost' + i }]);
+        comp.read();
+      }
+
+      assert(comp._table.size < comp._table.maxSize);
+      assert.equal(comp._table.dynamic.length, 21);
+    });
+  });
+
+  describe('update size', function() {
+    it('should evict header field from the table', function() {
+      comp.write([{ name: 'host', value: 'localhost' }]);
+      expect('6686a0e41d139d09', 'hex');
+
+      comp.reset();
+
+      // update=0, update=maxSize
+      expect('203fe107', 'hex');
+
+      comp.write([{ name: 'host', value: 'localhost' }]);
+      expect('6686a0e41d139d09', 'hex');
+    });
+
+    it('should send dynamic update if size >= protocolMaxSize', function() {
+      comp.updateTableSize(Infinity);
+
+      // update=maxSize
+      expect('3fe107', 'hex');
+    });
+  });
+
+  describe('spec examples', function() {
+    beforeEach(function() {
+      comp = hpack.compressor.create({
+        table: {
+          maxSize: 256
+        }
+      });
+    });
+
+    var tests = fixtures.specExamples;
+
+    tests.forEach(function(test, i) {
+      var prev = tests[i - 1];
+      it('should give expected output on ' + test.id, function() {
+        var startFrom = test.continuation ? prev.comp : comp;
+        if (!startFrom)
+          throw new Error('Previous test failed');
+        comp = startFrom;
+
+        comp.write(test.output.map(function(pair) {
+          return { name: pair[0], value: pair[1], huffman: test.huffman };
+        }));
+        expect(test.input.replace(/ /g, ''), 'hex');
+
+        // Verify table contents
+        assert.deepEqual(comp._table.dynamic.map(function(header) {
+          return [ header.name, header.value, header.totalSize ];
+        }).reverse(), test.table);
+
+        // Verify table size
+        var expectedSize = test.table.reduce(function(acc, item) {
+          return acc + item[2];
+        }, 0);
+        assert.equal(comp._table.size, expectedSize);
+
+        test.comp = comp;
+      });
+    });
+  });
+});

package/node_modules/hpack.js/test/decoder-test.js

@@ -0,0 +1,181 @@
+var assert = require('assert');
+var hpack = require('../');
+
+describe('hpack/decoder', function() {
+  var decoder;
+
+  beforeEach(function() {
+    decoder = hpack.decoder.create();
+  });
+
+  describe('bit', function() {
+    it('should decode number bit-by-bit', function() {
+      decoder.push([ 0b11101010, 0b10101111 ]);
+      var out = '';
+      for (var i = 0; i < 16; i++)
+        out += decoder.decodeBit();
+      assert.equal(out, '11101010' + '10101111');
+    });
+  });
+
+  describe('integer', function() {
+    it('should decode 10 in prefix-5 (C.1.1)', function() {
+      decoder.push([ 0b11101010 ]);
+      decoder.skipBits(3);
+      assert.equal(decoder.decodeInt(), 10);
+    });
+
+    it('should decode 1337 in prefix-5 (C.1.2)', function() {
+      decoder.push([ 0b11111111, 0b10011010, 0b00001010 ]);
+      decoder.skipBits(3);
+      assert.equal(decoder.decodeInt(), 1337);
+    });
+
+    it('should decode 42 at octect boundary (C.1.3)', function() {
+      decoder.push([ 0b00101010 ]);
+      assert.equal(decoder.decodeInt(8), 42);
+    });
+
+    it('should throw on empty input', function() {
+      assert.throws(function() {
+        decoder.decodeInt();
+      });
+    });
+
+    it('should throw on incomplete int', function() {
+      decoder.push([ 0b11111111, 0b10011010 ]);
+      decoder.skipBits(3);
+      assert.throws(function() {
+        decoder.decodeInt();
+      });
+    });
+
+    it('should throw on overflowing int', function() {
+      decoder.push([
+        0b11111111,
+        0b10011010,
+        0b10011010,
+        0b10011010,
+        0b10011010,
+        0b10011010
+      ]);
+      decoder.skipBits(3);
+      assert.throws(function() {
+        decoder.decodeInt();
+      });
+    });
+  });
+
+  describe('string', function() {
+    it('should decode literal from (C.2.1)', function() {
+      decoder.push([ 0x0a ]);
+      decoder.push(new Buffer('custom-key'));
+
+      assert.equal(decoder.decodeStr().toString(), 'custom-key');
+    });
+
+    it('should decode literal from (C.4.1)', function() {
+      decoder.push(new Buffer(
+        '8c' +
+            'f1e3 c2e5 f23a 6ba0 ab90 f4ff'.replace(/ /g, ''),
+        'hex'));
+
+      assert.equal(new Buffer(decoder.decodeStr()).toString(),
+                   'www.example.com');
+    });
+
+    it('should decode literal from (C.4.2)', function() {
+      decoder.push(new Buffer(
+        '86' +
+            'a8eb 1064 9cbf'.replace(/ /g, ''),
+        'hex'));
+
+      assert.equal(new Buffer(decoder.decodeStr()).toString(), 'no-cache');
+    });
+
+    it('should decode literal from (C.4.3) #1', function() {
+      decoder.push(new Buffer(
+        '88' +
+            '25a8 49e9 5ba9 7d7f'.replace(/ /g, ''),
+        'hex'));
+
+      assert.equal(new Buffer(decoder.decodeStr()).toString(), 'custom-key');
+    });
+
+    it('should decode literal from (C.4.3) #2', function() {
+      decoder.push(new Buffer(
+        '89' +
+            '25a8 49e9 5bb8 e8b4 bf'.replace(/ /g, ''),
+        'hex'));
+
+      assert.equal(new Buffer(decoder.decodeStr()).toString(), 'custom-value');
+    });
+
+    it('should decode literal from (C.6.1) #1', function() {
+      decoder.push(new Buffer(
+        ('96' +
+            'd07a be94 1054 d444 a820 0595 040b 8166' +
+            'e082 a62d 1bff').replace(/ /g, ''),
+        'hex'));
+
+      assert.equal(new Buffer(decoder.decodeStr()).toString(),
+                   'Mon, 21 Oct 2013 20:13:21 GMT');
+    });
+
+    it('should decode literal from (C.6.1) #2', function() {
+      decoder.push(new Buffer(
+        ('91' +
+            '9d29 ad17 1863 c78f 0b97 c8e9 ae82 ae43' +
+            'd3').replace(/ /g, ''),
+        'hex'));
+      assert.equal(new Buffer(decoder.decodeStr()).toString(),
+                   'https://www.example.com');
+    });
+
+    it('should decode many 5 bit chars', function() {
+      // e = 00101, 0x294A5294A5 = 00101 x 8
+      decoder.push(new Buffer('85294A5294A5', 'hex'));
+      assert.equal(new Buffer(decoder.decodeStr()).toString(), 'eeeeeeee');
+    });
+
+    it('should decode many 5 bit chars with 3-bit EOS', function() {
+      // e = 00101, EOS=111,
+      // 0x294A5294A52F = 00101 x 9 + 111
+      decoder.push(new Buffer('86294A5294A52F', 'hex'));
+      assert.equal(new Buffer(decoder.decodeStr()).toString(), 'eeeeeeeee');
+    });
+
+    it('should decode many 5 bit chars with 2-bit EOS', function() {
+      // e = 00101, EOS=11,
+      // 0x294A5297 = 00101 x 6 + 11
+      decoder.push(new Buffer('84294A5297', 'hex'));
+      assert.equal(new Buffer(decoder.decodeStr()).toString(), 'eeeeee');
+    });
+
+    it('should decode many multi-octet chars', function() {
+      decoder.push(new Buffer(
+          '97ffffb1ffff63fffec7fffd8ffffb1ffff63fffec7fffd8',
+          'hex'));
+      assert.deepEqual(decoder.decodeStr(), [
+        1, 1, 1, 1, 1, 1, 1, 1
+      ]);
+    });
+
+    it('should fail on 8 bit EOS', function() {
+      // e = 00101, 0x294A5294A5 = 00101 x 8
+      decoder.push(new Buffer('86294A5294A5ff', 'hex'));
+      assert.throws(function() {
+        decoder.decodeStr();
+      });
+    });
+
+    it('should fail on invalid 2-bit EOS', function() {
+      // e = 00101, EOS=10,
+      // 0x294A5297 = 00101 x 6 + 11
+      decoder.push(new Buffer('84294A5296', 'hex'));
+      assert.throws(function() {
+        decoder.decodeStr();
+      });
+    });
+  });
+});