esri-gl 1.0.0 → 1.0.2

package/dist/index.umd.js

@@ -1,27 +1,8 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@mapbox/tilebelt'), require('arcgis-pbf-parser')) :
-    typeof define === 'function' && define.amd ? define(['exports', '@mapbox/tilebelt', 'arcgis-pbf-parser'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.esrigl = {}, global.tilebelt, global.arcgisPbfParser));
-})(this, (function (exports, tilebelt, tileDecode) { 'use strict';
-
-    function _interopNamespaceDefault(e) {
-        var n = Object.create(null);
-        if (e) {
-            Object.keys(e).forEach(function (k) {
-                if (k !== 'default') {
-                    var d = Object.getOwnPropertyDescriptor(e, k);
-                    Object.defineProperty(n, k, d.get ? d : {
-                        enumerable: true,
-                        get: function () { return e[k]; }
-                    });
-                }
-            });
-        }
-        n.default = e;
-        return Object.freeze(n);
-    }
-
-    var tilebelt__namespace = /*#__PURE__*/_interopNamespaceDefault(tilebelt);
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.esrigl = {}));
+})(this, (function (exports) { 'use strict';
 
     function cleanTrailingSlash(url) {
       return url.replace(/\/$/, '');
@@ -631,6 +612,7 @@
           bboxSR: '3857',
           imageSR: '3857',
           format: this.options.format,
+          dpi: this.options.dpi.toString(),
           layers: this._layersStr || '',
           transparent: this.options.transparent.toString(),
           size: `${tileSize},${tileSize}`,
@@ -924,7 +906,7 @@
           }),
           tolerance: '3',
           returnGeometry: returnGeometry.toString(),
-          imageDisplay: `${canvas.width},${canvas.height},96`,
+          imageDisplay: `${canvas.width},${canvas.height},${this.options.dpi}`,
           mapExtent: `${bounds[0][0]},${bounds[0][1]},${bounds[1][0]},${bounds[1][1]}`,
           layers: this._layersStrIdentify || '',
           f: 'json'
@@ -1572,6 +1554,7 @@
           bboxSR: '3857',
           imageSR: '3857',
           format: this.options.format,
+          dpi: this.options.dpi.toString(),
           size: `${tileSize},${tileSize}`,
           f: 'image'
         });
@@ -1669,7 +1652,7 @@
           }),
           tolerance: '3',
           returnGeometry: returnGeometry.toString(),
-          imageDisplay: `${canvas.width},${canvas.height},96`,
+          imageDisplay: `${canvas.width},${canvas.height},${this.options.dpi}`,
           mapExtent: `${bounds[0][0]},${bounds[0][1]},${bounds[1][0]},${bounds[1][1]}`,
           f: 'json'
         });
@@ -2094,6 +2077,1642 @@
       }
     }
 
+    const d2r = Math.PI / 180;
+    const r2d = 180 / Math.PI;
+    function tile2lon(x, z) {
+        return (x / Math.pow(2, z)) * 360 - 180;
+    }
+    function tile2lat(y, z) {
+        const n = Math.PI - (2 * Math.PI * y) / Math.pow(2, z);
+        return r2d * Math.atan(0.5 * (Math.exp(n) - Math.exp(-n)));
+    }
+    /**
+     * Get the bbox of a tile
+     *
+     * const bbox = tileToBBOX([5, 10, 10])
+     * //=bbox
+     */
+    function tileToBBOX(tile) {
+        const e = tile2lon(tile[0] + 1, tile[2]);
+        const w = tile2lon(tile[0], tile[2]);
+        const s = tile2lat(tile[1] + 1, tile[2]);
+        const n = tile2lat(tile[1], tile[2]);
+        return [w, s, e, n];
+    }
+    /**
+     * Get the tile for a point at a specified zoom level
+     *
+     * const tile = pointToTile(1, 1, 20)
+     * //=tile
+     */
+    function pointToTile(lon, lat, z) {
+        const tile = pointToTileFraction(lon, lat, z);
+        tile[0] = Math.floor(tile[0]);
+        tile[1] = Math.floor(tile[1]);
+        return tile;
+    }
+    /**
+     * Get the precise fractional tile location for a point at a zoom level
+     *
+     * const tile = pointToTileFraction(30.5, 50.5, 15)
+     * //=tile
+     */
+    function pointToTileFraction(lon, lat, z) {
+        const sin = Math.sin(lat * d2r);
+        const z2 = Math.pow(2, z);
+        let x = z2 * (lon / 360 + 0.5);
+        const y = z2 * (0.5 - (0.25 * Math.log((1 + sin) / (1 - sin))) / Math.PI);
+        // Wrap Tile X
+        x = x % z2;
+        if (x < 0)
+            x = x + z2;
+        return [x, y, z];
+    }
+    /**
+     * Get the 4 tiles one zoom level higher
+     *
+     * const tiles = getChildren([5, 10, 10])
+     * //=tiles
+     */
+    function getChildren(tile) {
+        return [
+            [tile[0] * 2, tile[1] * 2, tile[2] + 1],
+            [tile[0] * 2 + 1, tile[1] * 2, tile[2] + 1],
+            [tile[0] * 2 + 1, tile[1] * 2 + 1, tile[2] + 1],
+            [tile[0] * 2, tile[1] * 2 + 1, tile[2] + 1],
+        ];
+    }
+    /**
+     * Get the quadkey for a tile
+     *
+     * const quadkey = tileToQuadkey([0, 1, 5])
+     * //=quadkey
+     */
+    function tileToQuadkey(tile) {
+        let index = '';
+        for (let z = tile[2]; z > 0; z--) {
+            let b = 0;
+            const mask = 1 << (z - 1);
+            if ((tile[0] & mask) !== 0)
+                b++;
+            if ((tile[1] & mask) !== 0)
+                b += 2;
+            index += b.toString();
+        }
+        return index;
+    }
+    function getBboxZoom(bbox) {
+        const MAX_ZOOM = 28;
+        for (let z = 0; z < MAX_ZOOM; z++) {
+            const mask = 1 << (32 - (z + 1));
+            if ((bbox[0] & mask) !== (bbox[2] & mask) ||
+                (bbox[1] & mask) !== (bbox[3] & mask)) {
+                return z;
+            }
+        }
+        return MAX_ZOOM;
+    }
+    /**
+     * Get the smallest tile to cover a bbox
+     *
+     * const tile = bboxToTile([ -178, 84, -177, 85 ])
+     * //=tile
+     */
+    function bboxToTile(bboxCoords) {
+        const min = pointToTile(bboxCoords[0], bboxCoords[1], 32);
+        const max = pointToTile(bboxCoords[2], bboxCoords[3], 32);
+        const bbox = [min[0], min[1], max[0], max[1]];
+        const z = getBboxZoom(bbox);
+        if (z === 0)
+            return [0, 0, 0];
+        const x = bbox[0] >>> (32 - z);
+        const y = bbox[1] >>> (32 - z);
+        return [x, y, z];
+    }
+
+    function getDefaultExportFromCjs (x) {
+    	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+    }
+
+    var ieee754 = {};
+
+    /*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
+
+    var hasRequiredIeee754;
+
+    function requireIeee754 () {
+    	if (hasRequiredIeee754) return ieee754;
+    	hasRequiredIeee754 = 1;
+    	ieee754.read = function (buffer, offset, isLE, mLen, nBytes) {
+    	  var e, m;
+    	  var eLen = (nBytes * 8) - mLen - 1;
+    	  var eMax = (1 << eLen) - 1;
+    	  var eBias = eMax >> 1;
+    	  var nBits = -7;
+    	  var i = isLE ? (nBytes - 1) : 0;
+    	  var d = isLE ? -1 : 1;
+    	  var s = buffer[offset + i];
+
+    	  i += d;
+
+    	  e = s & ((1 << (-nBits)) - 1);
+    	  s >>= (-nBits);
+    	  nBits += eLen;
+    	  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}
+
+    	  m = e & ((1 << (-nBits)) - 1);
+    	  e >>= (-nBits);
+    	  nBits += mLen;
+    	  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}
+
+    	  if (e === 0) {
+    	    e = 1 - eBias;
+    	  } else if (e === eMax) {
+    	    return m ? NaN : ((s ? -1 : 1) * Infinity)
+    	  } else {
+    	    m = m + Math.pow(2, mLen);
+    	    e = e - eBias;
+    	  }
+    	  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
+    	};
+
+    	ieee754.write = function (buffer, value, offset, isLE, mLen, nBytes) {
+    	  var e, m, c;
+    	  var eLen = (nBytes * 8) - mLen - 1;
+    	  var eMax = (1 << eLen) - 1;
+    	  var eBias = eMax >> 1;
+    	  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0);
+    	  var i = isLE ? 0 : (nBytes - 1);
+    	  var d = isLE ? 1 : -1;
+    	  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;
+
+    	  value = Math.abs(value);
+
+    	  if (isNaN(value) || value === Infinity) {
+    	    m = isNaN(value) ? 1 : 0;
+    	    e = eMax;
+    	  } else {
+    	    e = Math.floor(Math.log(value) / Math.LN2);
+    	    if (value * (c = Math.pow(2, -e)) < 1) {
+    	      e--;
+    	      c *= 2;
+    	    }
+    	    if (e + eBias >= 1) {
+    	      value += rt / c;
+    	    } else {
+    	      value += rt * Math.pow(2, 1 - eBias);
+    	    }
+    	    if (value * c >= 2) {
+    	      e++;
+    	      c /= 2;
+    	    }
+
+    	    if (e + eBias >= eMax) {
+    	      m = 0;
+    	      e = eMax;
+    	    } else if (e + eBias >= 1) {
+    	      m = ((value * c) - 1) * Math.pow(2, mLen);
+    	      e = e + eBias;
+    	    } else {
+    	      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
+    	      e = 0;
+    	    }
+    	  }
+
+    	  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}
+
+    	  e = (e << mLen) | m;
+    	  eLen += mLen;
+    	  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}
+
+    	  buffer[offset + i - d] |= s * 128;
+    	};
+    	return ieee754;
+    }
+
+    var pbf;
+    var hasRequiredPbf;
+
+    function requirePbf () {
+    	if (hasRequiredPbf) return pbf;
+    	hasRequiredPbf = 1;
+
+    	pbf = Pbf;
+
+    	var ieee754 = requireIeee754();
+
+    	function Pbf(buf) {
+    	    this.buf = ArrayBuffer.isView && ArrayBuffer.isView(buf) ? buf : new Uint8Array(buf || 0);
+    	    this.pos = 0;
+    	    this.type = 0;
+    	    this.length = this.buf.length;
+    	}
+
+    	Pbf.Varint  = 0; // varint: int32, int64, uint32, uint64, sint32, sint64, bool, enum
+    	Pbf.Fixed64 = 1; // 64-bit: double, fixed64, sfixed64
+    	Pbf.Bytes   = 2; // length-delimited: string, bytes, embedded messages, packed repeated fields
+    	Pbf.Fixed32 = 5; // 32-bit: float, fixed32, sfixed32
+
+    	var SHIFT_LEFT_32 = (1 << 16) * (1 << 16),
+    	    SHIFT_RIGHT_32 = 1 / SHIFT_LEFT_32;
+
+    	// Threshold chosen based on both benchmarking and knowledge about browser string
+    	// data structures (which currently switch structure types at 12 bytes or more)
+    	var TEXT_DECODER_MIN_LENGTH = 12;
+    	var utf8TextDecoder = typeof TextDecoder === 'undefined' ? null : new TextDecoder('utf-8');
+
+    	Pbf.prototype = {
+
+    	    destroy: function() {
+    	        this.buf = null;
+    	    },
+
+    	    // === READING =================================================================
+
+    	    readFields: function(readField, result, end) {
+    	        end = end || this.length;
+
+    	        while (this.pos < end) {
+    	            var val = this.readVarint(),
+    	                tag = val >> 3,
+    	                startPos = this.pos;
+
+    	            this.type = val & 0x7;
+    	            readField(tag, result, this);
+
+    	            if (this.pos === startPos) this.skip(val);
+    	        }
+    	        return result;
+    	    },
+
+    	    readMessage: function(readField, result) {
+    	        return this.readFields(readField, result, this.readVarint() + this.pos);
+    	    },
+
+    	    readFixed32: function() {
+    	        var val = readUInt32(this.buf, this.pos);
+    	        this.pos += 4;
+    	        return val;
+    	    },
+
+    	    readSFixed32: function() {
+    	        var val = readInt32(this.buf, this.pos);
+    	        this.pos += 4;
+    	        return val;
+    	    },
+
+    	    // 64-bit int handling is based on github.com/dpw/node-buffer-more-ints (MIT-licensed)
+
+    	    readFixed64: function() {
+    	        var val = readUInt32(this.buf, this.pos) + readUInt32(this.buf, this.pos + 4) * SHIFT_LEFT_32;
+    	        this.pos += 8;
+    	        return val;
+    	    },
+
+    	    readSFixed64: function() {
+    	        var val = readUInt32(this.buf, this.pos) + readInt32(this.buf, this.pos + 4) * SHIFT_LEFT_32;
+    	        this.pos += 8;
+    	        return val;
+    	    },
+
+    	    readFloat: function() {
+    	        var val = ieee754.read(this.buf, this.pos, true, 23, 4);
+    	        this.pos += 4;
+    	        return val;
+    	    },
+
+    	    readDouble: function() {
+    	        var val = ieee754.read(this.buf, this.pos, true, 52, 8);
+    	        this.pos += 8;
+    	        return val;
+    	    },
+
+    	    readVarint: function(isSigned) {
+    	        var buf = this.buf,
+    	            val, b;
+
+    	        b = buf[this.pos++]; val  =  b & 0x7f;        if (b < 0x80) return val;
+    	        b = buf[this.pos++]; val |= (b & 0x7f) << 7;  if (b < 0x80) return val;
+    	        b = buf[this.pos++]; val |= (b & 0x7f) << 14; if (b < 0x80) return val;
+    	        b = buf[this.pos++]; val |= (b & 0x7f) << 21; if (b < 0x80) return val;
+    	        b = buf[this.pos];   val |= (b & 0x0f) << 28;
+
+    	        return readVarintRemainder(val, isSigned, this);
+    	    },
+
+    	    readVarint64: function() { // for compatibility with v2.0.1
+    	        return this.readVarint(true);
+    	    },
+
+    	    readSVarint: function() {
+    	        var num = this.readVarint();
+    	        return num % 2 === 1 ? (num + 1) / -2 : num / 2; // zigzag encoding
+    	    },
+
+    	    readBoolean: function() {
+    	        return Boolean(this.readVarint());
+    	    },
+
+    	    readString: function() {
+    	        var end = this.readVarint() + this.pos;
+    	        var pos = this.pos;
+    	        this.pos = end;
+
+    	        if (end - pos >= TEXT_DECODER_MIN_LENGTH && utf8TextDecoder) {
+    	            // longer strings are fast with the built-in browser TextDecoder API
+    	            return readUtf8TextDecoder(this.buf, pos, end);
+    	        }
+    	        // short strings are fast with our custom implementation
+    	        return readUtf8(this.buf, pos, end);
+    	    },
+
+    	    readBytes: function() {
+    	        var end = this.readVarint() + this.pos,
+    	            buffer = this.buf.subarray(this.pos, end);
+    	        this.pos = end;
+    	        return buffer;
+    	    },
+
+    	    // verbose for performance reasons; doesn't affect gzipped size
+
+    	    readPackedVarint: function(arr, isSigned) {
+    	        if (this.type !== Pbf.Bytes) return arr.push(this.readVarint(isSigned));
+    	        var end = readPackedEnd(this);
+    	        arr = arr || [];
+    	        while (this.pos < end) arr.push(this.readVarint(isSigned));
+    	        return arr;
+    	    },
+    	    readPackedSVarint: function(arr) {
+    	        if (this.type !== Pbf.Bytes) return arr.push(this.readSVarint());
+    	        var end = readPackedEnd(this);
+    	        arr = arr || [];
+    	        while (this.pos < end) arr.push(this.readSVarint());
+    	        return arr;
+    	    },
+    	    readPackedBoolean: function(arr) {
+    	        if (this.type !== Pbf.Bytes) return arr.push(this.readBoolean());
+    	        var end = readPackedEnd(this);
+    	        arr = arr || [];
+    	        while (this.pos < end) arr.push(this.readBoolean());
+    	        return arr;
+    	    },
+    	    readPackedFloat: function(arr) {
+    	        if (this.type !== Pbf.Bytes) return arr.push(this.readFloat());
+    	        var end = readPackedEnd(this);
+    	        arr = arr || [];
+    	        while (this.pos < end) arr.push(this.readFloat());
+    	        return arr;
+    	    },
+    	    readPackedDouble: function(arr) {
+    	        if (this.type !== Pbf.Bytes) return arr.push(this.readDouble());
+    	        var end = readPackedEnd(this);
+    	        arr = arr || [];
+    	        while (this.pos < end) arr.push(this.readDouble());
+    	        return arr;
+    	    },
+    	    readPackedFixed32: function(arr) {
+    	        if (this.type !== Pbf.Bytes) return arr.push(this.readFixed32());
+    	        var end = readPackedEnd(this);
+    	        arr = arr || [];
+    	        while (this.pos < end) arr.push(this.readFixed32());
+    	        return arr;
+    	    },
+    	    readPackedSFixed32: function(arr) {
+    	        if (this.type !== Pbf.Bytes) return arr.push(this.readSFixed32());
+    	        var end = readPackedEnd(this);
+    	        arr = arr || [];
+    	        while (this.pos < end) arr.push(this.readSFixed32());
+    	        return arr;
+    	    },
+    	    readPackedFixed64: function(arr) {
+    	        if (this.type !== Pbf.Bytes) return arr.push(this.readFixed64());
+    	        var end = readPackedEnd(this);
+    	        arr = arr || [];
+    	        while (this.pos < end) arr.push(this.readFixed64());
+    	        return arr;
+    	    },
+    	    readPackedSFixed64: function(arr) {
+    	        if (this.type !== Pbf.Bytes) return arr.push(this.readSFixed64());
+    	        var end = readPackedEnd(this);
+    	        arr = arr || [];
+    	        while (this.pos < end) arr.push(this.readSFixed64());
+    	        return arr;
+    	    },
+
+    	    skip: function(val) {
+    	        var type = val & 0x7;
+    	        if (type === Pbf.Varint) while (this.buf[this.pos++] > 0x7f) {}
+    	        else if (type === Pbf.Bytes) this.pos = this.readVarint() + this.pos;
+    	        else if (type === Pbf.Fixed32) this.pos += 4;
+    	        else if (type === Pbf.Fixed64) this.pos += 8;
+    	        else throw new Error('Unimplemented type: ' + type);
+    	    },
+
+    	    // === WRITING =================================================================
+
+    	    writeTag: function(tag, type) {
+    	        this.writeVarint((tag << 3) | type);
+    	    },
+
+    	    realloc: function(min) {
+    	        var length = this.length || 16;
+
+    	        while (length < this.pos + min) length *= 2;
+
+    	        if (length !== this.length) {
+    	            var buf = new Uint8Array(length);
+    	            buf.set(this.buf);
+    	            this.buf = buf;
+    	            this.length = length;
+    	        }
+    	    },
+
+    	    finish: function() {
+    	        this.length = this.pos;
+    	        this.pos = 0;
+    	        return this.buf.subarray(0, this.length);
+    	    },
+
+    	    writeFixed32: function(val) {
+    	        this.realloc(4);
+    	        writeInt32(this.buf, val, this.pos);
+    	        this.pos += 4;
+    	    },
+
+    	    writeSFixed32: function(val) {
+    	        this.realloc(4);
+    	        writeInt32(this.buf, val, this.pos);
+    	        this.pos += 4;
+    	    },
+
+    	    writeFixed64: function(val) {
+    	        this.realloc(8);
+    	        writeInt32(this.buf, val & -1, this.pos);
+    	        writeInt32(this.buf, Math.floor(val * SHIFT_RIGHT_32), this.pos + 4);
+    	        this.pos += 8;
+    	    },
+
+    	    writeSFixed64: function(val) {
+    	        this.realloc(8);
+    	        writeInt32(this.buf, val & -1, this.pos);
+    	        writeInt32(this.buf, Math.floor(val * SHIFT_RIGHT_32), this.pos + 4);
+    	        this.pos += 8;
+    	    },
+
+    	    writeVarint: function(val) {
+    	        val = +val || 0;
+
+    	        if (val > 0xfffffff || val < 0) {
+    	            writeBigVarint(val, this);
+    	            return;
+    	        }
+
+    	        this.realloc(4);
+
+    	        this.buf[this.pos++] =           val & 0x7f  | (val > 0x7f ? 0x80 : 0); if (val <= 0x7f) return;
+    	        this.buf[this.pos++] = ((val >>>= 7) & 0x7f) | (val > 0x7f ? 0x80 : 0); if (val <= 0x7f) return;
+    	        this.buf[this.pos++] = ((val >>>= 7) & 0x7f) | (val > 0x7f ? 0x80 : 0); if (val <= 0x7f) return;
+    	        this.buf[this.pos++] =   (val >>> 7) & 0x7f;
+    	    },
+
+    	    writeSVarint: function(val) {
+    	        this.writeVarint(val < 0 ? -val * 2 - 1 : val * 2);
+    	    },
+
+    	    writeBoolean: function(val) {
+    	        this.writeVarint(Boolean(val));
+    	    },
+
+    	    writeString: function(str) {
+    	        str = String(str);
+    	        this.realloc(str.length * 4);
+
+    	        this.pos++; // reserve 1 byte for short string length
+
+    	        var startPos = this.pos;
+    	        // write the string directly to the buffer and see how much was written
+    	        this.pos = writeUtf8(this.buf, str, this.pos);
+    	        var len = this.pos - startPos;
+
+    	        if (len >= 0x80) makeRoomForExtraLength(startPos, len, this);
+
+    	        // finally, write the message length in the reserved place and restore the position
+    	        this.pos = startPos - 1;
+    	        this.writeVarint(len);
+    	        this.pos += len;
+    	    },
+
+    	    writeFloat: function(val) {
+    	        this.realloc(4);
+    	        ieee754.write(this.buf, val, this.pos, true, 23, 4);
+    	        this.pos += 4;
+    	    },
+
+    	    writeDouble: function(val) {
+    	        this.realloc(8);
+    	        ieee754.write(this.buf, val, this.pos, true, 52, 8);
+    	        this.pos += 8;
+    	    },
+
+    	    writeBytes: function(buffer) {
+    	        var len = buffer.length;
+    	        this.writeVarint(len);
+    	        this.realloc(len);
+    	        for (var i = 0; i < len; i++) this.buf[this.pos++] = buffer[i];
+    	    },
+
+    	    writeRawMessage: function(fn, obj) {
+    	        this.pos++; // reserve 1 byte for short message length
+
+    	        // write the message directly to the buffer and see how much was written
+    	        var startPos = this.pos;
+    	        fn(obj, this);
+    	        var len = this.pos - startPos;
+
+    	        if (len >= 0x80) makeRoomForExtraLength(startPos, len, this);
+
+    	        // finally, write the message length in the reserved place and restore the position
+    	        this.pos = startPos - 1;
+    	        this.writeVarint(len);
+    	        this.pos += len;
+    	    },
+
+    	    writeMessage: function(tag, fn, obj) {
+    	        this.writeTag(tag, Pbf.Bytes);
+    	        this.writeRawMessage(fn, obj);
+    	    },
+
+    	    writePackedVarint:   function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedVarint, arr);   },
+    	    writePackedSVarint:  function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedSVarint, arr);  },
+    	    writePackedBoolean:  function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedBoolean, arr);  },
+    	    writePackedFloat:    function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedFloat, arr);    },
+    	    writePackedDouble:   function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedDouble, arr);   },
+    	    writePackedFixed32:  function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedFixed32, arr);  },
+    	    writePackedSFixed32: function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedSFixed32, arr); },
+    	    writePackedFixed64:  function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedFixed64, arr);  },
+    	    writePackedSFixed64: function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedSFixed64, arr); },
+
+    	    writeBytesField: function(tag, buffer) {
+    	        this.writeTag(tag, Pbf.Bytes);
+    	        this.writeBytes(buffer);
+    	    },
+    	    writeFixed32Field: function(tag, val) {
+    	        this.writeTag(tag, Pbf.Fixed32);
+    	        this.writeFixed32(val);
+    	    },
+    	    writeSFixed32Field: function(tag, val) {
+    	        this.writeTag(tag, Pbf.Fixed32);
+    	        this.writeSFixed32(val);
+    	    },
+    	    writeFixed64Field: function(tag, val) {
+    	        this.writeTag(tag, Pbf.Fixed64);
+    	        this.writeFixed64(val);
+    	    },
+    	    writeSFixed64Field: function(tag, val) {
+    	        this.writeTag(tag, Pbf.Fixed64);
+    	        this.writeSFixed64(val);
+    	    },
+    	    writeVarintField: function(tag, val) {
+    	        this.writeTag(tag, Pbf.Varint);
+    	        this.writeVarint(val);
+    	    },
+    	    writeSVarintField: function(tag, val) {
+    	        this.writeTag(tag, Pbf.Varint);
+    	        this.writeSVarint(val);
+    	    },
+    	    writeStringField: function(tag, str) {
+    	        this.writeTag(tag, Pbf.Bytes);
+    	        this.writeString(str);
+    	    },
+    	    writeFloatField: function(tag, val) {
+    	        this.writeTag(tag, Pbf.Fixed32);
+    	        this.writeFloat(val);
+    	    },
+    	    writeDoubleField: function(tag, val) {
+    	        this.writeTag(tag, Pbf.Fixed64);
+    	        this.writeDouble(val);
+    	    },
+    	    writeBooleanField: function(tag, val) {
+    	        this.writeVarintField(tag, Boolean(val));
+    	    }
+    	};
+
+    	function readVarintRemainder(l, s, p) {
+    	    var buf = p.buf,
+    	        h, b;
+
+    	    b = buf[p.pos++]; h  = (b & 0x70) >> 4;  if (b < 0x80) return toNum(l, h, s);
+    	    b = buf[p.pos++]; h |= (b & 0x7f) << 3;  if (b < 0x80) return toNum(l, h, s);
+    	    b = buf[p.pos++]; h |= (b & 0x7f) << 10; if (b < 0x80) return toNum(l, h, s);
+    	    b = buf[p.pos++]; h |= (b & 0x7f) << 17; if (b < 0x80) return toNum(l, h, s);
+    	    b = buf[p.pos++]; h |= (b & 0x7f) << 24; if (b < 0x80) return toNum(l, h, s);
+    	    b = buf[p.pos++]; h |= (b & 0x01) << 31; if (b < 0x80) return toNum(l, h, s);
+
+    	    throw new Error('Expected varint not more than 10 bytes');
+    	}
+
+    	function readPackedEnd(pbf) {
+    	    return pbf.type === Pbf.Bytes ?
+    	        pbf.readVarint() + pbf.pos : pbf.pos + 1;
+    	}
+
+    	function toNum(low, high, isSigned) {
+    	    if (isSigned) {
+    	        return high * 0x100000000 + (low >>> 0);
+    	    }
+
+    	    return ((high >>> 0) * 0x100000000) + (low >>> 0);
+    	}
+
+    	function writeBigVarint(val, pbf) {
+    	    var low, high;
+
+    	    if (val >= 0) {
+    	        low  = (val % 0x100000000) | 0;
+    	        high = (val / 0x100000000) | 0;
+    	    } else {
+    	        low  = ~(-val % 0x100000000);
+    	        high = ~(-val / 0x100000000);
+
+    	        if (low ^ 0xffffffff) {
+    	            low = (low + 1) | 0;
+    	        } else {
+    	            low = 0;
+    	            high = (high + 1) | 0;
+    	        }
+    	    }
+
+    	    if (val >= 0x10000000000000000 || val < -18446744073709552e3) {
+    	        throw new Error('Given varint doesn\'t fit into 10 bytes');
+    	    }
+
+    	    pbf.realloc(10);
+
+    	    writeBigVarintLow(low, high, pbf);
+    	    writeBigVarintHigh(high, pbf);
+    	}
+
+    	function writeBigVarintLow(low, high, pbf) {
+    	    pbf.buf[pbf.pos++] = low & 0x7f | 0x80; low >>>= 7;
+    	    pbf.buf[pbf.pos++] = low & 0x7f | 0x80; low >>>= 7;
+    	    pbf.buf[pbf.pos++] = low & 0x7f | 0x80; low >>>= 7;
+    	    pbf.buf[pbf.pos++] = low & 0x7f | 0x80; low >>>= 7;
+    	    pbf.buf[pbf.pos]   = low & 0x7f;
+    	}
+
+    	function writeBigVarintHigh(high, pbf) {
+    	    var lsb = (high & 0x07) << 4;
+
+    	    pbf.buf[pbf.pos++] |= lsb         | ((high >>>= 3) ? 0x80 : 0); if (!high) return;
+    	    pbf.buf[pbf.pos++]  = high & 0x7f | ((high >>>= 7) ? 0x80 : 0); if (!high) return;
+    	    pbf.buf[pbf.pos++]  = high & 0x7f | ((high >>>= 7) ? 0x80 : 0); if (!high) return;
+    	    pbf.buf[pbf.pos++]  = high & 0x7f | ((high >>>= 7) ? 0x80 : 0); if (!high) return;
+    	    pbf.buf[pbf.pos++]  = high & 0x7f | ((high >>>= 7) ? 0x80 : 0); if (!high) return;
+    	    pbf.buf[pbf.pos++]  = high & 0x7f;
+    	}
+
+    	function makeRoomForExtraLength(startPos, len, pbf) {
+    	    var extraLen =
+    	        len <= 0x3fff ? 1 :
+    	        len <= 0x1fffff ? 2 :
+    	        len <= 0xfffffff ? 3 : Math.floor(Math.log(len) / (Math.LN2 * 7));
+
+    	    // if 1 byte isn't enough for encoding message length, shift the data to the right
+    	    pbf.realloc(extraLen);
+    	    for (var i = pbf.pos - 1; i >= startPos; i--) pbf.buf[i + extraLen] = pbf.buf[i];
+    	}
+
+    	function writePackedVarint(arr, pbf)   { for (var i = 0; i < arr.length; i++) pbf.writeVarint(arr[i]);   }
+    	function writePackedSVarint(arr, pbf)  { for (var i = 0; i < arr.length; i++) pbf.writeSVarint(arr[i]);  }
+    	function writePackedFloat(arr, pbf)    { for (var i = 0; i < arr.length; i++) pbf.writeFloat(arr[i]);    }
+    	function writePackedDouble(arr, pbf)   { for (var i = 0; i < arr.length; i++) pbf.writeDouble(arr[i]);   }
+    	function writePackedBoolean(arr, pbf)  { for (var i = 0; i < arr.length; i++) pbf.writeBoolean(arr[i]);  }
+    	function writePackedFixed32(arr, pbf)  { for (var i = 0; i < arr.length; i++) pbf.writeFixed32(arr[i]);  }
+    	function writePackedSFixed32(arr, pbf) { for (var i = 0; i < arr.length; i++) pbf.writeSFixed32(arr[i]); }
+    	function writePackedFixed64(arr, pbf)  { for (var i = 0; i < arr.length; i++) pbf.writeFixed64(arr[i]);  }
+    	function writePackedSFixed64(arr, pbf) { for (var i = 0; i < arr.length; i++) pbf.writeSFixed64(arr[i]); }
+
+    	// Buffer code below from https://github.com/feross/buffer, MIT-licensed
+
+    	function readUInt32(buf, pos) {
+    	    return ((buf[pos]) |
+    	        (buf[pos + 1] << 8) |
+    	        (buf[pos + 2] << 16)) +
+    	        (buf[pos + 3] * 0x1000000);
+    	}
+
+    	function writeInt32(buf, val, pos) {
+    	    buf[pos] = val;
+    	    buf[pos + 1] = (val >>> 8);
+    	    buf[pos + 2] = (val >>> 16);
+    	    buf[pos + 3] = (val >>> 24);
+    	}
+
+    	function readInt32(buf, pos) {
+    	    return ((buf[pos]) |
+    	        (buf[pos + 1] << 8) |
+    	        (buf[pos + 2] << 16)) +
+    	        (buf[pos + 3] << 24);
+    	}
+
+    	function readUtf8(buf, pos, end) {
+    	    var str = '';
+    	    var i = pos;
+
+    	    while (i < end) {
+    	        var b0 = buf[i];
+    	        var c = null; // codepoint
+    	        var bytesPerSequence =
+    	            b0 > 0xEF ? 4 :
+    	            b0 > 0xDF ? 3 :
+    	            b0 > 0xBF ? 2 : 1;
+
+    	        if (i + bytesPerSequence > end) break;
+
+    	        var b1, b2, b3;
+
+    	        if (bytesPerSequence === 1) {
+    	            if (b0 < 0x80) {
+    	                c = b0;
+    	            }
+    	        } else if (bytesPerSequence === 2) {
+    	            b1 = buf[i + 1];
+    	            if ((b1 & 0xC0) === 0x80) {
+    	                c = (b0 & 0x1F) << 0x6 | (b1 & 0x3F);
+    	                if (c <= 0x7F) {
+    	                    c = null;
+    	                }
+    	            }
+    	        } else if (bytesPerSequence === 3) {
+    	            b1 = buf[i + 1];
+    	            b2 = buf[i + 2];
+    	            if ((b1 & 0xC0) === 0x80 && (b2 & 0xC0) === 0x80) {
+    	                c = (b0 & 0xF) << 0xC | (b1 & 0x3F) << 0x6 | (b2 & 0x3F);
+    	                if (c <= 0x7FF || (c >= 0xD800 && c <= 0xDFFF)) {
+    	                    c = null;
+    	                }
+    	            }
+    	        } else if (bytesPerSequence === 4) {
+    	            b1 = buf[i + 1];
+    	            b2 = buf[i + 2];
+    	            b3 = buf[i + 3];
+    	            if ((b1 & 0xC0) === 0x80 && (b2 & 0xC0) === 0x80 && (b3 & 0xC0) === 0x80) {
+    	                c = (b0 & 0xF) << 0x12 | (b1 & 0x3F) << 0xC | (b2 & 0x3F) << 0x6 | (b3 & 0x3F);
+    	                if (c <= 0xFFFF || c >= 0x110000) {
+    	                    c = null;
+    	                }
+    	            }
+    	        }
+
+    	        if (c === null) {
+    	            c = 0xFFFD;
+    	            bytesPerSequence = 1;
+
+    	        } else if (c > 0xFFFF) {
+    	            c -= 0x10000;
+    	            str += String.fromCharCode(c >>> 10 & 0x3FF | 0xD800);
+    	            c = 0xDC00 | c & 0x3FF;
+    	        }
+
+    	        str += String.fromCharCode(c);
+    	        i += bytesPerSequence;
+    	    }
+
+    	    return str;
+    	}
+
+    	function readUtf8TextDecoder(buf, pos, end) {
+    	    return utf8TextDecoder.decode(buf.subarray(pos, end));
+    	}
+
+    	function writeUtf8(buf, str, pos) {
+    	    for (var i = 0, c, lead; i < str.length; i++) {
+    	        c = str.charCodeAt(i); // code point
+
+    	        if (c > 0xD7FF && c < 0xE000) {
+    	            if (lead) {
+    	                if (c < 0xDC00) {
+    	                    buf[pos++] = 0xEF;
+    	                    buf[pos++] = 0xBF;
+    	                    buf[pos++] = 0xBD;
+    	                    lead = c;
+    	                    continue;
+    	                } else {
+    	                    c = lead - 0xD800 << 10 | c - 0xDC00 | 0x10000;
+    	                    lead = null;
+    	                }
+    	            } else {
+    	                if (c > 0xDBFF || (i + 1 === str.length)) {
+    	                    buf[pos++] = 0xEF;
+    	                    buf[pos++] = 0xBF;
+    	                    buf[pos++] = 0xBD;
+    	                } else {
+    	                    lead = c;
+    	                }
+    	                continue;
+    	            }
+    	        } else if (lead) {
+    	            buf[pos++] = 0xEF;
+    	            buf[pos++] = 0xBF;
+    	            buf[pos++] = 0xBD;
+    	            lead = null;
+    	        }
+
+    	        if (c < 0x80) {
+    	            buf[pos++] = c;
+    	        } else {
+    	            if (c < 0x800) {
+    	                buf[pos++] = c >> 0x6 | 0xC0;
+    	            } else {
+    	                if (c < 0x10000) {
+    	                    buf[pos++] = c >> 0xC | 0xE0;
+    	                } else {
+    	                    buf[pos++] = c >> 0x12 | 0xF0;
+    	                    buf[pos++] = c >> 0xC & 0x3F | 0x80;
+    	                }
+    	                buf[pos++] = c >> 0x6 & 0x3F | 0x80;
+    	            }
+    	            buf[pos++] = c & 0x3F | 0x80;
+    	        }
+    	    }
+    	    return pos;
+    	}
+    	return pbf;
+    }
+
+    var pbfExports = requirePbf();
+    var Pbf = /*@__PURE__*/getDefaultExportFromCjs(pbfExports);
+
+    // FeatureCollectionPBuffer ========================================
+
+    const FeatureCollectionPBuffer = {};
+
+    FeatureCollectionPBuffer.read = function (pbf, end) {
+      return pbf.readFields(FeatureCollectionPBuffer._readField, {version: '', queryResult: null}, end);
+    };
+    FeatureCollectionPBuffer._readField = function (tag, obj, pbf) {
+      if (tag === 1) obj.version = pbf.readString();
+      else if (tag === 2) obj.queryResult = FeatureCollectionPBuffer.QueryResult.read(pbf, pbf.readVarint() + pbf.pos);
+    };
+    FeatureCollectionPBuffer.write = function (obj, pbf) {
+      if (obj.version) pbf.writeStringField(1, obj.version);
+      if (obj.queryResult) pbf.writeMessage(2, FeatureCollectionPBuffer.QueryResult.write, obj.queryResult);
+    };
+
+    FeatureCollectionPBuffer.GeometryType = {
+      'esriGeometryTypePoint': {
+        'value': 0,
+        'options': {}
+      },
+      'esriGeometryTypeMultipoint': {
+        'value': 1,
+        'options': {}
+      },
+      'esriGeometryTypePolyline': {
+        'value': 2,
+        'options': {}
+      },
+      'esriGeometryTypePolygon': {
+        'value': 3,
+        'options': {}
+      },
+      'esriGeometryTypeMultipatch': {
+        'value': 4,
+        'options': {}
+      },
+      'esriGeometryTypeNone': {
+        'value': 127,
+        'options': {}
+      }
+    };
+
+    FeatureCollectionPBuffer.FieldType = {
+      'esriFieldTypeSmallInteger': {
+        'value': 0,
+        'options': {}
+      },
+      'esriFieldTypeInteger': {
+        'value': 1,
+        'options': {}
+      },
+      'esriFieldTypeSingle': {
+        'value': 2,
+        'options': {}
+      },
+      'esriFieldTypeDouble': {
+        'value': 3,
+        'options': {}
+      },
+      'esriFieldTypeString': {
+        'value': 4,
+        'options': {}
+      },
+      'esriFieldTypeDate': {
+        'value': 5,
+        'options': {}
+      },
+      'esriFieldTypeOID': {
+        'value': 6,
+        'options': {}
+      },
+      'esriFieldTypeGeometry': {
+        'value': 7,
+        'options': {}
+      },
+      'esriFieldTypeBlob': {
+        'value': 8,
+        'options': {}
+      },
+      'esriFieldTypeRaster': {
+        'value': 9,
+        'options': {}
+      },
+      'esriFieldTypeGUID': {
+        'value': 10,
+        'options': {}
+      },
+      'esriFieldTypeGlobalID': {
+        'value': 11,
+        'options': {}
+      },
+      'esriFieldTypeXML': {
+        'value': 12,
+        'options': {}
+      }
+    };
+
+    FeatureCollectionPBuffer.SQLType = {
+      'sqlTypeBigInt': {
+        'value': 0,
+        'options': {}
+      },
+      'sqlTypeBinary': {
+        'value': 1,
+        'options': {}
+      },
+      'sqlTypeBit': {
+        'value': 2,
+        'options': {}
+      },
+      'sqlTypeChar': {
+        'value': 3,
+        'options': {}
+      },
+      'sqlTypeDate': {
+        'value': 4,
+        'options': {}
+      },
+      'sqlTypeDecimal': {
+        'value': 5,
+        'options': {}
+      },
+      'sqlTypeDouble': {
+        'value': 6,
+        'options': {}
+      },
+      'sqlTypeFloat': {
+        'value': 7,
+        'options': {}
+      },
+      'sqlTypeGeometry': {
+        'value': 8,
+        'options': {}
+      },
+      'sqlTypeGUID': {
+        'value': 9,
+        'options': {}
+      },
+      'sqlTypeInteger': {
+        'value': 10,
+        'options': {}
+      },
+      'sqlTypeLongNVarchar': {
+        'value': 11,
+        'options': {}
+      },
+      'sqlTypeLongVarbinary': {
+        'value': 12,
+        'options': {}
+      },
+      'sqlTypeLongVarchar': {
+        'value': 13,
+        'options': {}
+      },
+      'sqlTypeNChar': {
+        'value': 14,
+        'options': {}
+      },
+      'sqlTypeNVarchar': {
+        'value': 15,
+        'options': {}
+      },
+      'sqlTypeOther': {
+        'value': 16,
+        'options': {}
+      },
+      'sqlTypeReal': {
+        'value': 17,
+        'options': {}
+      },
+      'sqlTypeSmallInt': {
+        'value': 18,
+        'options': {}
+      },
+      'sqlTypeSqlXml': {
+        'value': 19,
+        'options': {}
+      },
+      'sqlTypeTime': {
+        'value': 20,
+        'options': {}
+      },
+      'sqlTypeTimestamp': {
+        'value': 21,
+        'options': {}
+      },
+      'sqlTypeTimestamp2': {
+        'value': 22,
+        'options': {}
+      },
+      'sqlTypeTinyInt': {
+        'value': 23,
+        'options': {}
+      },
+      'sqlTypeVarbinary': {
+        'value': 24,
+        'options': {}
+      },
+      'sqlTypeVarchar': {
+        'value': 25,
+        'options': {}
+      }
+    };
+
+    FeatureCollectionPBuffer.QuantizeOriginPostion = {
+      'upperLeft': {
+        'value': 0,
+        'options': {}
+      },
+      'lowerLeft': {
+        'value': 1,
+        'options': {}
+      }
+    };
+
+    // FeatureCollectionPBuffer.SpatialReference ========================================
+
+    FeatureCollectionPBuffer.SpatialReference = {};
+
+    FeatureCollectionPBuffer.SpatialReference.read = function (pbf, end) {
+      return pbf.readFields(FeatureCollectionPBuffer.SpatialReference._readField, {wkid: 0, lastestWkid: 0, vcsWkid: 0, latestVcsWkid: 0, wkt: ''}, end);
+    };
+    FeatureCollectionPBuffer.SpatialReference._readField = function (tag, obj, pbf) {
+      if (tag === 1) obj.wkid = pbf.readVarint();
+      else if (tag === 2) obj.lastestWkid = pbf.readVarint();
+      else if (tag === 3) obj.vcsWkid = pbf.readVarint();
+      else if (tag === 4) obj.latestVcsWkid = pbf.readVarint();
+      else if (tag === 5) obj.wkt = pbf.readString();
+    };
+    FeatureCollectionPBuffer.SpatialReference.write = function (obj, pbf) {
+      if (obj.wkid) pbf.writeVarintField(1, obj.wkid);
+      if (obj.lastestWkid) pbf.writeVarintField(2, obj.lastestWkid);
+      if (obj.vcsWkid) pbf.writeVarintField(3, obj.vcsWkid);
+      if (obj.latestVcsWkid) pbf.writeVarintField(4, obj.latestVcsWkid);
+      if (obj.wkt) pbf.writeStringField(5, obj.wkt);
+    };
+
+    // FeatureCollectionPBuffer.Field ========================================
+
+    FeatureCollectionPBuffer.Field = {};
+
+    FeatureCollectionPBuffer.Field.read = function (pbf, end) {
+      return pbf.readFields(FeatureCollectionPBuffer.Field._readField, {name: '', fieldType: 0, alias: '', sqlType: 0, domain: '', defaultValue: ''}, end);
+    };
+    FeatureCollectionPBuffer.Field._readField = function (tag, obj, pbf) {
+      if (tag === 1) obj.name = pbf.readString();
+      else if (tag === 2) obj.fieldType = pbf.readVarint();
+      else if (tag === 3) obj.alias = pbf.readString();
+      else if (tag === 4) obj.sqlType = pbf.readVarint();
+      else if (tag === 5) obj.domain = pbf.readString();
+      else if (tag === 6) obj.defaultValue = pbf.readString();
+    };
+    FeatureCollectionPBuffer.Field.write = function (obj, pbf) {
+      if (obj.name) pbf.writeStringField(1, obj.name);
+      if (obj.fieldType) pbf.writeVarintField(2, obj.fieldType);
+      if (obj.alias) pbf.writeStringField(3, obj.alias);
+      if (obj.sqlType) pbf.writeVarintField(4, obj.sqlType);
+      if (obj.domain) pbf.writeStringField(5, obj.domain);
+      if (obj.defaultValue) pbf.writeStringField(6, obj.defaultValue);
+    };
+
+    // FeatureCollectionPBuffer.Value ========================================
+
+    FeatureCollectionPBuffer.Value = {};
+
+    FeatureCollectionPBuffer.Value.read = function (pbf, end) {
+      return pbf.readFields(FeatureCollectionPBuffer.Value._readField, {string_value: '', value_type: null, float_value: 0, double_value: 0, sint_value: 0, uint_value: 0, int64_value: 0, uint64_value: 0, sint64_value: 0, bool_value: false}, end);
+    };
+    FeatureCollectionPBuffer.Value._readField = function (tag, obj, pbf) {
+      if (tag === 1) obj.string_value = pbf.readString(), obj.value_type = 'string_value';
+      else if (tag === 2) obj.float_value = pbf.readFloat(), obj.value_type = 'float_value';
+      else if (tag === 3) obj.double_value = pbf.readDouble(), obj.value_type = 'double_value';
+      else if (tag === 4) obj.sint_value = pbf.readSVarint(), obj.value_type = 'sint_value';
+      else if (tag === 5) obj.uint_value = pbf.readVarint(), obj.value_type = 'uint_value';
+      else if (tag === 6) obj.int64_value = pbf.readVarint(true), obj.value_type = 'int64_value';
+      else if (tag === 7) obj.uint64_value = pbf.readVarint(), obj.value_type = 'uint64_value';
+      else if (tag === 8) obj.sint64_value = pbf.readSVarint(), obj.value_type = 'sint64_value';
+      else if (tag === 9) obj.bool_value = pbf.readBoolean(), obj.value_type = 'bool_value';
+    };
+    FeatureCollectionPBuffer.Value.write = function (obj, pbf) {
+      if (obj.string_value) pbf.writeStringField(1, obj.string_value);
+      if (obj.float_value) pbf.writeFloatField(2, obj.float_value);
+      if (obj.double_value) pbf.writeDoubleField(3, obj.double_value);
+      if (obj.sint_value) pbf.writeSVarintField(4, obj.sint_value);
+      if (obj.uint_value) pbf.writeVarintField(5, obj.uint_value);
+      if (obj.int64_value) pbf.writeVarintField(6, obj.int64_value);
+      if (obj.uint64_value) pbf.writeVarintField(7, obj.uint64_value);
+      if (obj.sint64_value) pbf.writeSVarintField(8, obj.sint64_value);
+      if (obj.bool_value) pbf.writeBooleanField(9, obj.bool_value);
+    };
+
+    // FeatureCollectionPBuffer.Geometry ========================================
+
+    FeatureCollectionPBuffer.Geometry = {};
+
+    FeatureCollectionPBuffer.Geometry.read = function (pbf, end) {
+      return pbf.readFields(FeatureCollectionPBuffer.Geometry._readField, {lengths: [], coords: []}, end);
+    };
+    FeatureCollectionPBuffer.Geometry._readField = function (tag, obj, pbf) {
+      if (tag === 2) pbf.readPackedVarint(obj.lengths);
+      else if (tag === 3) pbf.readPackedSVarint(obj.coords);
+    };
+    FeatureCollectionPBuffer.Geometry.write = function (obj, pbf) {
+      if (obj.lengths) pbf.writePackedVarint(2, obj.lengths);
+      if (obj.coords) pbf.writePackedSVarint(3, obj.coords);
+    };
+
+    // FeatureCollectionPBuffer.esriShapeBuffer ========================================
+
+    FeatureCollectionPBuffer.esriShapeBuffer = {};
+
+    FeatureCollectionPBuffer.esriShapeBuffer.read = function (pbf, end) {
+      return pbf.readFields(FeatureCollectionPBuffer.esriShapeBuffer._readField, {bytes: null}, end);
+    };
+    FeatureCollectionPBuffer.esriShapeBuffer._readField = function (tag, obj, pbf) {
+      if (tag === 1) obj.bytes = pbf.readBytes();
+    };
+    FeatureCollectionPBuffer.esriShapeBuffer.write = function (obj, pbf) {
+      if (obj.bytes) pbf.writeBytesField(1, obj.bytes);
+    };
+
+    // FeatureCollectionPBuffer.Feature ========================================
+
+    FeatureCollectionPBuffer.Feature = {};
+
+    FeatureCollectionPBuffer.Feature.read = function (pbf, end) {
+      return pbf.readFields(FeatureCollectionPBuffer.Feature._readField, {attributes: [], geometry: null, compressed_geometry: null, shapeBuffer: null, centroid: null}, end);
+    };
+    FeatureCollectionPBuffer.Feature._readField = function (tag, obj, pbf) {
+      if (tag === 1) obj.attributes.push(FeatureCollectionPBuffer.Value.read(pbf, pbf.readVarint() + pbf.pos));
+      else if (tag === 2) obj.geometry = FeatureCollectionPBuffer.Geometry.read(pbf, pbf.readVarint() + pbf.pos), obj.compressed_geometry = 'geometry';
+      else if (tag === 3) obj.shapeBuffer = FeatureCollectionPBuffer.esriShapeBuffer.read(pbf, pbf.readVarint() + pbf.pos), obj.compressed_geometry = 'shapeBuffer';
+      else if (tag === 4) obj.centroid = FeatureCollectionPBuffer.Geometry.read(pbf, pbf.readVarint() + pbf.pos);
+    };
+    FeatureCollectionPBuffer.Feature.write = function (obj, pbf) {
+      if (obj.attributes) for (let i = 0; i < obj.attributes.length; i++) pbf.writeMessage(1, FeatureCollectionPBuffer.Value.write, obj.attributes[i]);
+      if (obj.geometry) pbf.writeMessage(2, FeatureCollectionPBuffer.Geometry.write, obj.geometry);
+      if (obj.shapeBuffer) pbf.writeMessage(3, FeatureCollectionPBuffer.esriShapeBuffer.write, obj.shapeBuffer);
+      if (obj.centroid) pbf.writeMessage(4, FeatureCollectionPBuffer.Geometry.write, obj.centroid);
+    };
+
+    // FeatureCollectionPBuffer.UniqueIdField ========================================
+
+    FeatureCollectionPBuffer.UniqueIdField = {};
+
+    FeatureCollectionPBuffer.UniqueIdField.read = function (pbf, end) {
+      return pbf.readFields(FeatureCollectionPBuffer.UniqueIdField._readField, {name: '', isSystemMaintained: false}, end);
+    };
+    FeatureCollectionPBuffer.UniqueIdField._readField = function (tag, obj, pbf) {
+      if (tag === 1) obj.name = pbf.readString();
+      else if (tag === 2) obj.isSystemMaintained = pbf.readBoolean();
+    };
+    FeatureCollectionPBuffer.UniqueIdField.write = function (obj, pbf) {
+      if (obj.name) pbf.writeStringField(1, obj.name);
+      if (obj.isSystemMaintained) pbf.writeBooleanField(2, obj.isSystemMaintained);
+    };
+
+    // FeatureCollectionPBuffer.GeometryProperties ========================================
+
+    FeatureCollectionPBuffer.GeometryProperties = {};
+
+    FeatureCollectionPBuffer.GeometryProperties.read = function (pbf, end) {
+      return pbf.readFields(FeatureCollectionPBuffer.GeometryProperties._readField, {shapeAreaFieldName: '', shapeLengthFieldName: '', units: ''}, end);
+    };
+    FeatureCollectionPBuffer.GeometryProperties._readField = function (tag, obj, pbf) {
+      if (tag === 1) obj.shapeAreaFieldName = pbf.readString();
+      else if (tag === 2) obj.shapeLengthFieldName = pbf.readString();
+      else if (tag === 3) obj.units = pbf.readString();
+    };
+    FeatureCollectionPBuffer.GeometryProperties.write = function (obj, pbf) {
+      if (obj.shapeAreaFieldName) pbf.writeStringField(1, obj.shapeAreaFieldName);
+      if (obj.shapeLengthFieldName) pbf.writeStringField(2, obj.shapeLengthFieldName);
+      if (obj.units) pbf.writeStringField(3, obj.units);
+    };
+
+    // FeatureCollectionPBuffer.ServerGens ========================================
+
+    FeatureCollectionPBuffer.ServerGens = {};
+
+    FeatureCollectionPBuffer.ServerGens.read = function (pbf, end) {
+      return pbf.readFields(FeatureCollectionPBuffer.ServerGens._readField, {minServerGen: 0, serverGen: 0}, end);
+    };
+    FeatureCollectionPBuffer.ServerGens._readField = function (tag, obj, pbf) {
+      if (tag === 1) obj.minServerGen = pbf.readVarint();
+      else if (tag === 2) obj.serverGen = pbf.readVarint();
+    };
+    FeatureCollectionPBuffer.ServerGens.write = function (obj, pbf) {
+      if (obj.minServerGen) pbf.writeVarintField(1, obj.minServerGen);
+      if (obj.serverGen) pbf.writeVarintField(2, obj.serverGen);
+    };
+
+    // FeatureCollectionPBuffer.Scale ========================================
+
+    FeatureCollectionPBuffer.Scale = {};
+
+    FeatureCollectionPBuffer.Scale.read = function (pbf, end) {
+      return pbf.readFields(FeatureCollectionPBuffer.Scale._readField, {xScale: 0, yScale: 0, mScale: 0, zScale: 0}, end);
+    };
+    FeatureCollectionPBuffer.Scale._readField = function (tag, obj, pbf) {
+      if (tag === 1) obj.xScale = pbf.readDouble();
+      else if (tag === 2) obj.yScale = pbf.readDouble();
+      else if (tag === 3) obj.mScale = pbf.readDouble();
+      else if (tag === 4) obj.zScale = pbf.readDouble();
+    };
+    FeatureCollectionPBuffer.Scale.write = function (obj, pbf) {
+      if (obj.xScale) pbf.writeDoubleField(1, obj.xScale);
+      if (obj.yScale) pbf.writeDoubleField(2, obj.yScale);
+      if (obj.mScale) pbf.writeDoubleField(3, obj.mScale);
+      if (obj.zScale) pbf.writeDoubleField(4, obj.zScale);
+    };
+
+    // FeatureCollectionPBuffer.Translate ========================================
+
+    FeatureCollectionPBuffer.Translate = {};
+
+    FeatureCollectionPBuffer.Translate.read = function (pbf, end) {
+      return pbf.readFields(FeatureCollectionPBuffer.Translate._readField, {xTranslate: 0, yTranslate: 0, mTranslate: 0, zTranslate: 0}, end);
+    };
+    FeatureCollectionPBuffer.Translate._readField = function (tag, obj, pbf) {
+      if (tag === 1) obj.xTranslate = pbf.readDouble();
+      else if (tag === 2) obj.yTranslate = pbf.readDouble();
+      else if (tag === 3) obj.mTranslate = pbf.readDouble();
+      else if (tag === 4) obj.zTranslate = pbf.readDouble();
+    };
+    FeatureCollectionPBuffer.Translate.write = function (obj, pbf) {
+      if (obj.xTranslate) pbf.writeDoubleField(1, obj.xTranslate);
+      if (obj.yTranslate) pbf.writeDoubleField(2, obj.yTranslate);
+      if (obj.mTranslate) pbf.writeDoubleField(3, obj.mTranslate);
+      if (obj.zTranslate) pbf.writeDoubleField(4, obj.zTranslate);
+    };
+
+    // FeatureCollectionPBuffer.Transform ========================================
+
+    FeatureCollectionPBuffer.Transform = {};
+
+    FeatureCollectionPBuffer.Transform.read = function (pbf, end) {
+      return pbf.readFields(FeatureCollectionPBuffer.Transform._readField, {quantizeOriginPostion: 0, scale: null, translate: null}, end);
+    };
+    FeatureCollectionPBuffer.Transform._readField = function (tag, obj, pbf) {
+      if (tag === 1) obj.quantizeOriginPostion = pbf.readVarint();
+      else if (tag === 2) obj.scale = FeatureCollectionPBuffer.Scale.read(pbf, pbf.readVarint() + pbf.pos);
+      else if (tag === 3) obj.translate = FeatureCollectionPBuffer.Translate.read(pbf, pbf.readVarint() + pbf.pos);
+    };
+    FeatureCollectionPBuffer.Transform.write = function (obj, pbf) {
+      if (obj.quantizeOriginPostion) pbf.writeVarintField(1, obj.quantizeOriginPostion);
+      if (obj.scale) pbf.writeMessage(2, FeatureCollectionPBuffer.Scale.write, obj.scale);
+      if (obj.translate) pbf.writeMessage(3, FeatureCollectionPBuffer.Translate.write, obj.translate);
+    };
+
+    // FeatureCollectionPBuffer.FeatureResult ========================================
+
+    FeatureCollectionPBuffer.FeatureResult = {};
+
+    FeatureCollectionPBuffer.FeatureResult.read = function (pbf, end) {
+      return pbf.readFields(FeatureCollectionPBuffer.FeatureResult._readField, {objectIdFieldName: '', uniqueIdField: null, globalIdFieldName: '', geohashFieldName: '', geometryProperties: null, serverGens: null, geometryType: 0, spatialReference: null, exceededTransferLimit: false, hasZ: false, hasM: false, transform: null, fields: [], values: [], features: []}, end);
+    };
+    FeatureCollectionPBuffer.FeatureResult._readField = function (tag, obj, pbf) {
+      if (tag === 1) obj.objectIdFieldName = pbf.readString();
+      else if (tag === 2) obj.uniqueIdField = FeatureCollectionPBuffer.UniqueIdField.read(pbf, pbf.readVarint() + pbf.pos);
+      else if (tag === 3) obj.globalIdFieldName = pbf.readString();
+      else if (tag === 4) obj.geohashFieldName = pbf.readString();
+      else if (tag === 5) obj.geometryProperties = FeatureCollectionPBuffer.GeometryProperties.read(pbf, pbf.readVarint() + pbf.pos);
+      else if (tag === 6) obj.serverGens = FeatureCollectionPBuffer.ServerGens.read(pbf, pbf.readVarint() + pbf.pos);
+      else if (tag === 7) obj.geometryType = pbf.readVarint();
+      else if (tag === 8) obj.spatialReference = FeatureCollectionPBuffer.SpatialReference.read(pbf, pbf.readVarint() + pbf.pos);
+      else if (tag === 9) obj.exceededTransferLimit = pbf.readBoolean();
+      else if (tag === 10) obj.hasZ = pbf.readBoolean();
+      else if (tag === 11) obj.hasM = pbf.readBoolean();
+      else if (tag === 12) obj.transform = FeatureCollectionPBuffer.Transform.read(pbf, pbf.readVarint() + pbf.pos);
+      else if (tag === 13) obj.fields.push(FeatureCollectionPBuffer.Field.read(pbf, pbf.readVarint() + pbf.pos));
+      else if (tag === 14) obj.values.push(FeatureCollectionPBuffer.Value.read(pbf, pbf.readVarint() + pbf.pos));
+      else if (tag === 15) obj.features.push(FeatureCollectionPBuffer.Feature.read(pbf, pbf.readVarint() + pbf.pos));
+    };
+    FeatureCollectionPBuffer.FeatureResult.write = function (obj, pbf) {
+      if (obj.objectIdFieldName) pbf.writeStringField(1, obj.objectIdFieldName);
+      if (obj.uniqueIdField) pbf.writeMessage(2, FeatureCollectionPBuffer.UniqueIdField.write, obj.uniqueIdField);
+      if (obj.globalIdFieldName) pbf.writeStringField(3, obj.globalIdFieldName);
+      if (obj.geohashFieldName) pbf.writeStringField(4, obj.geohashFieldName);
+      if (obj.geometryProperties) pbf.writeMessage(5, FeatureCollectionPBuffer.GeometryProperties.write, obj.geometryProperties);
+      if (obj.serverGens) pbf.writeMessage(6, FeatureCollectionPBuffer.ServerGens.write, obj.serverGens);
+      if (obj.geometryType) pbf.writeVarintField(7, obj.geometryType);
+      if (obj.spatialReference) pbf.writeMessage(8, FeatureCollectionPBuffer.SpatialReference.write, obj.spatialReference);
+      if (obj.exceededTransferLimit) pbf.writeBooleanField(9, obj.exceededTransferLimit);
+      if (obj.hasZ) pbf.writeBooleanField(10, obj.hasZ);
+      if (obj.hasM) pbf.writeBooleanField(11, obj.hasM);
+      if (obj.transform) pbf.writeMessage(12, FeatureCollectionPBuffer.Transform.write, obj.transform);
+      if (obj.fields) for (var i = 0; i < obj.fields.length; i++) pbf.writeMessage(13, FeatureCollectionPBuffer.Field.write, obj.fields[i]);
+      if (obj.values) for (i = 0; i < obj.values.length; i++) pbf.writeMessage(14, FeatureCollectionPBuffer.Value.write, obj.values[i]);
+      if (obj.features) for (i = 0; i < obj.features.length; i++) pbf.writeMessage(15, FeatureCollectionPBuffer.Feature.write, obj.features[i]);
+    };
+
+    // FeatureCollectionPBuffer.CountResult ========================================
+
+    FeatureCollectionPBuffer.CountResult = {};
+
+    FeatureCollectionPBuffer.CountResult.read = function (pbf, end) {
+      return pbf.readFields(FeatureCollectionPBuffer.CountResult._readField, {count: 0}, end);
+    };
+    FeatureCollectionPBuffer.CountResult._readField = function (tag, obj, pbf) {
+      if (tag === 1) obj.count = pbf.readVarint();
+    };
+    FeatureCollectionPBuffer.CountResult.write = function (obj, pbf) {
+      if (obj.count) pbf.writeVarintField(1, obj.count);
+    };
+
+    // FeatureCollectionPBuffer.ObjectIdsResult ========================================
+
+    FeatureCollectionPBuffer.ObjectIdsResult = {};
+
+    FeatureCollectionPBuffer.ObjectIdsResult.read = function (pbf, end) {
+      return pbf.readFields(FeatureCollectionPBuffer.ObjectIdsResult._readField, {objectIdFieldName: '', serverGens: null, objectIds: []}, end);
+    };
+    FeatureCollectionPBuffer.ObjectIdsResult._readField = function (tag, obj, pbf) {
+      if (tag === 1) obj.objectIdFieldName = pbf.readString();
+      else if (tag === 2) obj.serverGens = FeatureCollectionPBuffer.ServerGens.read(pbf, pbf.readVarint() + pbf.pos);
+      else if (tag === 3) pbf.readPackedVarint(obj.objectIds);
+    };
+    FeatureCollectionPBuffer.ObjectIdsResult.write = function (obj, pbf) {
+      if (obj.objectIdFieldName) pbf.writeStringField(1, obj.objectIdFieldName);
+      if (obj.serverGens) pbf.writeMessage(2, FeatureCollectionPBuffer.ServerGens.write, obj.serverGens);
+      if (obj.objectIds) pbf.writePackedVarint(3, obj.objectIds);
+    };
+
+    // FeatureCollectionPBuffer.QueryResult ========================================
+
+    FeatureCollectionPBuffer.QueryResult = {};
+
+    FeatureCollectionPBuffer.QueryResult.read = function (pbf, end) {
+      return pbf.readFields(FeatureCollectionPBuffer.QueryResult._readField, {featureResult: null, Results: null, countResult: null, idsResult: null}, end);
+    };
+    FeatureCollectionPBuffer.QueryResult._readField = function (tag, obj, pbf) {
+      if (tag === 1) obj.featureResult = FeatureCollectionPBuffer.FeatureResult.read(pbf, pbf.readVarint() + pbf.pos), obj.Results = 'featureResult';
+      else if (tag === 2) obj.countResult = FeatureCollectionPBuffer.CountResult.read(pbf, pbf.readVarint() + pbf.pos), obj.Results = 'countResult';
+      else if (tag === 3) obj.idsResult = FeatureCollectionPBuffer.ObjectIdsResult.read(pbf, pbf.readVarint() + pbf.pos), obj.Results = 'idsResult';
+    };
+    FeatureCollectionPBuffer.QueryResult.write = function (obj, pbf) {
+      if (obj.featureResult) pbf.writeMessage(1, FeatureCollectionPBuffer.FeatureResult.write, obj.featureResult);
+      if (obj.countResult) pbf.writeMessage(2, FeatureCollectionPBuffer.CountResult.write, obj.countResult);
+      if (obj.idsResult) pbf.writeMessage(3, FeatureCollectionPBuffer.ObjectIdsResult.write, obj.idsResult);
+    };
+
+    function decode(featureCollectionBuffer) {
+      let decodedObject;
+      try {
+        decodedObject = FeatureCollectionPBuffer.read(new Pbf(featureCollectionBuffer));
+      } catch (error) {
+        throw new Error('Could not parse arcgis-pbf buffer')
+      }
+      const featureResult = decodedObject.queryResult.featureResult;
+      const transform = featureResult.transform;
+      const geometryType = featureResult.geometryType;
+      const objectIdField = featureResult.objectIdFieldName;
+
+      // Wires up the field keynames
+      const fields = featureResult.fields;
+      for (let index = 0; index < fields.length; index++) {
+        const field = fields[index];
+        field.keyName = getKeyName(field);
+      }
+
+      const out = {
+        type: 'FeatureCollection',
+        features: []
+      };
+
+      const geometryParser = getGeometryParser(geometryType);
+
+      const featureLen = featureResult.features.length;
+      for (let index = 0; index < featureLen; index++) {
+        const f = featureResult.features[index];
+        out.features.push({
+          type: 'Feature',
+          id: getFeatureId(fields, f.attributes, objectIdField),
+          properties: collectAttributes(fields, f.attributes),
+          geometry: f.geometry && geometryParser(f, transform)
+        });
+      }
+
+      return {
+        featureCollection: out,
+        exceededTransferLimit: featureResult.exceededTransferLimit
+      }
+    }
+
+    // * @property {number} esriGeometryTypePoint=0 esriGeometryTypePoint value
+    // * @property {number} esriGeometryTypeMultipoint=1 esriGeometryTypeMultipoint value
+    // * @property {number} esriGeometryTypePolyline=2 esriGeometryTypePolyline value
+    // * @property {number} esriGeometryTypePolygon=3 esriGeometryTypePolygon value
+    // * @property {number} esriGeometryTypeMultipatch=4 esriGeometryTypeMultipatch value
+    // * @property {number} esriGeometryTypeNone=127 esriGeometryTypeNone value
+    function getGeometryParser (featureType) {
+      switch (featureType) {
+      case 3:
+        return createPolygon
+      case 2:
+        return createLine
+      case 0:
+        return createPoint
+      default:
+        return createPolygon
+      }
+    }
+
+    function createPoint (f, transform) {
+      const p = {
+        type: 'Point',
+        coordinates: transformTuple(f.geometry.coords, transform)
+      };
+      return p
+    }
+
+    function createLine (f, transform) {
+      let l = null;
+      const lengths = f.geometry.lengths.length;
+
+      if (lengths === 1) {
+        l = {
+          type: 'LineString',
+          coordinates: createLinearRing(f.geometry.coords, transform, 0, f.geometry.lengths[0] * 2)
+        };
+      } else if (lengths > 1) {
+        l = {
+          type: 'MultiLineString',
+          coordinates: []
+        };
+        let startPoint = 0;
+        for (let index = 0; index < lengths; index++) {
+          const stopPoint = startPoint + (f.geometry.lengths[index] * 2);
+          const line = createLinearRing(f.geometry.coords, transform, startPoint, stopPoint);
+          l.coordinates.push(line);
+          startPoint = stopPoint;
+        }
+      }
+      return l
+    }
+
+    function createPolygon (f, transform) {
+      const lengths = f.geometry.lengths.length;
+
+      const p = {
+        type: 'Polygon',
+        coordinates: []
+      };
+
+      if (lengths === 1) {
+        p.coordinates.push(createLinearRing(f.geometry.coords, transform, 0, f.geometry.lengths[0] * 2));
+      } else {
+        p.type = 'MultiPolygon';
+
+        let startPoint = 0;
+        for (let index = 0; index < lengths; index++) {
+          const stopPoint = startPoint + (f.geometry.lengths[index] * 2);
+          const ring = createLinearRing(f.geometry.coords, transform, startPoint, stopPoint);
+
+          // Check if the ring is clockwise, if so it's an outer ring
+          // If it's counter-clockwise its a hole and so push it to the prev outer ring
+          // This is perhaps a bit naive
+          // see https://github.com/terraformer-js/terraformer/blob/master/packages/arcgis/src/geojson.js
+          // for a fuller example of doing this
+          if (ringIsClockwise(ring)) {
+            p.coordinates.push([ring]);
+          } else if (p.coordinates.length > 0) {
+            p.coordinates[p.coordinates.length - 1].push(ring);
+          }
+          startPoint = stopPoint;
+        }
+      }
+      return p
+    }
+
+    function ringIsClockwise (ringToTest) {
+      let total = 0;
+      let i = 0;
+      const rLength = ringToTest.length;
+      let pt1 = ringToTest[i];
+      let pt2;
+      for (i; i < rLength - 1; i++) {
+        pt2 = ringToTest[i + 1];
+        total += (pt2[0] - pt1[0]) * (pt2[1] + pt1[1]);
+        pt1 = pt2;
+      }
+      return (total >= 0)
+    }
+
+    function createLinearRing (arr, transform, startPoint, stopPoint) {
+      const out = [];
+      if (arr.length === 0) return out
+
+
+      const initialX = arr[startPoint];
+      const initialY = arr[startPoint + 1];
+      out.push(transformTuple([initialX, initialY], transform));
+      let prevX = initialX;
+      let prevY = initialY;
+      for (let i = startPoint + 2; i < stopPoint; i = i + 2) {
+        const x = difference(prevX, arr[i]);
+        const y = difference(prevY, arr[i + 1]);
+        const transformed = transformTuple([x, y], transform);
+        out.push(transformed);
+        prevX = x;
+        prevY = y;
+      }
+      return out
+    }
+
+    function collectAttributes(fields, featureAttributes) {
+      const out = {};
+      for (let i = 0; i < fields.length; i++) {
+        const f = fields[i];
+        if (featureAttributes[i][featureAttributes[i].value_type] !== undefined) out[f.name] = featureAttributes[i][featureAttributes[i].value_type];
+        else out[f.name] = null;
+      }
+      return out
+    }
+
+    function getFeatureId(fields, featureAttributes, featureIdField) {
+      for (let index = 0; index < fields.length; index++) {
+        const field = fields[index];
+        if (field.name === featureIdField) {
+          return featureAttributes[index][featureAttributes[index].value_type]
+        }
+      }
+      return null
+    }
+
+    function getKeyName (fields) {
+      switch (fields.fieldType) {
+      case 1:
+        return 'sintValue'
+      case 2:
+        return 'floatValue'
+      case 3:
+        return 'doubleValue'
+      case 4:
+        return 'stringValue'
+      case 5:
+        return 'sint64Value'
+      case 6:
+        return 'uintValue'
+      default:
+        return null
+      }
+    }
+
+    function transformTuple(coords, transform) {
+
+      let x = coords[0];
+      let y = coords[1];
+
+      let z = coords[2] ? coords[2] : undefined;
+      if (transform.scale) {
+        x *= transform.scale.xScale;
+        y *= -transform.scale.yScale;
+        if (undefined !== z) { z *= transform.scale.zScale; }
+      }
+      if (transform.translate) {
+        x += transform.translate.xTranslate;
+        y += transform.translate.yTranslate;
+        if (undefined !== z) { z += transform.translate.zTranslate; }
+      }
+      const ret = [x, y];
+      if (undefined !== z) { ret.push(z); }
+      return ret;
+    }
+
+    function difference(a, b) {
+      return a + b
+    }
+
     /**
      * FeatureService - Tile-based feature loading from ArcGIS FeatureServers
      *
@@ -2512,7 +4131,7 @@
         const bounds = this._map.getBounds();
         if (!bounds) return;
         const boundsArray = bounds.toArray();
-        const primaryTile = tilebelt__namespace.bboxToTile([boundsArray[0][0], boundsArray[0][1], boundsArray[1][0], boundsArray[1][1]]);
+        const primaryTile = bboxToTile([boundsArray[0][0], boundsArray[0][1], boundsArray[1][0], boundsArray[1][1]]);
         if (this._esriServiceOptions.useServiceBounds) {
           if (this._maxExtent[0] !== -Infinity && !this._doesTileOverlapBbox(this._maxExtent, boundsArray)) {
             return;
@@ -2525,12 +4144,12 @@
         const fc = this._createOrGetFeatureCollection(zoomLevel);
         let tilesToRequest = [];
         if (primaryTile[2] < zoomLevel) {
-          let candidateTiles = tilebelt__namespace.getChildren(primaryTile);
+          let candidateTiles = getChildren(primaryTile);
           let minZoomOfCandidates = candidateTiles[0][2];
           while (minZoomOfCandidates < zoomLevel) {
             const newCandidateTiles = [];
             candidateTiles.forEach(t => {
-              newCandidateTiles.push(...tilebelt__namespace.getChildren(t));
+              newCandidateTiles.push(...getChildren(t));
             });
             candidateTiles = newCandidateTiles;
             minZoomOfCandidates = candidateTiles[0][2];
@@ -2545,7 +4164,7 @@
         }
         // Filter out already fetched tiles
         tilesToRequest = tilesToRequest.filter(tile => {
-          const quadKey = tilebelt__namespace.tileToQuadkey(tile);
+          const quadKey = tileToQuadkey(tile);
           if (zoomLevelIndex.has(quadKey)) {
             return false;
           }
@@ -2592,7 +4211,7 @@
         return `${from ?? ''},${to}`;
       }
       async _getTile(tile, tolerance) {
-        const tileBounds = tilebelt__namespace.tileToBBOX(tile);
+        const tileBounds = tileToBBOX(tile);
         const extent = {
           spatialReference: {
             latestWkid: 4326,
@@ -2635,7 +4254,7 @@
           if (this._format === 'pbf') {
             const buffer = await response.arrayBuffer();
             try {
-              const decoded = tileDecode(new Uint8Array(buffer));
+              const decoded = decode(new Uint8Array(buffer));
               return decoded.featureCollection;
             } catch {
               console.error('Could not parse arcgis buffer. Please check the url you requested.');
@@ -2659,7 +4278,7 @@
         }
       }
       _doesTileOverlapBbox(tile, bbox) {
-        const tileBounds = tile.length === 4 ? tile : tilebelt__namespace.tileToBBOX(tile);
+        const tileBounds = tile.length === 4 ? tile : tileToBBOX(tile);
         if (tileBounds[2] < bbox[0][0]) return false;
         if (tileBounds[0] > bbox[1][0]) return false;
         if (tileBounds[3] < bbox[0][1]) return false;
@@ -3987,7 +5606,8 @@
           const bounds = map.getBounds().toArray();
           this.params.mapExtent = [bounds[0][0], bounds[0][1], bounds[1][0], bounds[1][1]].join(',');
           const canvas = map.getCanvas();
-          this.params.imageDisplay = [canvas.width, canvas.height, 96].join(',');
+          const dpi = this.options?.dpi ?? 96;
+          this.params.imageDisplay = [canvas.width, canvas.height, dpi].join(',');
         } catch (error) {
           console.warn('Could not extract map extent and display info:', error);
         }