maxmind 2.10.0 → 2.12.0

package/test/decoder.js

@@ -1,78 +0,0 @@
-'use strict';
-
-var assert = require('assert');
-var fs = require('fs');
-var path = require('path');
-var Decoder = require('../lib/decoder');
-
-
-describe('lib/decoder', function() {
-
-  var decoder = new Decoder(
-    fs.readFileSync(path.join(__dirname, 'data/test-data/GeoIP2-City-Test.mmdb')),
-    1
-  );
-
-  describe('decodeByType()', function() {
-    it('should fail for unknown type', function() {
-      assert.throws(function() {
-        decoder.decodeByType('kraken');
-      }, /Unknown type/);
-    });
-  });
-
-  describe('decodeUint()', function() {
-    it('should return zero for unsupported int size', function() {
-      assert.equal(decoder.decodeUint(1, 32), 0);
-    });
-  });
-
-  describe('decode()', function() {
-    it('should throw when extended type has wrong size', function() {
-      var test = new Decoder(new Buffer([0x00, 0x00]));
-      assert.throws(function() {
-        test.decode(0);
-      }, /Invalid Extended Type at offset 1 val 7/);
-    });
-  });
-
-  describe('sizeFromCtrlByte()', function() {
-    var decoder = new Decoder(new Buffer([0x01, 0x02, 0x03, 0x04]));
-
-    it('should return correct value (size <29)', function() {
-      assert.deepEqual(decoder.sizeFromCtrlByte(60, 0), { value: 28, offset: 0 });
-    });
-
-    it('should return correct value (size = 29)', function() {
-      assert.deepEqual(decoder.sizeFromCtrlByte(61, 0), { value: 30, offset: 1 });
-    });
-
-    it('should return correct value (size = 30)', function() {
-      assert.deepEqual(decoder.sizeFromCtrlByte(62, 0), { value: 543, offset: 2 });
-    });
-
-    it('should return correct value (size = 31)', function() {
-      assert.deepEqual(decoder.sizeFromCtrlByte(63, 0), { value: 131872, offset: 3 });
-    });
-  });
-
-  describe('decodePointer()', function() {
-    var decoder = new Decoder(new Buffer([0x01, 0x02, 0x03, 0x04]));
-
-    it('should return correct value (pointer size = 0)', function() {
-      assert.deepEqual(decoder.decodePointer(39, 0), { value: 1793, offset: 1 });
-    });
-
-    it('should return correct value (pointer size = 1)', function() {
-      assert.deepEqual(decoder.decodePointer(45, 0), { value: 329986, offset: 2 });
-    });
-
-    it('should return correct value (pointer size = 2)', function() {
-      assert.deepEqual(decoder.decodePointer(48, 0), { value: 592387, offset: 3 });
-    });
-
-    it('should return correct value (pointer size = 3)', function() {
-      assert.deepEqual(decoder.decodePointer(56, 0), { value: 16909060, offset: 4 });
-    });
-  });
-});

package/test/e2e.js

@@ -1,146 +0,0 @@
-'use strict';
-
-var path = require('path');
-var assert = require('assert');
-var maxmind = require('../index');
-var ipaddr = require('ip-address');
-
-
-var actual = function(file) {
-  var data = require('./data/source-data/' + file);
-  var hash = {};
-  data.forEach(function(item) {
-    for (var key in item)
-      hash[key] = item[key];
-  });
-
-  return {
-    hash: hash,
-    get: function(subnet) {
-      var item = hash[subnet];
-      assert(item);
-      return item;
-    }
-  };
-};
-
-describe('maxmind', function() {
-
-  var dataDir = path.join(__dirname, 'data/test-data');
-
-  describe('basic functionality', function() {
-
-    it('should successfully handle database', function() {
-      assert(maxmind.openSync(path.join(dataDir, 'GeoIP2-City-Test.mmdb')));
-    });
-
-    it('should fetch geo ip', function() {
-      var geoIp = maxmind.openSync(path.join(dataDir, 'GeoIP2-City-Test.mmdb'));
-      var data = actual('GeoIP2-City-Test.json');
-      assert.deepEqual(geoIp.get('1.1.1.1'), null);
-
-      assert.deepEqual(geoIp.get('175.16.198.255'), null);
-      assert.deepEqual(geoIp.get('175.16.199.1'), data.get('::175.16.199.0/120'));
-      assert.deepEqual(geoIp.get('175.16.199.255'), data.get('::175.16.199.0/120'));
-      assert.deepEqual(geoIp.get('::175.16.199.255'), data.get('::175.16.199.0/120'));
-      assert.deepEqual(geoIp.get('175.16.200.1'), null);
-
-      assert.deepEqual(geoIp.get('2a02:cf40:ffff::'), data.get('2a02:cf40::/29'));
-      assert.deepEqual(geoIp.get('2a02:cf47:0000::'), data.get('2a02:cf40::/29'));
-      assert.deepEqual(geoIp.get('2a02:cf48:0000::'), null);
-    });
-
-    it('should handle corrupt database', function() {
-      assert.throws(function verify() {
-        maxmind.openSync('./data/README.md');
-      });
-    });
-
-    it('should accept cache options', function() {
-      assert(maxmind.openSync(path.join(dataDir, 'GeoIP2-City-Test.mmdb'), {
-        cache: { max: 1000 }
-      }));
-    });
-  });
-
-  describe('section: data', function() {
-    it('should decode all possible types - complex', function() {
-      var geoIp = maxmind.openSync(path.join(dataDir, 'MaxMind-DB-test-decoder.mmdb'));
-      assert.deepEqual(geoIp.get('::1.1.1.1'), {
-        array: [1, 2, 3],
-        boolean: true,
-        bytes: new Buffer([0, 0, 0, 42]),
-        double: 42.123456,
-        // It should be 1.1, but there's some issue with rounding in v8
-        float: 1.100000023841858,
-        int32: -268435456,
-        map: { mapX: { arrayX: [7, 8, 9], utf8_stringX: 'hello' } },
-        uint128: '1329227995784915872903807060280344576',
-        uint16: 100,
-        uint32: 268435456,
-        uint64: '1152921504606846976',
-        utf8_string: 'unicode! ☯ - ♫'
-      });
-    });
-
-    it('should decode all possible types - zero/empty values', function() {
-      var geoIp = maxmind.openSync(path.join(dataDir, 'MaxMind-DB-test-decoder.mmdb'));
-      assert.deepEqual(geoIp.get('::0.0.0.0'), {
-        array: [],
-        boolean: false,
-        bytes: new Buffer([]),
-        double: 0,
-        float: 0,
-        int32: 0,
-        map: {},
-        uint128: '0',
-        uint16: 0,
-        uint32: 0,
-        uint64: '0',
-        utf8_string: ''
-      });
-    });
-
-    it('should return correct value: string entries', function() {
-      var geoIp = maxmind.openSync(path.join(dataDir, 'MaxMind-DB-string-value-entries.mmdb'));
-      assert.equal(geoIp.get('1.1.1.1'), '1.1.1.1/32');
-      assert.equal(geoIp.get('1.1.1.2'), '1.1.1.2/31');
-      assert.equal(geoIp.get('175.2.1.1'), null);
-    });
-  });
-
-  describe('section: binary search tree', function() {
-
-    var files = [
-      'GeoIP2-Anonymous-IP-Test',
-      'GeoIP2-City-Test',
-      'GeoIP2-Connection-Type-Test',
-      'GeoIP2-Country-Test',
-      'GeoIP2-Domain-Test',
-      'GeoIP2-Enterprise-Test',
-      'GeoIP2-ISP-Test',
-      'GeoIP2-Precision-City-Test',
-      'GeoIP2-Precision-ISP-Test'
-    ];
-
-    var tester = function(geoIp, data) {
-      for (var subnet in data.hash) {
-        var ip = new ipaddr.Address6(subnet);
-        // TODO: check random address from the subnet?
-        // see http://ip-address.js.org/#address4/biginteger
-        // see https://github.com/andyperlitch/jsbn
-        assert.deepEqual(geoIp.get(ip.startAddress().address), data.hash[subnet], subnet);
-        assert.deepEqual(geoIp.get(ip.endAddress().address), data.hash[subnet], subnet);
-      }
-    };
-
-    files.forEach(function(file) {
-      it('should test everything: ' + file, function() {
-        var geoIp = maxmind.openSync(path.join(dataDir, '/' + file + '.mmdb'));
-        var data = actual(file + '.json');
-        tester(geoIp, data);
-      });
-    });
-  });
-
-});

package/test/index.js

@@ -1,176 +0,0 @@
-'use strict';
-
-var sinon = require('sinon');
-var assert = require('assert');
-var path = require('path');
-var fs = require('fs');
-var maxmind = require('../index');
-var Reader = require('../lib/reader');
-
-describe('index', function() {
-  var dataDir = path.join(__dirname, 'data/test-data');
-  var dbPath = path.join(dataDir, 'GeoIP2-City-Test.mmdb');
-
-  var sandbox;
-  var watchHandler;
-  beforeEach(function() {
-    sandbox = sinon.createSandbox();
-    sandbox.stub(fs, 'watch').callsFake(function(path, options, cb) { watchHandler = cb; });
-    sandbox.spy(fs, 'readFile');
-    sandbox.spy(fs, 'readFileSync');
-  });
-  afterEach(function() { sandbox.restore(); });
-
-
-  describe('validate()', function() {
-    it('should work fine for both IPv4 and IPv6', function() {
-      assert.equal(maxmind.validate('64.4.4.4'), true);
-      assert.equal(maxmind.validate('2001:4860:0:1001::3004:ef68'), true);
-      assert.equal(maxmind.validate('whhaaaazza'), false);
-    });
-  });
-
-  describe('init()', function() {
-    it('should fail when someone tries to use legacy api', function() {
-      assert.throws(function() {
-        maxmind.init();
-      }, /Maxmind v1 module has changed API/);
-    });
-  });
-
-  describe('open()', function() {
-    it('should work with most basic usage', function(done) {
-      maxmind.open(dbPath, function(err, lookup) {
-        if (err) return done(err);
-        assert(lookup.get('2001:230::'));
-        done();
-      });
-    });
-
-    it('should successfully handle database, with opts', function(done) {
-      var options = { cache: { max: 1000 }, watchForUpdates: true };
-      maxmind.open(dbPath, options, function(err, lookup) {
-        if (err) return done(err);
-        assert(lookup.get('2001:230::'));
-        assert(fs.watch.calledOnce);
-        assert(fs.readFile.calledOnce);
-        done();
-      });
-    });
-
-    it('should work with auto updates', function(done) {
-      var options = { watchForUpdates: true };
-      maxmind.open(dbPath, options, function(err, lookup) {
-        if (err) return done(err);
-        assert(lookup.get('2001:230::'));
-        assert(fs.watch.calledOnce);
-        assert(fs.readFile.calledOnce);
-        watchHandler();
-        assert(fs.readFile.calledTwice);
-        done();
-      });
-    });
-
-    it('should work with auto updates and call specified hook', function(done) {
-      var hook = sinon.spy();
-      var options = {
-        watchForUpdates: true,
-        watchForUpdatesHook: hook,
-        watchForUpdatesNonPersistent: false,
-      };
-      maxmind.open(dbPath, options, function(err, lookup) {
-        if (err) return done(err);
-        assert(lookup.get('2001:230::'));
-        assert(hook.notCalled);
-        watchHandler();
-        assert(hook.calledOnce);
-        done();
-      });
-    });
-
-    it('should successfully handle errors while opening a db', function(done) {
-      maxmind.open('/foo/bar', function(err) {
-        assert.equal(err.code, 'ENOENT');
-        done();
-      });
-    });
-
-    it('should throw an error when no callback provided', function() {
-      assert.throws(function() {
-        maxmind.open(dbPath);
-      }, /Callback function must be provided/);
-    });
-
-    it('should return an error when gzip file attempted', function(done) {
-      var dbPath = path.join(__dirname, 'databases/GeoIP2-City-Test.mmdb.gz');
-      maxmind.open(dbPath, function(err) {
-        assert.equal(err.message,
-          'Looks like you are passing in a file in gzip format, please use mmdb database instead.');
-        done();
-      });
-    });
-
-    it('should check for an error when cannot read database on update', function(done) {
-      var counter = 0;
-      var cb = function(err, reader) {
-        // Indeed couter is kinda gross.
-        switch (counter++) {
-          case 0:
-            assert.equal(err, null);
-            assert(reader instanceof Reader);
-            assert(fs.readFile.calledOnce);
-            fs.readFile.restore();
-            sandbox.stub(fs, 'readFile').callsFake(function(path, cb) { cb(new Error('Crazy shit')); });
-            watchHandler();
-            break;
-
-          case 1:
-            assert.equal(err.message, 'Crazy shit');
-            done();
-            break;
-
-          default:
-            done(new Error('Only two calls should happen'));
-        }
-      };
-      maxmind.open(dbPath, { watchForUpdates: true }, cb);
-    });
-
-    it('should handler reader errors', function(done) {
-      maxmind.open(path.join(__dirname, 'databases/broken.dat'), function(err) {
-        assert.equal(err.message, 'Cannot parse binary database');
-        done();
-      });
-    });
-  });
-
-  describe('openSync()', function() {
-    it('should successfully handle database', function() {
-      var lookup = maxmind.openSync(dbPath);
-      assert(lookup.get('2001:230::'));
-    });
-
-    it('should successfully handle database updates', function() {
-      var lookup = maxmind.openSync(dbPath, { watchForUpdates: true });
-      assert(lookup.get('2001:230::'));
-      assert(fs.watch.calledOnce);
-      assert(fs.readFileSync.calledOnce);
-      watchHandler();
-      assert(fs.readFileSync.calledTwice);
-    });
-
-    it('should successfully handle database updates and call specified hook', function() {
-      var hook = sinon.spy();
-      var opts = {
-        watchForUpdates: true,
-        watchForUpdatesHook: hook,
-      };
-      var lookup = maxmind.openSync(dbPath, opts);
-      assert(lookup.get('2001:230::'));
-      assert(hook.notCalled);
-      watchHandler();
-      assert(hook.calledOnce);
-    });
-
-  });
-});

package/test/ip.js

@@ -1,89 +0,0 @@
-'use strict';
-
-var assert = require('assert');
-var ip = require('../lib/ip');
-
-
-describe('lib/ip', function() {
-
-  describe('parse()', function() {
-    describe('ipv4', function() {
-      it('should successfully parse v4', function() {
-        assert.deepEqual(ip.parse('127.0.0.1'), [0x7f, 0x00, 0x00, 0x01]);
-        assert.deepEqual(ip.parse('10.10.200.59'), [0x0a, 0x0a, 0xc8, 0x3b]);
-      });
-    });
-
-    describe('ipv6', function() {
-      it('should parse complete address', function() {
-        assert.deepEqual(
-          ip.parse('2001:0db8:85a3:0042:1000:8a2e:0370:7334'),
-          [0x20, 0x1, 0xd, 0xb8, 0x85, 0xa3, 0, 0x42, 0x10, 0, 0x8a, 0x2e, 0x03, 0x70, 0x73, 0x34]
-        );
-        assert.deepEqual(
-          ip.parse('2001:0db8:85a3:0000:0000:8a2e:0370:7334'),
-          [0x20, 0x01, 0x0d, 0xb8, 0x85, 0xa3, 0x00, 0x00, 0x00, 0x00, 0x8a, 0x2e, 0x03, 0x70, 0x73, 0x34]
-        );
-      });
-
-      it('should parse two-part address', function() {
-        assert.deepEqual(
-          ip.parse('2001:4860:0:1001::3004:ef68'),
-          [0x20, 0x01, 0x48, 0x60, 0, 0, 0x10, 0x01, 0, 0, 0, 0, 0x30, 0x04, 0xef, 0x68]
-        );
-        assert.deepEqual(
-          ip.parse('2001:db8:85a3::8a2e:370:7334'),
-          [0x20, 0x01, 0x0d, 0xb8, 0x85, 0xa3, 0x00, 0x00, 0x00, 0x00, 0x8a, 0x2e, 0x03, 0x70, 0x73, 0x34]
-        );
-      });
-
-      it('should parse `::` in the end of address', function() {
-        var expected = [0x20, 0x01, 0x02, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
-        assert.deepEqual(ip.parse('2001:200::'), expected);
-        assert.deepEqual(ip.parse('2001:0200:0000:0000:0000:0000:0000:0000'), expected);
-      });
-
-      it('should parse ipv4 with `::ffff`', function() {
-        var expected = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 1, 2, 254, 216];
-        assert.deepEqual(ip.parse('::ffff:1.2.254.216'), expected);
-        assert.deepEqual(ip.parse('::ffff:0102:fed8'), expected);
-        assert.deepEqual(ip.parse('::ffff:102:fed8'), expected);
-        assert.deepEqual(ip.parse('0000:0000:0000:0000:0000:ffff:0102:fed8'), expected);
-        assert.deepEqual(ip.parse('0000:0000:0000:0000:0000:ffff:102:fed8'), expected);
-      });
-
-      it('should parse ipv4 with `::`', function() {
-        var expected = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 17, 254, 216];
-        assert.deepEqual(ip.parse('::64.17.254.216'), expected);
-        assert.deepEqual(ip.parse('::4011:fed8'), expected);
-        assert.deepEqual(ip.parse('0000:0000:0000:0000:0000:0000:4011:fed8'), expected);
-      });
-    });
-  });
-
-  describe('bitAt()', function() {
-    it('should return correct bit for given offset', function() {
-      var address = new Buffer([0x0a, 0x0a, 0xc8, 0x3b]);
-      assert.strictEqual(ip.bitAt(address, 1), 0);
-      assert.strictEqual(ip.bitAt(address, 10), 0);
-      assert.strictEqual(ip.bitAt(address, 23), 0);
-      assert.strictEqual(ip.bitAt(address, 31), 1);
-      assert.strictEqual(ip.bitAt(address, 999), 0);
-    });
-  });
-
-  describe('validate()', function() {
-    it('should work fine for IPv4', function() {
-      assert.equal(ip.validate('64.4.4.4'), true);
-      assert.equal(ip.validate('64.4.4.boom!'), false);
-      assert.equal(ip.validate(undefined), false);
-      assert.equal(ip.validate('kraken'), false);
-    });
-
-    it('should work fine for IPv6', function() {
-      assert.equal(ip.validate('2001:4860:0:1001::3004:ef68'), true);
-      assert.equal(ip.validate('::64.17.254.216'), true);
-      assert.equal(ip.validate('2001:4860:0:1001::3004:boom!'), false);
-    });
-  });
-});

package/test/is-gzip.js

@@ -1,21 +0,0 @@
-'use strict';
-
-var assert = require('assert');
-var isGzip = require('../lib/is-gzip');
-
-describe('lib/is-gzip', function() {
-  it('should return false for short buffers', function() {
-    assert.equal(isGzip(new Buffer([1, 2])), false);
-  });
-
-  it('should return false for string buffer', function() {
-    assert.equal(isGzip(new Buffer('kraken')), false);
-  });
-
-  it('should return false for string buffer', function() {
-    // gzipped "kraken" string
-    // shell: `echo "kraken" | gzip | base64`
-    var buffer = new Buffer('H4sIAGBDv1gAA8suSsxOzeMCAKjj9U8HAAAA', 'base64');
-    assert.equal(isGzip(buffer), true);
-  });
-});

package/test/reader.js

@@ -1,124 +0,0 @@
-'use strict';
-
-var fs = require('fs');
-var path = require('path');
-var assert = require('assert');
-var Reader = require('../lib/reader');
-
-
-describe('lib/reader', function() {
-
-  var dataDir = path.join(__dirname, 'data/test-data');
-  var read = function(dir, filepath) {
-    return fs.readFileSync(path.join(dir, filepath));
-  };
-
-  describe('findAddressInTree()', function() {
-
-    it('should work for most basic case', function() {
-      var reader = new Reader(read(dataDir, 'GeoIP2-City-Test.mmdb'));
-      assert.equal(reader.findAddressInTree('1.1.1.1'), null);
-    });
-
-    it('should return correct value: city database', function() {
-      var reader = new Reader(read(dataDir, 'GeoIP2-City-Test.mmdb'));
-      assert.equal(reader.findAddressInTree('1.1.1.1'), null);
-      assert.equal(reader.findAddressInTree('175.16.199.1'), 3042);
-      assert.equal(reader.findAddressInTree('175.16.199.88'), 3042);
-      assert.equal(reader.findAddressInTree('175.16.199.255'), 3042);
-      assert.equal(reader.findAddressInTree('::175.16.199.255'), 3042);
-      assert.equal(reader.findAddressInTree('::ffff:175.16.199.255'), 3042);
-      assert.equal(reader.findAddressInTree('2a02:cf40:ffff::'), 4735);
-      assert.equal(reader.findAddressInTree('2a02:cf47:0000::'), 4735);
-      assert.equal(reader.findAddressInTree('2a02:cf47:0000:fff0:ffff::'), 4735);
-      assert.equal(reader.findAddressInTree('2a02:cf48:0000::'), null);
-    });
-
-    it('should return correct value: string entries', function() {
-      var reader = new Reader(read(dataDir, 'MaxMind-DB-string-value-entries.mmdb'));
-      assert.equal(reader.findAddressInTree('1.1.1.1'), 98);
-      assert.equal(reader.findAddressInTree('1.1.1.2'), 87);
-      assert.equal(reader.findAddressInTree('175.2.1.1'), null);
-    });
-
-    describe('various record sizes and ip versions', function() {
-      var ips = {
-        v4: {
-          '1.1.1.1': 102,
-          '1.1.1.2': 90,
-          '1.1.1.32': 114,
-          '1.1.1.33': null
-        },
-        v6: {
-          '::1:ffff:fffa': null,
-          '::1:ffff:ffff': 176,
-          '::2:0000:0000': 194,
-          '::2:0000:0060': null
-        },
-        mix: {
-          '1.1.1.1': 315,
-          '1.1.1.2': 301,
-          '1.1.1.32': 329,
-          '1.1.1.33': null,
-          '::1:ffff:fffa': null,
-          '::1:ffff:ffff': 344,
-          '::2:0000:0000': 362,
-          '::2:0000:0060': null
-        }
-      };
-
-      var scenarios = {
-        'MaxMind-DB-test-ipv4-24.mmdb': ips.v4,
-        'MaxMind-DB-test-ipv4-28.mmdb': ips.v4,
-        'MaxMind-DB-test-ipv4-32.mmdb': ips.v4,
-        'MaxMind-DB-test-ipv6-24.mmdb': ips.v6,
-        'MaxMind-DB-test-ipv6-28.mmdb': ips.v6,
-        'MaxMind-DB-test-ipv6-32.mmdb': ips.v6,
-        'MaxMind-DB-test-mixed-24.mmdb': ips.mix,
-        'MaxMind-DB-test-mixed-28.mmdb': ips.mix,
-        'MaxMind-DB-test-mixed-32.mmdb': ips.mix
-      };
-
-      for (var file in scenarios) {
-        (function(file, ips) {
-          it('should return correct value: ' + file, function() {
-            var reader = new Reader(read(dataDir, '' + file));
-            for (var ip in ips) {
-              assert.equal(reader.findAddressInTree(ip), ips[ip], 'IP: ' + ip);
-            }
-          });
-        })(file, scenarios[file]);
-      }
-    });
-
-    describe('broken files and search trees', function() {
-      it('should behave fine when there is no  ipv4 search tree', function() {
-        var reader = new Reader(read(dataDir, 'MaxMind-DB-no-ipv4-search-tree.mmdb'));
-        assert.equal(reader.findAddressInTree('::1:ffff:ffff'), 80);
-        // TODO: perhaps null should be returned here, note that pointer is larger than file itself
-        assert.equal(reader.findAddressInTree('1.1.1.1'), 4811873);
-      });
-
-      it('should behave fine when search tree is broken', function() {
-        // TODO: find out in what way the file is broken
-        var reader = new Reader(read(dataDir, 'MaxMind-DB-test-broken-search-tree-24.mmdb'));
-        assert.equal(reader.findAddressInTree('1.1.1.1'), 102);
-        assert.equal(reader.findAddressInTree('1.1.1.2'), 90);
-      });
-    });
-
-    describe('invalid database format', function() {
-      it('should provide meaningful message when one tries to use legacy db', function() {
-        assert.throws(function() {
-          new Reader(read(path.join(__dirname, 'databases'), 'legacy.dat'));
-        }, /Maxmind v1 module has changed API/);
-      });
-
-      it('should provide meaningful message when one tries to use unknown format', function() {
-        assert.throws(function() {
-          new Reader(read(path.join(__dirname, 'databases'), 'broken.dat'));
-        }, /Cannot parse binary database/);
-      });
-    });
-  });
-});