@loaders.gl/flatgeobuf 3.1.0-beta.5 → 3.1.2

package/dist/bundle.js

@@ -1,4346 +1,5 @@
-(() => {
-  var __create = Object.create;
-  var __defProp = Object.defineProperty;
-  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-  var __getOwnPropNames = Object.getOwnPropertyNames;
-  var __getProtoOf = Object.getPrototypeOf;
-  var __hasOwnProp = Object.prototype.hasOwnProperty;
-  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
-  var __esm = (fn, res) => function __init() {
-    return fn && (res = (0, fn[Object.keys(fn)[0]])(fn = 0)), res;
-  };
-  var __commonJS = (cb, mod) => function __require() {
-    return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-  };
-  var __export = (target, all) => {
-    __markAsModule(target);
-    for (var name in all)
-      __defProp(target, name, { get: all[name], enumerable: true });
-  };
-  var __reExport = (target, module, desc) => {
-    if (module && typeof module === "object" || typeof module === "function") {
-      for (let key of __getOwnPropNames(module))
-        if (!__hasOwnProp.call(target, key) && key !== "default")
-          __defProp(target, key, { get: () => module[key], enumerable: !(desc = __getOwnPropDesc(module, key)) || desc.enumerable });
-    }
-    return target;
-  };
-  var __toModule = (module) => {
-    return __reExport(__markAsModule(__defProp(module != null ? __create(__getProtoOf(module)) : {}, "default", module && module.__esModule && "default" in module ? { get: () => module.default, enumerable: true } : { value: module, enumerable: true })), module);
-  };
-
-  // src/flatgeobuf-loader.ts
-  var VERSION, FlatGeobufLoader;
-  var init_flatgeobuf_loader = __esm({
-    "src/flatgeobuf-loader.ts"() {
-      VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-      FlatGeobufLoader = {
-        id: "flatgeobuf",
-        name: "FlatGeobuf",
-        module: "flatgeobuf",
-        version: VERSION,
-        worker: true,
-        extensions: ["fgb"],
-        mimeTypes: ["application/octet-stream"],
-        category: "geometry",
-        options: {
-          flatgeobuf: {}
-        }
-      };
-    }
-  });
-
-  // ../../node_modules/flatgeobuf/node_modules/web-streams-polyfill/dist/ponyfill.js
-  var require_ponyfill = __commonJS({
-    "../../node_modules/flatgeobuf/node_modules/web-streams-polyfill/dist/ponyfill.js"(exports, module) {
-      (function(global, factory) {
-        typeof exports === "object" && typeof module !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global = global || self, factory(global.WebStreamsPolyfill = {}));
-      })(exports, function(exports2) {
-        "use strict";
-        var SymbolPolyfill = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? Symbol : function(description) {
-          return "Symbol(" + description + ")";
-        };
-        function noop() {
-        }
-        var NumberIsNaN = Number.isNaN || function(x) {
-          return x !== x;
-        };
-        var rethrowAssertionErrorRejection = noop;
-        function typeIsObject(x) {
-          return typeof x === "object" && x !== null || typeof x === "function";
-        }
-        function createArrayFromList(elements) {
-          return elements.slice();
-        }
-        function ArrayBufferCopy(dest, destOffset, src, srcOffset, n) {
-          new Uint8Array(dest).set(new Uint8Array(src, srcOffset, n), destOffset);
-        }
-        function IsFiniteNonNegativeNumber(v) {
-          if (IsNonNegativeNumber(v) === false) {
-            return false;
-          }
-          if (v === Infinity) {
-            return false;
-          }
-          return true;
-        }
-        function IsNonNegativeNumber(v) {
-          if (typeof v !== "number") {
-            return false;
-          }
-          if (NumberIsNaN(v)) {
-            return false;
-          }
-          if (v < 0) {
-            return false;
-          }
-          return true;
-        }
-        function Call(F, V, args) {
-          if (typeof F !== "function") {
-            throw new TypeError("Argument is not a function");
-          }
-          return Function.prototype.apply.call(F, V, args);
-        }
-        function CreateAlgorithmFromUnderlyingMethod(underlyingObject, methodName, algoArgCount, extraArgs) {
-          var method = underlyingObject[methodName];
-          if (method !== void 0) {
-            if (typeof method !== "function") {
-              throw new TypeError(method + " is not a method");
-            }
-            switch (algoArgCount) {
-              case 0: {
-                return function() {
-                  return PromiseCall(method, underlyingObject, extraArgs);
-                };
-              }
-              case 1: {
-                return function(arg) {
-                  var fullArgs = [arg].concat(extraArgs);
-                  return PromiseCall(method, underlyingObject, fullArgs);
-                };
-              }
-            }
-          }
-          return function() {
-            return promiseResolvedWith(void 0);
-          };
-        }
-        function InvokeOrNoop(O, P, args) {
-          var method = O[P];
-          if (method === void 0) {
-            return void 0;
-          }
-          return Call(method, O, args);
-        }
-        function PromiseCall(F, V, args) {
-          try {
-            return promiseResolvedWith(Call(F, V, args));
-          } catch (value) {
-            return promiseRejectedWith(value);
-          }
-        }
-        function TransferArrayBuffer(O) {
-          return O;
-        }
-        function IsDetachedBuffer(O) {
-          return false;
-        }
-        function ValidateAndNormalizeHighWaterMark(highWaterMark) {
-          highWaterMark = Number(highWaterMark);
-          if (NumberIsNaN(highWaterMark) || highWaterMark < 0) {
-            throw new RangeError("highWaterMark property of a queuing strategy must be non-negative and non-NaN");
-          }
-          return highWaterMark;
-        }
-        function MakeSizeAlgorithmFromSizeFunction(size) {
-          if (size === void 0) {
-            return function() {
-              return 1;
-            };
-          }
-          if (typeof size !== "function") {
-            throw new TypeError("size property of a queuing strategy must be a function");
-          }
-          return function(chunk) {
-            return size(chunk);
-          };
-        }
-        var originalPromise = Promise;
-        var originalPromiseThen = Promise.prototype.then;
-        var originalPromiseResolve = Promise.resolve.bind(originalPromise);
-        var originalPromiseReject = Promise.reject.bind(originalPromise);
-        function newPromise(executor) {
-          return new originalPromise(executor);
-        }
-        function promiseResolvedWith(value) {
-          return originalPromiseResolve(value);
-        }
-        function promiseRejectedWith(reason) {
-          return originalPromiseReject(reason);
-        }
-        function PerformPromiseThen(promise, onFulfilled, onRejected) {
-          return originalPromiseThen.call(promise, onFulfilled, onRejected);
-        }
-        function uponPromise(promise, onFulfilled, onRejected) {
-          PerformPromiseThen(PerformPromiseThen(promise, onFulfilled, onRejected), void 0, rethrowAssertionErrorRejection);
-        }
-        function uponFulfillment(promise, onFulfilled) {
-          uponPromise(promise, onFulfilled);
-        }
-        function uponRejection(promise, onRejected) {
-          uponPromise(promise, void 0, onRejected);
-        }
-        function transformPromiseWith(promise, fulfillmentHandler, rejectionHandler) {
-          return PerformPromiseThen(promise, fulfillmentHandler, rejectionHandler);
-        }
-        function setPromiseIsHandledToTrue(promise) {
-          PerformPromiseThen(promise, void 0, rethrowAssertionErrorRejection);
-        }
-        var QUEUE_MAX_ARRAY_SIZE = 16384;
-        var SimpleQueue = function() {
-          function SimpleQueue2() {
-            this._cursor = 0;
-            this._size = 0;
-            this._front = {
-              _elements: [],
-              _next: void 0
-            };
-            this._back = this._front;
-            this._cursor = 0;
-            this._size = 0;
-          }
-          Object.defineProperty(SimpleQueue2.prototype, "length", {
-            get: function() {
-              return this._size;
-            },
-            enumerable: true,
-            configurable: true
-          });
-          SimpleQueue2.prototype.push = function(element) {
-            var oldBack = this._back;
-            var newBack = oldBack;
-            if (oldBack._elements.length === QUEUE_MAX_ARRAY_SIZE - 1) {
-              newBack = {
-                _elements: [],
-                _next: void 0
-              };
-            }
-            oldBack._elements.push(element);
-            if (newBack !== oldBack) {
-              this._back = newBack;
-              oldBack._next = newBack;
-            }
-            ++this._size;
-          };
-          SimpleQueue2.prototype.shift = function() {
-            var oldFront = this._front;
-            var newFront = oldFront;
-            var oldCursor = this._cursor;
-            var newCursor = oldCursor + 1;
-            var elements = oldFront._elements;
-            var element = elements[oldCursor];
-            if (newCursor === QUEUE_MAX_ARRAY_SIZE) {
-              newFront = oldFront._next;
-              newCursor = 0;
-            }
-            --this._size;
-            this._cursor = newCursor;
-            if (oldFront !== newFront) {
-              this._front = newFront;
-            }
-            elements[oldCursor] = void 0;
-            return element;
-          };
-          SimpleQueue2.prototype.forEach = function(callback) {
-            var i = this._cursor;
-            var node = this._front;
-            var elements = node._elements;
-            while (i !== elements.length || node._next !== void 0) {
-              if (i === elements.length) {
-                node = node._next;
-                elements = node._elements;
-                i = 0;
-                if (elements.length === 0) {
-                  break;
-                }
-              }
-              callback(elements[i]);
-              ++i;
-            }
-          };
-          SimpleQueue2.prototype.peek = function() {
-            var front = this._front;
-            var cursor = this._cursor;
-            return front._elements[cursor];
-          };
-          return SimpleQueue2;
-        }();
-        function ReadableStreamCreateReadResult(value, done, forAuthorCode) {
-          var prototype = null;
-          if (forAuthorCode === true) {
-            prototype = Object.prototype;
-          }
-          var obj = Object.create(prototype);
-          obj.value = value;
-          obj.done = done;
-          return obj;
-        }
-        function ReadableStreamReaderGenericInitialize(reader, stream) {
-          reader._forAuthorCode = true;
-          reader._ownerReadableStream = stream;
-          stream._reader = reader;
-          if (stream._state === "readable") {
-            defaultReaderClosedPromiseInitialize(reader);
-          } else if (stream._state === "closed") {
-            defaultReaderClosedPromiseInitializeAsResolved(reader);
-          } else {
-            defaultReaderClosedPromiseInitializeAsRejected(reader, stream._storedError);
-          }
-        }
-        function ReadableStreamReaderGenericCancel(reader, reason) {
-          var stream = reader._ownerReadableStream;
-          return ReadableStreamCancel(stream, reason);
-        }
-        function ReadableStreamReaderGenericRelease(reader) {
-          if (reader._ownerReadableStream._state === "readable") {
-            defaultReaderClosedPromiseReject(reader, new TypeError("Reader was released and can no longer be used to monitor the stream's closedness"));
-          } else {
-            defaultReaderClosedPromiseResetToRejected(reader, new TypeError("Reader was released and can no longer be used to monitor the stream's closedness"));
-          }
-          reader._ownerReadableStream._reader = void 0;
-          reader._ownerReadableStream = void 0;
-        }
-        function readerLockException(name) {
-          return new TypeError("Cannot " + name + " a stream using a released reader");
-        }
-        function defaultReaderClosedPromiseInitialize(reader) {
-          reader._closedPromise = newPromise(function(resolve, reject) {
-            reader._closedPromise_resolve = resolve;
-            reader._closedPromise_reject = reject;
-          });
-        }
-        function defaultReaderClosedPromiseInitializeAsRejected(reader, reason) {
-          defaultReaderClosedPromiseInitialize(reader);
-          defaultReaderClosedPromiseReject(reader, reason);
-        }
-        function defaultReaderClosedPromiseInitializeAsResolved(reader) {
-          defaultReaderClosedPromiseInitialize(reader);
-          defaultReaderClosedPromiseResolve(reader);
-        }
-        function defaultReaderClosedPromiseReject(reader, reason) {
-          setPromiseIsHandledToTrue(reader._closedPromise);
-          reader._closedPromise_reject(reason);
-          reader._closedPromise_resolve = void 0;
-          reader._closedPromise_reject = void 0;
-        }
-        function defaultReaderClosedPromiseResetToRejected(reader, reason) {
-          defaultReaderClosedPromiseInitializeAsRejected(reader, reason);
-        }
-        function defaultReaderClosedPromiseResolve(reader) {
-          reader._closedPromise_resolve(void 0);
-          reader._closedPromise_resolve = void 0;
-          reader._closedPromise_reject = void 0;
-        }
-        var CancelSteps = SymbolPolyfill("[[CancelSteps]]");
-        var PullSteps = SymbolPolyfill("[[PullSteps]]");
-        function AcquireReadableStreamDefaultReader(stream, forAuthorCode) {
-          if (forAuthorCode === void 0) {
-            forAuthorCode = false;
-          }
-          var reader = new ReadableStreamDefaultReader(stream);
-          reader._forAuthorCode = forAuthorCode;
-          return reader;
-        }
-        function ReadableStreamAddReadRequest(stream) {
-          var promise = newPromise(function(resolve, reject) {
-            var readRequest = {
-              _resolve: resolve,
-              _reject: reject
-            };
-            stream._reader._readRequests.push(readRequest);
-          });
-          return promise;
-        }
-        function ReadableStreamFulfillReadRequest(stream, chunk, done) {
-          var reader = stream._reader;
-          var readRequest = reader._readRequests.shift();
-          readRequest._resolve(ReadableStreamCreateReadResult(chunk, done, reader._forAuthorCode));
-        }
-        function ReadableStreamGetNumReadRequests(stream) {
-          return stream._reader._readRequests.length;
-        }
-        function ReadableStreamHasDefaultReader(stream) {
-          var reader = stream._reader;
-          if (reader === void 0) {
-            return false;
-          }
-          if (!IsReadableStreamDefaultReader(reader)) {
-            return false;
-          }
-          return true;
-        }
-        var ReadableStreamDefaultReader = function() {
-          function ReadableStreamDefaultReader2(stream) {
-            if (IsReadableStream(stream) === false) {
-              throw new TypeError("ReadableStreamDefaultReader can only be constructed with a ReadableStream instance");
-            }
-            if (IsReadableStreamLocked(stream) === true) {
-              throw new TypeError("This stream has already been locked for exclusive reading by another reader");
-            }
-            ReadableStreamReaderGenericInitialize(this, stream);
-            this._readRequests = new SimpleQueue();
-          }
-          Object.defineProperty(ReadableStreamDefaultReader2.prototype, "closed", {
-            get: function() {
-              if (!IsReadableStreamDefaultReader(this)) {
-                return promiseRejectedWith(defaultReaderBrandCheckException("closed"));
-              }
-              return this._closedPromise;
-            },
-            enumerable: true,
-            configurable: true
-          });
-          ReadableStreamDefaultReader2.prototype.cancel = function(reason) {
-            if (!IsReadableStreamDefaultReader(this)) {
-              return promiseRejectedWith(defaultReaderBrandCheckException("cancel"));
-            }
-            if (this._ownerReadableStream === void 0) {
-              return promiseRejectedWith(readerLockException("cancel"));
-            }
-            return ReadableStreamReaderGenericCancel(this, reason);
-          };
-          ReadableStreamDefaultReader2.prototype.read = function() {
-            if (!IsReadableStreamDefaultReader(this)) {
-              return promiseRejectedWith(defaultReaderBrandCheckException("read"));
-            }
-            if (this._ownerReadableStream === void 0) {
-              return promiseRejectedWith(readerLockException("read from"));
-            }
-            return ReadableStreamDefaultReaderRead(this);
-          };
-          ReadableStreamDefaultReader2.prototype.releaseLock = function() {
-            if (!IsReadableStreamDefaultReader(this)) {
-              throw defaultReaderBrandCheckException("releaseLock");
-            }
-            if (this._ownerReadableStream === void 0) {
-              return;
-            }
-            if (this._readRequests.length > 0) {
-              throw new TypeError("Tried to release a reader lock when that reader has pending read() calls un-settled");
-            }
-            ReadableStreamReaderGenericRelease(this);
-          };
-          return ReadableStreamDefaultReader2;
-        }();
-        function IsReadableStreamDefaultReader(x) {
-          if (!typeIsObject(x)) {
-            return false;
-          }
-          if (!Object.prototype.hasOwnProperty.call(x, "_readRequests")) {
-            return false;
-          }
-          return true;
-        }
-        function ReadableStreamDefaultReaderRead(reader) {
-          var stream = reader._ownerReadableStream;
-          stream._disturbed = true;
-          if (stream._state === "closed") {
-            return promiseResolvedWith(ReadableStreamCreateReadResult(void 0, true, reader._forAuthorCode));
-          }
-          if (stream._state === "errored") {
-            return promiseRejectedWith(stream._storedError);
-          }
-          return stream._readableStreamController[PullSteps]();
-        }
-        function defaultReaderBrandCheckException(name) {
-          return new TypeError("ReadableStreamDefaultReader.prototype." + name + " can only be used on a ReadableStreamDefaultReader");
-        }
-        var _a;
-        var AsyncIteratorPrototype;
-        if (typeof SymbolPolyfill.asyncIterator === "symbol") {
-          AsyncIteratorPrototype = (_a = {}, _a[SymbolPolyfill.asyncIterator] = function() {
-            return this;
-          }, _a);
-          Object.defineProperty(AsyncIteratorPrototype, SymbolPolyfill.asyncIterator, { enumerable: false });
-        }
-        var ReadableStreamAsyncIteratorPrototype = {
-          next: function() {
-            if (IsReadableStreamAsyncIterator(this) === false) {
-              return promiseRejectedWith(streamAsyncIteratorBrandCheckException("next"));
-            }
-            var reader = this._asyncIteratorReader;
-            if (reader._ownerReadableStream === void 0) {
-              return promiseRejectedWith(readerLockException("iterate"));
-            }
-            return transformPromiseWith(ReadableStreamDefaultReaderRead(reader), function(result) {
-              var done = result.done;
-              if (done) {
-                ReadableStreamReaderGenericRelease(reader);
-              }
-              var value = result.value;
-              return ReadableStreamCreateReadResult(value, done, true);
-            });
-          },
-          return: function(value) {
-            if (IsReadableStreamAsyncIterator(this) === false) {
-              return promiseRejectedWith(streamAsyncIteratorBrandCheckException("next"));
-            }
-            var reader = this._asyncIteratorReader;
-            if (reader._ownerReadableStream === void 0) {
-              return promiseRejectedWith(readerLockException("finish iterating"));
-            }
-            if (reader._readRequests.length > 0) {
-              return promiseRejectedWith(new TypeError("Tried to release a reader lock when that reader has pending read() calls un-settled"));
-            }
-            if (this._preventCancel === false) {
-              var result = ReadableStreamReaderGenericCancel(reader, value);
-              ReadableStreamReaderGenericRelease(reader);
-              return transformPromiseWith(result, function() {
-                return ReadableStreamCreateReadResult(value, true, true);
-              });
-            }
-            ReadableStreamReaderGenericRelease(reader);
-            return promiseResolvedWith(ReadableStreamCreateReadResult(value, true, true));
-          }
-        };
-        if (AsyncIteratorPrototype !== void 0) {
-          Object.setPrototypeOf(ReadableStreamAsyncIteratorPrototype, AsyncIteratorPrototype);
-        }
-        Object.defineProperty(ReadableStreamAsyncIteratorPrototype, "next", { enumerable: false });
-        Object.defineProperty(ReadableStreamAsyncIteratorPrototype, "return", { enumerable: false });
-        function AcquireReadableStreamAsyncIterator(stream, preventCancel) {
-          if (preventCancel === void 0) {
-            preventCancel = false;
-          }
-          var reader = AcquireReadableStreamDefaultReader(stream);
-          var iterator = Object.create(ReadableStreamAsyncIteratorPrototype);
-          iterator._asyncIteratorReader = reader;
-          iterator._preventCancel = Boolean(preventCancel);
-          return iterator;
-        }
-        function IsReadableStreamAsyncIterator(x) {
-          if (!typeIsObject(x)) {
-            return false;
-          }
-          if (!Object.prototype.hasOwnProperty.call(x, "_asyncIteratorReader")) {
-            return false;
-          }
-          return true;
-        }
-        function streamAsyncIteratorBrandCheckException(name) {
-          return new TypeError("ReadableStreamAsyncIterator." + name + " can only be used on a ReadableSteamAsyncIterator");
-        }
-        function DequeueValue(container) {
-          var pair = container._queue.shift();
-          container._queueTotalSize -= pair.size;
-          if (container._queueTotalSize < 0) {
-            container._queueTotalSize = 0;
-          }
-          return pair.value;
-        }
-        function EnqueueValueWithSize(container, value, size) {
-          size = Number(size);
-          if (!IsFiniteNonNegativeNumber(size)) {
-            throw new RangeError("Size must be a finite, non-NaN, non-negative number.");
-          }
-          container._queue.push({ value, size });
-          container._queueTotalSize += size;
-        }
-        function PeekQueueValue(container) {
-          var pair = container._queue.peek();
-          return pair.value;
-        }
-        function ResetQueue(container) {
-          container._queue = new SimpleQueue();
-          container._queueTotalSize = 0;
-        }
-        var AbortSteps = SymbolPolyfill("[[AbortSteps]]");
-        var ErrorSteps = SymbolPolyfill("[[ErrorSteps]]");
-        var WritableStream = function() {
-          function WritableStream2(underlyingSink, strategy) {
-            if (underlyingSink === void 0) {
-              underlyingSink = {};
-            }
-            if (strategy === void 0) {
-              strategy = {};
-            }
-            InitializeWritableStream(this);
-            var size = strategy.size;
-            var highWaterMark = strategy.highWaterMark;
-            var type = underlyingSink.type;
-            if (type !== void 0) {
-              throw new RangeError("Invalid type is specified");
-            }
-            var sizeAlgorithm = MakeSizeAlgorithmFromSizeFunction(size);
-            if (highWaterMark === void 0) {
-              highWaterMark = 1;
-            }
-            highWaterMark = ValidateAndNormalizeHighWaterMark(highWaterMark);
-            SetUpWritableStreamDefaultControllerFromUnderlyingSink(this, underlyingSink, highWaterMark, sizeAlgorithm);
-          }
-          Object.defineProperty(WritableStream2.prototype, "locked", {
-            get: function() {
-              if (IsWritableStream(this) === false) {
-                throw streamBrandCheckException("locked");
-              }
-              return IsWritableStreamLocked(this);
-            },
-            enumerable: true,
-            configurable: true
-          });
-          WritableStream2.prototype.abort = function(reason) {
-            if (IsWritableStream(this) === false) {
-              return promiseRejectedWith(streamBrandCheckException("abort"));
-            }
-            if (IsWritableStreamLocked(this) === true) {
-              return promiseRejectedWith(new TypeError("Cannot abort a stream that already has a writer"));
-            }
-            return WritableStreamAbort(this, reason);
-          };
-          WritableStream2.prototype.close = function() {
-            if (IsWritableStream(this) === false) {
-              return promiseRejectedWith(streamBrandCheckException("close"));
-            }
-            if (IsWritableStreamLocked(this) === true) {
-              return promiseRejectedWith(new TypeError("Cannot close a stream that already has a writer"));
-            }
-            if (WritableStreamCloseQueuedOrInFlight(this) === true) {
-              return promiseRejectedWith(new TypeError("Cannot close an already-closing stream"));
-            }
-            return WritableStreamClose(this);
-          };
-          WritableStream2.prototype.getWriter = function() {
-            if (IsWritableStream(this) === false) {
-              throw streamBrandCheckException("getWriter");
-            }
-            return AcquireWritableStreamDefaultWriter(this);
-          };
-          return WritableStream2;
-        }();
-        function AcquireWritableStreamDefaultWriter(stream) {
-          return new WritableStreamDefaultWriter(stream);
-        }
-        function CreateWritableStream(startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm) {
-          if (highWaterMark === void 0) {
-            highWaterMark = 1;
-          }
-          if (sizeAlgorithm === void 0) {
-            sizeAlgorithm = function() {
-              return 1;
-            };
-          }
-          var stream = Object.create(WritableStream.prototype);
-          InitializeWritableStream(stream);
-          var controller = Object.create(WritableStreamDefaultController.prototype);
-          SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm);
-          return stream;
-        }
-        function InitializeWritableStream(stream) {
-          stream._state = "writable";
-          stream._storedError = void 0;
-          stream._writer = void 0;
-          stream._writableStreamController = void 0;
-          stream._writeRequests = new SimpleQueue();
-          stream._inFlightWriteRequest = void 0;
-          stream._closeRequest = void 0;
-          stream._inFlightCloseRequest = void 0;
-          stream._pendingAbortRequest = void 0;
-          stream._backpressure = false;
-        }
-        function IsWritableStream(x) {
-          if (!typeIsObject(x)) {
-            return false;
-          }
-          if (!Object.prototype.hasOwnProperty.call(x, "_writableStreamController")) {
-            return false;
-          }
-          return true;
-        }
-        function IsWritableStreamLocked(stream) {
-          if (stream._writer === void 0) {
-            return false;
-          }
-          return true;
-        }
-        function WritableStreamAbort(stream, reason) {
-          var state = stream._state;
-          if (state === "closed" || state === "errored") {
-            return promiseResolvedWith(void 0);
-          }
-          if (stream._pendingAbortRequest !== void 0) {
-            return stream._pendingAbortRequest._promise;
-          }
-          var wasAlreadyErroring = false;
-          if (state === "erroring") {
-            wasAlreadyErroring = true;
-            reason = void 0;
-          }
-          var promise = newPromise(function(resolve, reject) {
-            stream._pendingAbortRequest = {
-              _promise: void 0,
-              _resolve: resolve,
-              _reject: reject,
-              _reason: reason,
-              _wasAlreadyErroring: wasAlreadyErroring
-            };
-          });
-          stream._pendingAbortRequest._promise = promise;
-          if (wasAlreadyErroring === false) {
-            WritableStreamStartErroring(stream, reason);
-          }
-          return promise;
-        }
-        function WritableStreamClose(stream) {
-          var state = stream._state;
-          if (state === "closed" || state === "errored") {
-            return promiseRejectedWith(new TypeError("The stream (in " + state + " state) is not in the writable state and cannot be closed"));
-          }
-          var promise = newPromise(function(resolve, reject) {
-            var closeRequest = {
-              _resolve: resolve,
-              _reject: reject
-            };
-            stream._closeRequest = closeRequest;
-          });
-          var writer = stream._writer;
-          if (writer !== void 0 && stream._backpressure === true && state === "writable") {
-            defaultWriterReadyPromiseResolve(writer);
-          }
-          WritableStreamDefaultControllerClose(stream._writableStreamController);
-          return promise;
-        }
-        function WritableStreamAddWriteRequest(stream) {
-          var promise = newPromise(function(resolve, reject) {
-            var writeRequest = {
-              _resolve: resolve,
-              _reject: reject
-            };
-            stream._writeRequests.push(writeRequest);
-          });
-          return promise;
-        }
-        function WritableStreamDealWithRejection(stream, error) {
-          var state = stream._state;
-          if (state === "writable") {
-            WritableStreamStartErroring(stream, error);
-            return;
-          }
-          WritableStreamFinishErroring(stream);
-        }
-        function WritableStreamStartErroring(stream, reason) {
-          var controller = stream._writableStreamController;
-          stream._state = "erroring";
-          stream._storedError = reason;
-          var writer = stream._writer;
-          if (writer !== void 0) {
-            WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, reason);
-          }
-          if (WritableStreamHasOperationMarkedInFlight(stream) === false && controller._started === true) {
-            WritableStreamFinishErroring(stream);
-          }
-        }
-        function WritableStreamFinishErroring(stream) {
-          stream._state = "errored";
-          stream._writableStreamController[ErrorSteps]();
-          var storedError = stream._storedError;
-          stream._writeRequests.forEach(function(writeRequest) {
-            writeRequest._reject(storedError);
-          });
-          stream._writeRequests = new SimpleQueue();
-          if (stream._pendingAbortRequest === void 0) {
-            WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
-            return;
-          }
-          var abortRequest = stream._pendingAbortRequest;
-          stream._pendingAbortRequest = void 0;
-          if (abortRequest._wasAlreadyErroring === true) {
-            abortRequest._reject(storedError);
-            WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
-            return;
-          }
-          var promise = stream._writableStreamController[AbortSteps](abortRequest._reason);
-          uponPromise(promise, function() {
-            abortRequest._resolve();
-            WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
-          }, function(reason) {
-            abortRequest._reject(reason);
-            WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
-          });
-        }
-        function WritableStreamFinishInFlightWrite(stream) {
-          stream._inFlightWriteRequest._resolve(void 0);
-          stream._inFlightWriteRequest = void 0;
-        }
-        function WritableStreamFinishInFlightWriteWithError(stream, error) {
-          stream._inFlightWriteRequest._reject(error);
-          stream._inFlightWriteRequest = void 0;
-          WritableStreamDealWithRejection(stream, error);
-        }
-        function WritableStreamFinishInFlightClose(stream) {
-          stream._inFlightCloseRequest._resolve(void 0);
-          stream._inFlightCloseRequest = void 0;
-          var state = stream._state;
-          if (state === "erroring") {
-            stream._storedError = void 0;
-            if (stream._pendingAbortRequest !== void 0) {
-              stream._pendingAbortRequest._resolve();
-              stream._pendingAbortRequest = void 0;
-            }
-          }
-          stream._state = "closed";
-          var writer = stream._writer;
-          if (writer !== void 0) {
-            defaultWriterClosedPromiseResolve(writer);
-          }
-        }
-        function WritableStreamFinishInFlightCloseWithError(stream, error) {
-          stream._inFlightCloseRequest._reject(error);
-          stream._inFlightCloseRequest = void 0;
-          if (stream._pendingAbortRequest !== void 0) {
-            stream._pendingAbortRequest._reject(error);
-            stream._pendingAbortRequest = void 0;
-          }
-          WritableStreamDealWithRejection(stream, error);
-        }
-        function WritableStreamCloseQueuedOrInFlight(stream) {
-          if (stream._closeRequest === void 0 && stream._inFlightCloseRequest === void 0) {
-            return false;
-          }
-          return true;
-        }
-        function WritableStreamHasOperationMarkedInFlight(stream) {
-          if (stream._inFlightWriteRequest === void 0 && stream._inFlightCloseRequest === void 0) {
-            return false;
-          }
-          return true;
-        }
-        function WritableStreamMarkCloseRequestInFlight(stream) {
-          stream._inFlightCloseRequest = stream._closeRequest;
-          stream._closeRequest = void 0;
-        }
-        function WritableStreamMarkFirstWriteRequestInFlight(stream) {
-          stream._inFlightWriteRequest = stream._writeRequests.shift();
-        }
-        function WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream) {
-          if (stream._closeRequest !== void 0) {
-            stream._closeRequest._reject(stream._storedError);
-            stream._closeRequest = void 0;
-          }
-          var writer = stream._writer;
-          if (writer !== void 0) {
-            defaultWriterClosedPromiseReject(writer, stream._storedError);
-          }
-        }
-        function WritableStreamUpdateBackpressure(stream, backpressure) {
-          var writer = stream._writer;
-          if (writer !== void 0 && backpressure !== stream._backpressure) {
-            if (backpressure === true) {
-              defaultWriterReadyPromiseReset(writer);
-            } else {
-              defaultWriterReadyPromiseResolve(writer);
-            }
-          }
-          stream._backpressure = backpressure;
-        }
-        var WritableStreamDefaultWriter = function() {
-          function WritableStreamDefaultWriter2(stream) {
-            if (IsWritableStream(stream) === false) {
-              throw new TypeError("WritableStreamDefaultWriter can only be constructed with a WritableStream instance");
-            }
-            if (IsWritableStreamLocked(stream) === true) {
-              throw new TypeError("This stream has already been locked for exclusive writing by another writer");
-            }
-            this._ownerWritableStream = stream;
-            stream._writer = this;
-            var state = stream._state;
-            if (state === "writable") {
-              if (WritableStreamCloseQueuedOrInFlight(stream) === false && stream._backpressure === true) {
-                defaultWriterReadyPromiseInitialize(this);
-              } else {
-                defaultWriterReadyPromiseInitializeAsResolved(this);
-              }
-              defaultWriterClosedPromiseInitialize(this);
-            } else if (state === "erroring") {
-              defaultWriterReadyPromiseInitializeAsRejected(this, stream._storedError);
-              defaultWriterClosedPromiseInitialize(this);
-            } else if (state === "closed") {
-              defaultWriterReadyPromiseInitializeAsResolved(this);
-              defaultWriterClosedPromiseInitializeAsResolved(this);
-            } else {
-              var storedError = stream._storedError;
-              defaultWriterReadyPromiseInitializeAsRejected(this, storedError);
-              defaultWriterClosedPromiseInitializeAsRejected(this, storedError);
-            }
-          }
-          Object.defineProperty(WritableStreamDefaultWriter2.prototype, "closed", {
-            get: function() {
-              if (IsWritableStreamDefaultWriter(this) === false) {
-                return promiseRejectedWith(defaultWriterBrandCheckException("closed"));
-              }
-              return this._closedPromise;
-            },
-            enumerable: true,
-            configurable: true
-          });
-          Object.defineProperty(WritableStreamDefaultWriter2.prototype, "desiredSize", {
-            get: function() {
-              if (IsWritableStreamDefaultWriter(this) === false) {
-                throw defaultWriterBrandCheckException("desiredSize");
-              }
-              if (this._ownerWritableStream === void 0) {
-                throw defaultWriterLockException("desiredSize");
-              }
-              return WritableStreamDefaultWriterGetDesiredSize(this);
-            },
-            enumerable: true,
-            configurable: true
-          });
-          Object.defineProperty(WritableStreamDefaultWriter2.prototype, "ready", {
-            get: function() {
-              if (IsWritableStreamDefaultWriter(this) === false) {
-                return promiseRejectedWith(defaultWriterBrandCheckException("ready"));
-              }
-              return this._readyPromise;
-            },
-            enumerable: true,
-            configurable: true
-          });
-          WritableStreamDefaultWriter2.prototype.abort = function(reason) {
-            if (IsWritableStreamDefaultWriter(this) === false) {
-              return promiseRejectedWith(defaultWriterBrandCheckException("abort"));
-            }
-            if (this._ownerWritableStream === void 0) {
-              return promiseRejectedWith(defaultWriterLockException("abort"));
-            }
-            return WritableStreamDefaultWriterAbort(this, reason);
-          };
-          WritableStreamDefaultWriter2.prototype.close = function() {
-            if (IsWritableStreamDefaultWriter(this) === false) {
-              return promiseRejectedWith(defaultWriterBrandCheckException("close"));
-            }
-            var stream = this._ownerWritableStream;
-            if (stream === void 0) {
-              return promiseRejectedWith(defaultWriterLockException("close"));
-            }
-            if (WritableStreamCloseQueuedOrInFlight(stream) === true) {
-              return promiseRejectedWith(new TypeError("Cannot close an already-closing stream"));
-            }
-            return WritableStreamDefaultWriterClose(this);
-          };
-          WritableStreamDefaultWriter2.prototype.releaseLock = function() {
-            if (IsWritableStreamDefaultWriter(this) === false) {
-              throw defaultWriterBrandCheckException("releaseLock");
-            }
-            var stream = this._ownerWritableStream;
-            if (stream === void 0) {
-              return;
-            }
-            WritableStreamDefaultWriterRelease(this);
-          };
-          WritableStreamDefaultWriter2.prototype.write = function(chunk) {
-            if (IsWritableStreamDefaultWriter(this) === false) {
-              return promiseRejectedWith(defaultWriterBrandCheckException("write"));
-            }
-            if (this._ownerWritableStream === void 0) {
-              return promiseRejectedWith(defaultWriterLockException("write to"));
-            }
-            return WritableStreamDefaultWriterWrite(this, chunk);
-          };
-          return WritableStreamDefaultWriter2;
-        }();
-        function IsWritableStreamDefaultWriter(x) {
-          if (!typeIsObject(x)) {
-            return false;
-          }
-          if (!Object.prototype.hasOwnProperty.call(x, "_ownerWritableStream")) {
-            return false;
-          }
-          return true;
-        }
-        function WritableStreamDefaultWriterAbort(writer, reason) {
-          var stream = writer._ownerWritableStream;
-          return WritableStreamAbort(stream, reason);
-        }
-        function WritableStreamDefaultWriterClose(writer) {
-          var stream = writer._ownerWritableStream;
-          return WritableStreamClose(stream);
-        }
-        function WritableStreamDefaultWriterCloseWithErrorPropagation(writer) {
-          var stream = writer._ownerWritableStream;
-          var state = stream._state;
-          if (WritableStreamCloseQueuedOrInFlight(stream) === true || state === "closed") {
-            return promiseResolvedWith(void 0);
-          }
-          if (state === "errored") {
-            return promiseRejectedWith(stream._storedError);
-          }
-          return WritableStreamDefaultWriterClose(writer);
-        }
-        function WritableStreamDefaultWriterEnsureClosedPromiseRejected(writer, error) {
-          if (writer._closedPromiseState === "pending") {
-            defaultWriterClosedPromiseReject(writer, error);
-          } else {
-            defaultWriterClosedPromiseResetToRejected(writer, error);
-          }
-        }
-        function WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, error) {
-          if (writer._readyPromiseState === "pending") {
-            defaultWriterReadyPromiseReject(writer, error);
-          } else {
-            defaultWriterReadyPromiseResetToRejected(writer, error);
-          }
-        }
-        function WritableStreamDefaultWriterGetDesiredSize(writer) {
-          var stream = writer._ownerWritableStream;
-          var state = stream._state;
-          if (state === "errored" || state === "erroring") {
-            return null;
-          }
-          if (state === "closed") {
-            return 0;
-          }
-          return WritableStreamDefaultControllerGetDesiredSize(stream._writableStreamController);
-        }
-        function WritableStreamDefaultWriterRelease(writer) {
-          var stream = writer._ownerWritableStream;
-          var releasedError = new TypeError("Writer was released and can no longer be used to monitor the stream's closedness");
-          WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, releasedError);
-          WritableStreamDefaultWriterEnsureClosedPromiseRejected(writer, releasedError);
-          stream._writer = void 0;
-          writer._ownerWritableStream = void 0;
-        }
-        function WritableStreamDefaultWriterWrite(writer, chunk) {
-          var stream = writer._ownerWritableStream;
-          var controller = stream._writableStreamController;
-          var chunkSize = WritableStreamDefaultControllerGetChunkSize(controller, chunk);
-          if (stream !== writer._ownerWritableStream) {
-            return promiseRejectedWith(defaultWriterLockException("write to"));
-          }
-          var state = stream._state;
-          if (state === "errored") {
-            return promiseRejectedWith(stream._storedError);
-          }
-          if (WritableStreamCloseQueuedOrInFlight(stream) === true || state === "closed") {
-            return promiseRejectedWith(new TypeError("The stream is closing or closed and cannot be written to"));
-          }
-          if (state === "erroring") {
-            return promiseRejectedWith(stream._storedError);
-          }
-          var promise = WritableStreamAddWriteRequest(stream);
-          WritableStreamDefaultControllerWrite(controller, chunk, chunkSize);
-          return promise;
-        }
-        var WritableStreamDefaultController = function() {
-          function WritableStreamDefaultController2() {
-            throw new TypeError("WritableStreamDefaultController cannot be constructed explicitly");
-          }
-          WritableStreamDefaultController2.prototype.error = function(e) {
-            if (IsWritableStreamDefaultController(this) === false) {
-              throw new TypeError("WritableStreamDefaultController.prototype.error can only be used on a WritableStreamDefaultController");
-            }
-            var state = this._controlledWritableStream._state;
-            if (state !== "writable") {
-              return;
-            }
-            WritableStreamDefaultControllerError(this, e);
-          };
-          WritableStreamDefaultController2.prototype[AbortSteps] = function(reason) {
-            var result = this._abortAlgorithm(reason);
-            WritableStreamDefaultControllerClearAlgorithms(this);
-            return result;
-          };
-          WritableStreamDefaultController2.prototype[ErrorSteps] = function() {
-            ResetQueue(this);
-          };
-          return WritableStreamDefaultController2;
-        }();
-        function IsWritableStreamDefaultController(x) {
-          if (!typeIsObject(x)) {
-            return false;
-          }
-          if (!Object.prototype.hasOwnProperty.call(x, "_controlledWritableStream")) {
-            return false;
-          }
-          return true;
-        }
-        function SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm) {
-          controller._controlledWritableStream = stream;
-          stream._writableStreamController = controller;
-          controller._queue = void 0;
-          controller._queueTotalSize = void 0;
-          ResetQueue(controller);
-          controller._started = false;
-          controller._strategySizeAlgorithm = sizeAlgorithm;
-          controller._strategyHWM = highWaterMark;
-          controller._writeAlgorithm = writeAlgorithm;
-          controller._closeAlgorithm = closeAlgorithm;
-          controller._abortAlgorithm = abortAlgorithm;
-          var backpressure = WritableStreamDefaultControllerGetBackpressure(controller);
-          WritableStreamUpdateBackpressure(stream, backpressure);
-          var startResult = startAlgorithm();
-          var startPromise = promiseResolvedWith(startResult);
-          uponPromise(startPromise, function() {
-            controller._started = true;
-            WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
-          }, function(r) {
-            controller._started = true;
-            WritableStreamDealWithRejection(stream, r);
-          });
-        }
-        function SetUpWritableStreamDefaultControllerFromUnderlyingSink(stream, underlyingSink, highWaterMark, sizeAlgorithm) {
-          var controller = Object.create(WritableStreamDefaultController.prototype);
-          function startAlgorithm() {
-            return InvokeOrNoop(underlyingSink, "start", [controller]);
-          }
-          var writeAlgorithm = CreateAlgorithmFromUnderlyingMethod(underlyingSink, "write", 1, [controller]);
-          var closeAlgorithm = CreateAlgorithmFromUnderlyingMethod(underlyingSink, "close", 0, []);
-          var abortAlgorithm = CreateAlgorithmFromUnderlyingMethod(underlyingSink, "abort", 1, []);
-          SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm);
-        }
-        function WritableStreamDefaultControllerClearAlgorithms(controller) {
-          controller._writeAlgorithm = void 0;
-          controller._closeAlgorithm = void 0;
-          controller._abortAlgorithm = void 0;
-          controller._strategySizeAlgorithm = void 0;
-        }
-        function WritableStreamDefaultControllerClose(controller) {
-          EnqueueValueWithSize(controller, "close", 0);
-          WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
-        }
-        function WritableStreamDefaultControllerGetChunkSize(controller, chunk) {
-          try {
-            return controller._strategySizeAlgorithm(chunk);
-          } catch (chunkSizeE) {
-            WritableStreamDefaultControllerErrorIfNeeded(controller, chunkSizeE);
-            return 1;
-          }
-        }
-        function WritableStreamDefaultControllerGetDesiredSize(controller) {
-          return controller._strategyHWM - controller._queueTotalSize;
-        }
-        function WritableStreamDefaultControllerWrite(controller, chunk, chunkSize) {
-          var writeRecord = { chunk };
-          try {
-            EnqueueValueWithSize(controller, writeRecord, chunkSize);
-          } catch (enqueueE) {
-            WritableStreamDefaultControllerErrorIfNeeded(controller, enqueueE);
-            return;
-          }
-          var stream = controller._controlledWritableStream;
-          if (WritableStreamCloseQueuedOrInFlight(stream) === false && stream._state === "writable") {
-            var backpressure = WritableStreamDefaultControllerGetBackpressure(controller);
-            WritableStreamUpdateBackpressure(stream, backpressure);
-          }
-          WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
-        }
-        function WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller) {
-          var stream = controller._controlledWritableStream;
-          if (controller._started === false) {
-            return;
-          }
-          if (stream._inFlightWriteRequest !== void 0) {
-            return;
-          }
-          var state = stream._state;
-          if (state === "erroring") {
-            WritableStreamFinishErroring(stream);
-            return;
-          }
-          if (controller._queue.length === 0) {
-            return;
-          }
-          var writeRecord = PeekQueueValue(controller);
-          if (writeRecord === "close") {
-            WritableStreamDefaultControllerProcessClose(controller);
-          } else {
-            WritableStreamDefaultControllerProcessWrite(controller, writeRecord.chunk);
-          }
-        }
-        function WritableStreamDefaultControllerErrorIfNeeded(controller, error) {
-          if (controller._controlledWritableStream._state === "writable") {
-            WritableStreamDefaultControllerError(controller, error);
-          }
-        }
-        function WritableStreamDefaultControllerProcessClose(controller) {
-          var stream = controller._controlledWritableStream;
-          WritableStreamMarkCloseRequestInFlight(stream);
-          DequeueValue(controller);
-          var sinkClosePromise = controller._closeAlgorithm();
-          WritableStreamDefaultControllerClearAlgorithms(controller);
-          uponPromise(sinkClosePromise, function() {
-            WritableStreamFinishInFlightClose(stream);
-          }, function(reason) {
-            WritableStreamFinishInFlightCloseWithError(stream, reason);
-          });
-        }
-        function WritableStreamDefaultControllerProcessWrite(controller, chunk) {
-          var stream = controller._controlledWritableStream;
-          WritableStreamMarkFirstWriteRequestInFlight(stream);
-          var sinkWritePromise = controller._writeAlgorithm(chunk);
-          uponPromise(sinkWritePromise, function() {
-            WritableStreamFinishInFlightWrite(stream);
-            var state = stream._state;
-            DequeueValue(controller);
-            if (WritableStreamCloseQueuedOrInFlight(stream) === false && state === "writable") {
-              var backpressure = WritableStreamDefaultControllerGetBackpressure(controller);
-              WritableStreamUpdateBackpressure(stream, backpressure);
-            }
-            WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
-          }, function(reason) {
-            if (stream._state === "writable") {
-              WritableStreamDefaultControllerClearAlgorithms(controller);
-            }
-            WritableStreamFinishInFlightWriteWithError(stream, reason);
-          });
-        }
-        function WritableStreamDefaultControllerGetBackpressure(controller) {
-          var desiredSize = WritableStreamDefaultControllerGetDesiredSize(controller);
-          return desiredSize <= 0;
-        }
-        function WritableStreamDefaultControllerError(controller, error) {
-          var stream = controller._controlledWritableStream;
-          WritableStreamDefaultControllerClearAlgorithms(controller);
-          WritableStreamStartErroring(stream, error);
-        }
-        function streamBrandCheckException(name) {
-          return new TypeError("WritableStream.prototype." + name + " can only be used on a WritableStream");
-        }
-        function defaultWriterBrandCheckException(name) {
-          return new TypeError("WritableStreamDefaultWriter.prototype." + name + " can only be used on a WritableStreamDefaultWriter");
-        }
-        function defaultWriterLockException(name) {
-          return new TypeError("Cannot " + name + " a stream using a released writer");
-        }
-        function defaultWriterClosedPromiseInitialize(writer) {
-          writer._closedPromise = newPromise(function(resolve, reject) {
-            writer._closedPromise_resolve = resolve;
-            writer._closedPromise_reject = reject;
-            writer._closedPromiseState = "pending";
-          });
-        }
-        function defaultWriterClosedPromiseInitializeAsRejected(writer, reason) {
-          defaultWriterClosedPromiseInitialize(writer);
-          defaultWriterClosedPromiseReject(writer, reason);
-        }
-        function defaultWriterClosedPromiseInitializeAsResolved(writer) {
-          defaultWriterClosedPromiseInitialize(writer);
-          defaultWriterClosedPromiseResolve(writer);
-        }
-        function defaultWriterClosedPromiseReject(writer, reason) {
-          setPromiseIsHandledToTrue(writer._closedPromise);
-          writer._closedPromise_reject(reason);
-          writer._closedPromise_resolve = void 0;
-          writer._closedPromise_reject = void 0;
-          writer._closedPromiseState = "rejected";
-        }
-        function defaultWriterClosedPromiseResetToRejected(writer, reason) {
-          defaultWriterClosedPromiseInitializeAsRejected(writer, reason);
-        }
-        function defaultWriterClosedPromiseResolve(writer) {
-          writer._closedPromise_resolve(void 0);
-          writer._closedPromise_resolve = void 0;
-          writer._closedPromise_reject = void 0;
-          writer._closedPromiseState = "resolved";
-        }
-        function defaultWriterReadyPromiseInitialize(writer) {
-          writer._readyPromise = newPromise(function(resolve, reject) {
-            writer._readyPromise_resolve = resolve;
-            writer._readyPromise_reject = reject;
-          });
-          writer._readyPromiseState = "pending";
-        }
-        function defaultWriterReadyPromiseInitializeAsRejected(writer, reason) {
-          defaultWriterReadyPromiseInitialize(writer);
-          defaultWriterReadyPromiseReject(writer, reason);
-        }
-        function defaultWriterReadyPromiseInitializeAsResolved(writer) {
-          defaultWriterReadyPromiseInitialize(writer);
-          defaultWriterReadyPromiseResolve(writer);
-        }
-        function defaultWriterReadyPromiseReject(writer, reason) {
-          setPromiseIsHandledToTrue(writer._readyPromise);
-          writer._readyPromise_reject(reason);
-          writer._readyPromise_resolve = void 0;
-          writer._readyPromise_reject = void 0;
-          writer._readyPromiseState = "rejected";
-        }
-        function defaultWriterReadyPromiseReset(writer) {
-          defaultWriterReadyPromiseInitialize(writer);
-        }
-        function defaultWriterReadyPromiseResetToRejected(writer, reason) {
-          defaultWriterReadyPromiseInitializeAsRejected(writer, reason);
-        }
-        function defaultWriterReadyPromiseResolve(writer) {
-          writer._readyPromise_resolve(void 0);
-          writer._readyPromise_resolve = void 0;
-          writer._readyPromise_reject = void 0;
-          writer._readyPromiseState = "fulfilled";
-        }
-        function isAbortSignal(value) {
-          if (typeof value !== "object" || value === null) {
-            return false;
-          }
-          try {
-            return typeof value.aborted === "boolean";
-          } catch (_a2) {
-            return false;
-          }
-        }
-        var NativeDOMException = typeof DOMException !== "undefined" ? DOMException : void 0;
-        function isDOMExceptionConstructor(ctor) {
-          if (!(typeof ctor === "function" || typeof ctor === "object")) {
-            return false;
-          }
-          try {
-            new ctor();
-            return true;
-          } catch (_a2) {
-            return false;
-          }
-        }
-        function createDOMExceptionPolyfill() {
-          var ctor = function DOMException2(message, name) {
-            this.message = message || "";
-            this.name = name || "Error";
-            if (Error.captureStackTrace) {
-              Error.captureStackTrace(this, this.constructor);
-            }
-          };
-          ctor.prototype = Object.create(Error.prototype);
-          Object.defineProperty(ctor.prototype, "constructor", { value: ctor, writable: true, configurable: true });
-          return ctor;
-        }
-        var DOMException$1 = isDOMExceptionConstructor(NativeDOMException) ? NativeDOMException : createDOMExceptionPolyfill();
-        function ReadableStreamPipeTo(source, dest, preventClose, preventAbort, preventCancel, signal) {
-          var reader = AcquireReadableStreamDefaultReader(source);
-          var writer = AcquireWritableStreamDefaultWriter(dest);
-          source._disturbed = true;
-          var shuttingDown = false;
-          var currentWrite = promiseResolvedWith(void 0);
-          return newPromise(function(resolve, reject) {
-            var abortAlgorithm;
-            if (signal !== void 0) {
-              abortAlgorithm = function() {
-                var error = new DOMException$1("Aborted", "AbortError");
-                var actions = [];
-                if (preventAbort === false) {
-                  actions.push(function() {
-                    if (dest._state === "writable") {
-                      return WritableStreamAbort(dest, error);
-                    }
-                    return promiseResolvedWith(void 0);
-                  });
-                }
-                if (preventCancel === false) {
-                  actions.push(function() {
-                    if (source._state === "readable") {
-                      return ReadableStreamCancel(source, error);
-                    }
-                    return promiseResolvedWith(void 0);
-                  });
-                }
-                shutdownWithAction(function() {
-                  return Promise.all(actions.map(function(action) {
-                    return action();
-                  }));
-                }, true, error);
-              };
-              if (signal.aborted === true) {
-                abortAlgorithm();
-                return;
-              }
-              signal.addEventListener("abort", abortAlgorithm);
-            }
-            function pipeLoop() {
-              return newPromise(function(resolveLoop, rejectLoop) {
-                function next(done) {
-                  if (done) {
-                    resolveLoop();
-                  } else {
-                    PerformPromiseThen(pipeStep(), next, rejectLoop);
-                  }
-                }
-                next(false);
-              });
-            }
-            function pipeStep() {
-              if (shuttingDown === true) {
-                return promiseResolvedWith(true);
-              }
-              return PerformPromiseThen(writer._readyPromise, function() {
-                return PerformPromiseThen(ReadableStreamDefaultReaderRead(reader), function(result) {
-                  if (result.done === true) {
-                    return true;
-                  }
-                  currentWrite = PerformPromiseThen(WritableStreamDefaultWriterWrite(writer, result.value), void 0, noop);
-                  return false;
-                });
-              });
-            }
-            isOrBecomesErrored(source, reader._closedPromise, function(storedError) {
-              if (preventAbort === false) {
-                shutdownWithAction(function() {
-                  return WritableStreamAbort(dest, storedError);
-                }, true, storedError);
-              } else {
-                shutdown(true, storedError);
-              }
-            });
-            isOrBecomesErrored(dest, writer._closedPromise, function(storedError) {
-              if (preventCancel === false) {
-                shutdownWithAction(function() {
-                  return ReadableStreamCancel(source, storedError);
-                }, true, storedError);
-              } else {
-                shutdown(true, storedError);
-              }
-            });
-            isOrBecomesClosed(source, reader._closedPromise, function() {
-              if (preventClose === false) {
-                shutdownWithAction(function() {
-                  return WritableStreamDefaultWriterCloseWithErrorPropagation(writer);
-                });
-              } else {
-                shutdown();
-              }
-            });
-            if (WritableStreamCloseQueuedOrInFlight(dest) === true || dest._state === "closed") {
-              var destClosed_1 = new TypeError("the destination writable stream closed before all data could be piped to it");
-              if (preventCancel === false) {
-                shutdownWithAction(function() {
-                  return ReadableStreamCancel(source, destClosed_1);
-                }, true, destClosed_1);
-              } else {
-                shutdown(true, destClosed_1);
-              }
-            }
-            setPromiseIsHandledToTrue(pipeLoop());
-            function waitForWritesToFinish() {
-              var oldCurrentWrite = currentWrite;
-              return PerformPromiseThen(currentWrite, function() {
-                return oldCurrentWrite !== currentWrite ? waitForWritesToFinish() : void 0;
-              });
-            }
-            function isOrBecomesErrored(stream, promise, action) {
-              if (stream._state === "errored") {
-                action(stream._storedError);
-              } else {
-                uponRejection(promise, action);
-              }
-            }
-            function isOrBecomesClosed(stream, promise, action) {
-              if (stream._state === "closed") {
-                action();
-              } else {
-                uponFulfillment(promise, action);
-              }
-            }
-            function shutdownWithAction(action, originalIsError, originalError) {
-              if (shuttingDown === true) {
-                return;
-              }
-              shuttingDown = true;
-              if (dest._state === "writable" && WritableStreamCloseQueuedOrInFlight(dest) === false) {
-                uponFulfillment(waitForWritesToFinish(), doTheRest);
-              } else {
-                doTheRest();
-              }
-              function doTheRest() {
-                uponPromise(action(), function() {
-                  return finalize(originalIsError, originalError);
-                }, function(newError) {
-                  return finalize(true, newError);
-                });
-              }
-            }
-            function shutdown(isError, error) {
-              if (shuttingDown === true) {
-                return;
-              }
-              shuttingDown = true;
-              if (dest._state === "writable" && WritableStreamCloseQueuedOrInFlight(dest) === false) {
-                uponFulfillment(waitForWritesToFinish(), function() {
-                  return finalize(isError, error);
-                });
-              } else {
-                finalize(isError, error);
-              }
-            }
-            function finalize(isError, error) {
-              WritableStreamDefaultWriterRelease(writer);
-              ReadableStreamReaderGenericRelease(reader);
-              if (signal !== void 0) {
-                signal.removeEventListener("abort", abortAlgorithm);
-              }
-              if (isError) {
-                reject(error);
-              } else {
-                resolve(void 0);
-              }
-            }
-          });
-        }
-        var ReadableStreamDefaultController = function() {
-          function ReadableStreamDefaultController2() {
-            throw new TypeError();
-          }
-          Object.defineProperty(ReadableStreamDefaultController2.prototype, "desiredSize", {
-            get: function() {
-              if (IsReadableStreamDefaultController(this) === false) {
-                throw defaultControllerBrandCheckException("desiredSize");
-              }
-              return ReadableStreamDefaultControllerGetDesiredSize(this);
-            },
-            enumerable: true,
-            configurable: true
-          });
-          ReadableStreamDefaultController2.prototype.close = function() {
-            if (IsReadableStreamDefaultController(this) === false) {
-              throw defaultControllerBrandCheckException("close");
-            }
-            if (ReadableStreamDefaultControllerCanCloseOrEnqueue(this) === false) {
-              throw new TypeError("The stream is not in a state that permits close");
-            }
-            ReadableStreamDefaultControllerClose(this);
-          };
-          ReadableStreamDefaultController2.prototype.enqueue = function(chunk) {
-            if (IsReadableStreamDefaultController(this) === false) {
-              throw defaultControllerBrandCheckException("enqueue");
-            }
-            if (ReadableStreamDefaultControllerCanCloseOrEnqueue(this) === false) {
-              throw new TypeError("The stream is not in a state that permits enqueue");
-            }
-            return ReadableStreamDefaultControllerEnqueue(this, chunk);
-          };
-          ReadableStreamDefaultController2.prototype.error = function(e) {
-            if (IsReadableStreamDefaultController(this) === false) {
-              throw defaultControllerBrandCheckException("error");
-            }
-            ReadableStreamDefaultControllerError(this, e);
-          };
-          ReadableStreamDefaultController2.prototype[CancelSteps] = function(reason) {
-            ResetQueue(this);
-            var result = this._cancelAlgorithm(reason);
-            ReadableStreamDefaultControllerClearAlgorithms(this);
-            return result;
-          };
-          ReadableStreamDefaultController2.prototype[PullSteps] = function() {
-            var stream = this._controlledReadableStream;
-            if (this._queue.length > 0) {
-              var chunk = DequeueValue(this);
-              if (this._closeRequested === true && this._queue.length === 0) {
-                ReadableStreamDefaultControllerClearAlgorithms(this);
-                ReadableStreamClose(stream);
-              } else {
-                ReadableStreamDefaultControllerCallPullIfNeeded(this);
-              }
-              return promiseResolvedWith(ReadableStreamCreateReadResult(chunk, false, stream._reader._forAuthorCode));
-            }
-            var pendingPromise = ReadableStreamAddReadRequest(stream);
-            ReadableStreamDefaultControllerCallPullIfNeeded(this);
-            return pendingPromise;
-          };
-          return ReadableStreamDefaultController2;
-        }();
-        function IsReadableStreamDefaultController(x) {
-          if (!typeIsObject(x)) {
-            return false;
-          }
-          if (!Object.prototype.hasOwnProperty.call(x, "_controlledReadableStream")) {
-            return false;
-          }
-          return true;
-        }
-        function ReadableStreamDefaultControllerCallPullIfNeeded(controller) {
-          var shouldPull = ReadableStreamDefaultControllerShouldCallPull(controller);
-          if (shouldPull === false) {
-            return;
-          }
-          if (controller._pulling === true) {
-            controller._pullAgain = true;
-            return;
-          }
-          controller._pulling = true;
-          var pullPromise = controller._pullAlgorithm();
-          uponPromise(pullPromise, function() {
-            controller._pulling = false;
-            if (controller._pullAgain === true) {
-              controller._pullAgain = false;
-              ReadableStreamDefaultControllerCallPullIfNeeded(controller);
-            }
-          }, function(e) {
-            ReadableStreamDefaultControllerError(controller, e);
-          });
-        }
-        function ReadableStreamDefaultControllerShouldCallPull(controller) {
-          var stream = controller._controlledReadableStream;
-          if (ReadableStreamDefaultControllerCanCloseOrEnqueue(controller) === false) {
-            return false;
-          }
-          if (controller._started === false) {
-            return false;
-          }
-          if (IsReadableStreamLocked(stream) === true && ReadableStreamGetNumReadRequests(stream) > 0) {
-            return true;
-          }
-          var desiredSize = ReadableStreamDefaultControllerGetDesiredSize(controller);
-          if (desiredSize > 0) {
-            return true;
-          }
-          return false;
-        }
-        function ReadableStreamDefaultControllerClearAlgorithms(controller) {
-          controller._pullAlgorithm = void 0;
-          controller._cancelAlgorithm = void 0;
-          controller._strategySizeAlgorithm = void 0;
-        }
-        function ReadableStreamDefaultControllerClose(controller) {
-          var stream = controller._controlledReadableStream;
-          controller._closeRequested = true;
-          if (controller._queue.length === 0) {
-            ReadableStreamDefaultControllerClearAlgorithms(controller);
-            ReadableStreamClose(stream);
-          }
-        }
-        function ReadableStreamDefaultControllerEnqueue(controller, chunk) {
-          var stream = controller._controlledReadableStream;
-          if (IsReadableStreamLocked(stream) === true && ReadableStreamGetNumReadRequests(stream) > 0) {
-            ReadableStreamFulfillReadRequest(stream, chunk, false);
-          } else {
-            var chunkSize = void 0;
-            try {
-              chunkSize = controller._strategySizeAlgorithm(chunk);
-            } catch (chunkSizeE) {
-              ReadableStreamDefaultControllerError(controller, chunkSizeE);
-              throw chunkSizeE;
-            }
-            try {
-              EnqueueValueWithSize(controller, chunk, chunkSize);
-            } catch (enqueueE) {
-              ReadableStreamDefaultControllerError(controller, enqueueE);
-              throw enqueueE;
-            }
-          }
-          ReadableStreamDefaultControllerCallPullIfNeeded(controller);
-        }
-        function ReadableStreamDefaultControllerError(controller, e) {
-          var stream = controller._controlledReadableStream;
-          if (stream._state !== "readable") {
-            return;
-          }
-          ResetQueue(controller);
-          ReadableStreamDefaultControllerClearAlgorithms(controller);
-          ReadableStreamError(stream, e);
-        }
-        function ReadableStreamDefaultControllerGetDesiredSize(controller) {
-          var stream = controller._controlledReadableStream;
-          var state = stream._state;
-          if (state === "errored") {
-            return null;
-          }
-          if (state === "closed") {
-            return 0;
-          }
-          return controller._strategyHWM - controller._queueTotalSize;
-        }
-        function ReadableStreamDefaultControllerHasBackpressure(controller) {
-          if (ReadableStreamDefaultControllerShouldCallPull(controller) === true) {
-            return false;
-          }
-          return true;
-        }
-        function ReadableStreamDefaultControllerCanCloseOrEnqueue(controller) {
-          var state = controller._controlledReadableStream._state;
-          if (controller._closeRequested === false && state === "readable") {
-            return true;
-          }
-          return false;
-        }
-        function SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm) {
-          controller._controlledReadableStream = stream;
-          controller._queue = void 0;
-          controller._queueTotalSize = void 0;
-          ResetQueue(controller);
-          controller._started = false;
-          controller._closeRequested = false;
-          controller._pullAgain = false;
-          controller._pulling = false;
-          controller._strategySizeAlgorithm = sizeAlgorithm;
-          controller._strategyHWM = highWaterMark;
-          controller._pullAlgorithm = pullAlgorithm;
-          controller._cancelAlgorithm = cancelAlgorithm;
-          stream._readableStreamController = controller;
-          var startResult = startAlgorithm();
-          uponPromise(promiseResolvedWith(startResult), function() {
-            controller._started = true;
-            ReadableStreamDefaultControllerCallPullIfNeeded(controller);
-          }, function(r) {
-            ReadableStreamDefaultControllerError(controller, r);
-          });
-        }
-        function SetUpReadableStreamDefaultControllerFromUnderlyingSource(stream, underlyingSource, highWaterMark, sizeAlgorithm) {
-          var controller = Object.create(ReadableStreamDefaultController.prototype);
-          function startAlgorithm() {
-            return InvokeOrNoop(underlyingSource, "start", [controller]);
-          }
-          var pullAlgorithm = CreateAlgorithmFromUnderlyingMethod(underlyingSource, "pull", 0, [controller]);
-          var cancelAlgorithm = CreateAlgorithmFromUnderlyingMethod(underlyingSource, "cancel", 1, []);
-          SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm);
-        }
-        function defaultControllerBrandCheckException(name) {
-          return new TypeError("ReadableStreamDefaultController.prototype." + name + " can only be used on a ReadableStreamDefaultController");
-        }
-        function ReadableStreamTee(stream, cloneForBranch2) {
-          var reader = AcquireReadableStreamDefaultReader(stream);
-          var reading = false;
-          var canceled1 = false;
-          var canceled2 = false;
-          var reason1;
-          var reason2;
-          var branch1;
-          var branch2;
-          var resolveCancelPromise;
-          var cancelPromise = newPromise(function(resolve) {
-            resolveCancelPromise = resolve;
-          });
-          function pullAlgorithm() {
-            if (reading === true) {
-              return promiseResolvedWith(void 0);
-            }
-            reading = true;
-            var readPromise = transformPromiseWith(ReadableStreamDefaultReaderRead(reader), function(result) {
-              reading = false;
-              var done = result.done;
-              if (done === true) {
-                if (canceled1 === false) {
-                  ReadableStreamDefaultControllerClose(branch1._readableStreamController);
-                }
-                if (canceled2 === false) {
-                  ReadableStreamDefaultControllerClose(branch2._readableStreamController);
-                }
-                return;
-              }
-              var value = result.value;
-              var value1 = value;
-              var value2 = value;
-              if (canceled1 === false) {
-                ReadableStreamDefaultControllerEnqueue(branch1._readableStreamController, value1);
-              }
-              if (canceled2 === false) {
-                ReadableStreamDefaultControllerEnqueue(branch2._readableStreamController, value2);
-              }
-            });
-            setPromiseIsHandledToTrue(readPromise);
-            return promiseResolvedWith(void 0);
-          }
-          function cancel1Algorithm(reason) {
-            canceled1 = true;
-            reason1 = reason;
-            if (canceled2 === true) {
-              var compositeReason = createArrayFromList([reason1, reason2]);
-              var cancelResult = ReadableStreamCancel(stream, compositeReason);
-              resolveCancelPromise(cancelResult);
-            }
-            return cancelPromise;
-          }
-          function cancel2Algorithm(reason) {
-            canceled2 = true;
-            reason2 = reason;
-            if (canceled1 === true) {
-              var compositeReason = createArrayFromList([reason1, reason2]);
-              var cancelResult = ReadableStreamCancel(stream, compositeReason);
-              resolveCancelPromise(cancelResult);
-            }
-            return cancelPromise;
-          }
-          function startAlgorithm() {
-          }
-          branch1 = CreateReadableStream(startAlgorithm, pullAlgorithm, cancel1Algorithm);
-          branch2 = CreateReadableStream(startAlgorithm, pullAlgorithm, cancel2Algorithm);
-          uponRejection(reader._closedPromise, function(r) {
-            ReadableStreamDefaultControllerError(branch1._readableStreamController, r);
-            ReadableStreamDefaultControllerError(branch2._readableStreamController, r);
-          });
-          return [branch1, branch2];
-        }
-        var NumberIsInteger = Number.isInteger || function(value) {
-          return typeof value === "number" && isFinite(value) && Math.floor(value) === value;
-        };
-        var ReadableStreamBYOBRequest = function() {
-          function ReadableStreamBYOBRequest2() {
-            throw new TypeError("ReadableStreamBYOBRequest cannot be used directly");
-          }
-          Object.defineProperty(ReadableStreamBYOBRequest2.prototype, "view", {
-            get: function() {
-              if (IsReadableStreamBYOBRequest(this) === false) {
-                throw byobRequestBrandCheckException("view");
-              }
-              return this._view;
-            },
-            enumerable: true,
-            configurable: true
-          });
-          ReadableStreamBYOBRequest2.prototype.respond = function(bytesWritten) {
-            if (IsReadableStreamBYOBRequest(this) === false) {
-              throw byobRequestBrandCheckException("respond");
-            }
-            if (this._associatedReadableByteStreamController === void 0) {
-              throw new TypeError("This BYOB request has been invalidated");
-            }
-            if (IsDetachedBuffer(this._view.buffer) === true)
-              ;
-            ReadableByteStreamControllerRespond(this._associatedReadableByteStreamController, bytesWritten);
-          };
-          ReadableStreamBYOBRequest2.prototype.respondWithNewView = function(view) {
-            if (IsReadableStreamBYOBRequest(this) === false) {
-              throw byobRequestBrandCheckException("respond");
-            }
-            if (this._associatedReadableByteStreamController === void 0) {
-              throw new TypeError("This BYOB request has been invalidated");
-            }
-            if (!ArrayBuffer.isView(view)) {
-              throw new TypeError("You can only respond with array buffer views");
-            }
-            if (IsDetachedBuffer(view.buffer) === true)
-              ;
-            ReadableByteStreamControllerRespondWithNewView(this._associatedReadableByteStreamController, view);
-          };
-          return ReadableStreamBYOBRequest2;
-        }();
-        var ReadableByteStreamController = function() {
-          function ReadableByteStreamController2() {
-            throw new TypeError("ReadableByteStreamController constructor cannot be used directly");
-          }
-          Object.defineProperty(ReadableByteStreamController2.prototype, "byobRequest", {
-            get: function() {
-              if (IsReadableByteStreamController(this) === false) {
-                throw byteStreamControllerBrandCheckException("byobRequest");
-              }
-              if (this._byobRequest === void 0 && this._pendingPullIntos.length > 0) {
-                var firstDescriptor = this._pendingPullIntos.peek();
-                var view = new Uint8Array(firstDescriptor.buffer, firstDescriptor.byteOffset + firstDescriptor.bytesFilled, firstDescriptor.byteLength - firstDescriptor.bytesFilled);
-                var byobRequest = Object.create(ReadableStreamBYOBRequest.prototype);
-                SetUpReadableStreamBYOBRequest(byobRequest, this, view);
-                this._byobRequest = byobRequest;
-              }
-              return this._byobRequest;
-            },
-            enumerable: true,
-            configurable: true
-          });
-          Object.defineProperty(ReadableByteStreamController2.prototype, "desiredSize", {
-            get: function() {
-              if (IsReadableByteStreamController(this) === false) {
-                throw byteStreamControllerBrandCheckException("desiredSize");
-              }
-              return ReadableByteStreamControllerGetDesiredSize(this);
-            },
-            enumerable: true,
-            configurable: true
-          });
-          ReadableByteStreamController2.prototype.close = function() {
-            if (IsReadableByteStreamController(this) === false) {
-              throw byteStreamControllerBrandCheckException("close");
-            }
-            if (this._closeRequested === true) {
-              throw new TypeError("The stream has already been closed; do not close it again!");
-            }
-            var state = this._controlledReadableByteStream._state;
-            if (state !== "readable") {
-              throw new TypeError("The stream (in " + state + " state) is not in the readable state and cannot be closed");
-            }
-            ReadableByteStreamControllerClose(this);
-          };
-          ReadableByteStreamController2.prototype.enqueue = function(chunk) {
-            if (IsReadableByteStreamController(this) === false) {
-              throw byteStreamControllerBrandCheckException("enqueue");
-            }
-            if (this._closeRequested === true) {
-              throw new TypeError("stream is closed or draining");
-            }
-            var state = this._controlledReadableByteStream._state;
-            if (state !== "readable") {
-              throw new TypeError("The stream (in " + state + " state) is not in the readable state and cannot be enqueued to");
-            }
-            if (!ArrayBuffer.isView(chunk)) {
-              throw new TypeError("You can only enqueue array buffer views when using a ReadableByteStreamController");
-            }
-            if (IsDetachedBuffer(chunk.buffer) === true)
-              ;
-            ReadableByteStreamControllerEnqueue(this, chunk);
-          };
-          ReadableByteStreamController2.prototype.error = function(e) {
-            if (IsReadableByteStreamController(this) === false) {
-              throw byteStreamControllerBrandCheckException("error");
-            }
-            ReadableByteStreamControllerError(this, e);
-          };
-          ReadableByteStreamController2.prototype[CancelSteps] = function(reason) {
-            if (this._pendingPullIntos.length > 0) {
-              var firstDescriptor = this._pendingPullIntos.peek();
-              firstDescriptor.bytesFilled = 0;
-            }
-            ResetQueue(this);
-            var result = this._cancelAlgorithm(reason);
-            ReadableByteStreamControllerClearAlgorithms(this);
-            return result;
-          };
-          ReadableByteStreamController2.prototype[PullSteps] = function() {
-            var stream = this._controlledReadableByteStream;
-            if (this._queueTotalSize > 0) {
-              var entry = this._queue.shift();
-              this._queueTotalSize -= entry.byteLength;
-              ReadableByteStreamControllerHandleQueueDrain(this);
-              var view = void 0;
-              try {
-                view = new Uint8Array(entry.buffer, entry.byteOffset, entry.byteLength);
-              } catch (viewE) {
-                return promiseRejectedWith(viewE);
-              }
-              return promiseResolvedWith(ReadableStreamCreateReadResult(view, false, stream._reader._forAuthorCode));
-            }
-            var autoAllocateChunkSize = this._autoAllocateChunkSize;
-            if (autoAllocateChunkSize !== void 0) {
-              var buffer = void 0;
-              try {
-                buffer = new ArrayBuffer(autoAllocateChunkSize);
-              } catch (bufferE) {
-                return promiseRejectedWith(bufferE);
-              }
-              var pullIntoDescriptor = {
-                buffer,
-                byteOffset: 0,
-                byteLength: autoAllocateChunkSize,
-                bytesFilled: 0,
-                elementSize: 1,
-                ctor: Uint8Array,
-                readerType: "default"
-              };
-              this._pendingPullIntos.push(pullIntoDescriptor);
-            }
-            var promise = ReadableStreamAddReadRequest(stream);
-            ReadableByteStreamControllerCallPullIfNeeded(this);
-            return promise;
-          };
-          return ReadableByteStreamController2;
-        }();
-        function IsReadableByteStreamController(x) {
-          if (!typeIsObject(x)) {
-            return false;
-          }
-          if (!Object.prototype.hasOwnProperty.call(x, "_controlledReadableByteStream")) {
-            return false;
-          }
-          return true;
-        }
-        function IsReadableStreamBYOBRequest(x) {
-          if (!typeIsObject(x)) {
-            return false;
-          }
-          if (!Object.prototype.hasOwnProperty.call(x, "_associatedReadableByteStreamController")) {
-            return false;
-          }
-          return true;
-        }
-        function ReadableByteStreamControllerCallPullIfNeeded(controller) {
-          var shouldPull = ReadableByteStreamControllerShouldCallPull(controller);
-          if (shouldPull === false) {
-            return;
-          }
-          if (controller._pulling === true) {
-            controller._pullAgain = true;
-            return;
-          }
-          controller._pulling = true;
-          var pullPromise = controller._pullAlgorithm();
-          uponPromise(pullPromise, function() {
-            controller._pulling = false;
-            if (controller._pullAgain === true) {
-              controller._pullAgain = false;
-              ReadableByteStreamControllerCallPullIfNeeded(controller);
-            }
-          }, function(e) {
-            ReadableByteStreamControllerError(controller, e);
-          });
-        }
-        function ReadableByteStreamControllerClearPendingPullIntos(controller) {
-          ReadableByteStreamControllerInvalidateBYOBRequest(controller);
-          controller._pendingPullIntos = new SimpleQueue();
-        }
-        function ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor) {
-          var done = false;
-          if (stream._state === "closed") {
-            done = true;
-          }
-          var filledView = ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor);
-          if (pullIntoDescriptor.readerType === "default") {
-            ReadableStreamFulfillReadRequest(stream, filledView, done);
-          } else {
-            ReadableStreamFulfillReadIntoRequest(stream, filledView, done);
-          }
-        }
-        function ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor) {
-          var bytesFilled = pullIntoDescriptor.bytesFilled;
-          var elementSize = pullIntoDescriptor.elementSize;
-          return new pullIntoDescriptor.ctor(pullIntoDescriptor.buffer, pullIntoDescriptor.byteOffset, bytesFilled / elementSize);
-        }
-        function ReadableByteStreamControllerEnqueueChunkToQueue(controller, buffer, byteOffset, byteLength) {
-          controller._queue.push({ buffer, byteOffset, byteLength });
-          controller._queueTotalSize += byteLength;
-        }
-        function ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) {
-          var elementSize = pullIntoDescriptor.elementSize;
-          var currentAlignedBytes = pullIntoDescriptor.bytesFilled - pullIntoDescriptor.bytesFilled % elementSize;
-          var maxBytesToCopy = Math.min(controller._queueTotalSize, pullIntoDescriptor.byteLength - pullIntoDescriptor.bytesFilled);
-          var maxBytesFilled = pullIntoDescriptor.bytesFilled + maxBytesToCopy;
-          var maxAlignedBytes = maxBytesFilled - maxBytesFilled % elementSize;
-          var totalBytesToCopyRemaining = maxBytesToCopy;
-          var ready = false;
-          if (maxAlignedBytes > currentAlignedBytes) {
-            totalBytesToCopyRemaining = maxAlignedBytes - pullIntoDescriptor.bytesFilled;
-            ready = true;
-          }
-          var queue = controller._queue;
-          while (totalBytesToCopyRemaining > 0) {
-            var headOfQueue = queue.peek();
-            var bytesToCopy = Math.min(totalBytesToCopyRemaining, headOfQueue.byteLength);
-            var destStart = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled;
-            ArrayBufferCopy(pullIntoDescriptor.buffer, destStart, headOfQueue.buffer, headOfQueue.byteOffset, bytesToCopy);
-            if (headOfQueue.byteLength === bytesToCopy) {
-              queue.shift();
-            } else {
-              headOfQueue.byteOffset += bytesToCopy;
-              headOfQueue.byteLength -= bytesToCopy;
-            }
-            controller._queueTotalSize -= bytesToCopy;
-            ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesToCopy, pullIntoDescriptor);
-            totalBytesToCopyRemaining -= bytesToCopy;
-          }
-          return ready;
-        }
-        function ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, size, pullIntoDescriptor) {
-          ReadableByteStreamControllerInvalidateBYOBRequest(controller);
-          pullIntoDescriptor.bytesFilled += size;
-        }
-        function ReadableByteStreamControllerHandleQueueDrain(controller) {
-          if (controller._queueTotalSize === 0 && controller._closeRequested === true) {
-            ReadableByteStreamControllerClearAlgorithms(controller);
-            ReadableStreamClose(controller._controlledReadableByteStream);
-          } else {
-            ReadableByteStreamControllerCallPullIfNeeded(controller);
-          }
-        }
-        function ReadableByteStreamControllerInvalidateBYOBRequest(controller) {
-          if (controller._byobRequest === void 0) {
-            return;
-          }
-          controller._byobRequest._associatedReadableByteStreamController = void 0;
-          controller._byobRequest._view = void 0;
-          controller._byobRequest = void 0;
-        }
-        function ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller) {
-          while (controller._pendingPullIntos.length > 0) {
-            if (controller._queueTotalSize === 0) {
-              return;
-            }
-            var pullIntoDescriptor = controller._pendingPullIntos.peek();
-            if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) === true) {
-              ReadableByteStreamControllerShiftPendingPullInto(controller);
-              ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableByteStream, pullIntoDescriptor);
-            }
-          }
-        }
-        function ReadableByteStreamControllerPullInto(controller, view) {
-          var stream = controller._controlledReadableByteStream;
-          var elementSize = 1;
-          if (view.constructor !== DataView) {
-            elementSize = view.constructor.BYTES_PER_ELEMENT;
-          }
-          var ctor = view.constructor;
-          var buffer = TransferArrayBuffer(view.buffer);
-          var pullIntoDescriptor = {
-            buffer,
-            byteOffset: view.byteOffset,
-            byteLength: view.byteLength,
-            bytesFilled: 0,
-            elementSize,
-            ctor,
-            readerType: "byob"
-          };
-          if (controller._pendingPullIntos.length > 0) {
-            controller._pendingPullIntos.push(pullIntoDescriptor);
-            return ReadableStreamAddReadIntoRequest(stream);
-          }
-          if (stream._state === "closed") {
-            var emptyView = new ctor(pullIntoDescriptor.buffer, pullIntoDescriptor.byteOffset, 0);
-            return promiseResolvedWith(ReadableStreamCreateReadResult(emptyView, true, stream._reader._forAuthorCode));
-          }
-          if (controller._queueTotalSize > 0) {
-            if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) === true) {
-              var filledView = ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor);
-              ReadableByteStreamControllerHandleQueueDrain(controller);
-              return promiseResolvedWith(ReadableStreamCreateReadResult(filledView, false, stream._reader._forAuthorCode));
-            }
-            if (controller._closeRequested === true) {
-              var e = new TypeError("Insufficient bytes to fill elements in the given buffer");
-              ReadableByteStreamControllerError(controller, e);
-              return promiseRejectedWith(e);
-            }
-          }
-          controller._pendingPullIntos.push(pullIntoDescriptor);
-          var promise = ReadableStreamAddReadIntoRequest(stream);
-          ReadableByteStreamControllerCallPullIfNeeded(controller);
-          return promise;
-        }
-        function ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor) {
-          firstDescriptor.buffer = TransferArrayBuffer(firstDescriptor.buffer);
-          var stream = controller._controlledReadableByteStream;
-          if (ReadableStreamHasBYOBReader(stream) === true) {
-            while (ReadableStreamGetNumReadIntoRequests(stream) > 0) {
-              var pullIntoDescriptor = ReadableByteStreamControllerShiftPendingPullInto(controller);
-              ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor);
-            }
-          }
-        }
-        function ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, pullIntoDescriptor) {
-          if (pullIntoDescriptor.bytesFilled + bytesWritten > pullIntoDescriptor.byteLength) {
-            throw new RangeError("bytesWritten out of range");
-          }
-          ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesWritten, pullIntoDescriptor);
-          if (pullIntoDescriptor.bytesFilled < pullIntoDescriptor.elementSize) {
-            return;
-          }
-          ReadableByteStreamControllerShiftPendingPullInto(controller);
-          var remainderSize = pullIntoDescriptor.bytesFilled % pullIntoDescriptor.elementSize;
-          if (remainderSize > 0) {
-            var end = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled;
-            var remainder = pullIntoDescriptor.buffer.slice(end - remainderSize, end);
-            ReadableByteStreamControllerEnqueueChunkToQueue(controller, remainder, 0, remainder.byteLength);
-          }
-          pullIntoDescriptor.buffer = TransferArrayBuffer(pullIntoDescriptor.buffer);
-          pullIntoDescriptor.bytesFilled -= remainderSize;
-          ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableByteStream, pullIntoDescriptor);
-          ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);
-        }
-        function ReadableByteStreamControllerRespondInternal(controller, bytesWritten) {
-          var firstDescriptor = controller._pendingPullIntos.peek();
-          var stream = controller._controlledReadableByteStream;
-          if (stream._state === "closed") {
-            if (bytesWritten !== 0) {
-              throw new TypeError("bytesWritten must be 0 when calling respond() on a closed stream");
-            }
-            ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor);
-          } else {
-            ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, firstDescriptor);
-          }
-          ReadableByteStreamControllerCallPullIfNeeded(controller);
-        }
-        function ReadableByteStreamControllerShiftPendingPullInto(controller) {
-          var descriptor = controller._pendingPullIntos.shift();
-          ReadableByteStreamControllerInvalidateBYOBRequest(controller);
-          return descriptor;
-        }
-        function ReadableByteStreamControllerShouldCallPull(controller) {
-          var stream = controller._controlledReadableByteStream;
-          if (stream._state !== "readable") {
-            return false;
-          }
-          if (controller._closeRequested === true) {
-            return false;
-          }
-          if (controller._started === false) {
-            return false;
-          }
-          if (ReadableStreamHasDefaultReader(stream) === true && ReadableStreamGetNumReadRequests(stream) > 0) {
-            return true;
-          }
-          if (ReadableStreamHasBYOBReader(stream) === true && ReadableStreamGetNumReadIntoRequests(stream) > 0) {
-            return true;
-          }
-          var desiredSize = ReadableByteStreamControllerGetDesiredSize(controller);
-          if (desiredSize > 0) {
-            return true;
-          }
-          return false;
-        }
-        function ReadableByteStreamControllerClearAlgorithms(controller) {
-          controller._pullAlgorithm = void 0;
-          controller._cancelAlgorithm = void 0;
-        }
-        function ReadableByteStreamControllerClose(controller) {
-          var stream = controller._controlledReadableByteStream;
-          if (controller._queueTotalSize > 0) {
-            controller._closeRequested = true;
-            return;
-          }
-          if (controller._pendingPullIntos.length > 0) {
-            var firstPendingPullInto = controller._pendingPullIntos.peek();
-            if (firstPendingPullInto.bytesFilled > 0) {
-              var e = new TypeError("Insufficient bytes to fill elements in the given buffer");
-              ReadableByteStreamControllerError(controller, e);
-              throw e;
-            }
-          }
-          ReadableByteStreamControllerClearAlgorithms(controller);
-          ReadableStreamClose(stream);
-        }
-        function ReadableByteStreamControllerEnqueue(controller, chunk) {
-          var stream = controller._controlledReadableByteStream;
-          var buffer = chunk.buffer;
-          var byteOffset = chunk.byteOffset;
-          var byteLength = chunk.byteLength;
-          var transferredBuffer = TransferArrayBuffer(buffer);
-          if (ReadableStreamHasDefaultReader(stream) === true) {
-            if (ReadableStreamGetNumReadRequests(stream) === 0) {
-              ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
-            } else {
-              var transferredView = new Uint8Array(transferredBuffer, byteOffset, byteLength);
-              ReadableStreamFulfillReadRequest(stream, transferredView, false);
-            }
-          } else if (ReadableStreamHasBYOBReader(stream) === true) {
-            ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
-            ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);
-          } else {
-            ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
-          }
-          ReadableByteStreamControllerCallPullIfNeeded(controller);
-        }
-        function ReadableByteStreamControllerError(controller, e) {
-          var stream = controller._controlledReadableByteStream;
-          if (stream._state !== "readable") {
-            return;
-          }
-          ReadableByteStreamControllerClearPendingPullIntos(controller);
-          ResetQueue(controller);
-          ReadableByteStreamControllerClearAlgorithms(controller);
-          ReadableStreamError(stream, e);
-        }
-        function ReadableByteStreamControllerGetDesiredSize(controller) {
-          var stream = controller._controlledReadableByteStream;
-          var state = stream._state;
-          if (state === "errored") {
-            return null;
-          }
-          if (state === "closed") {
-            return 0;
-          }
-          return controller._strategyHWM - controller._queueTotalSize;
-        }
-        function ReadableByteStreamControllerRespond(controller, bytesWritten) {
-          bytesWritten = Number(bytesWritten);
-          if (IsFiniteNonNegativeNumber(bytesWritten) === false) {
-            throw new RangeError("bytesWritten must be a finite");
-          }
-          ReadableByteStreamControllerRespondInternal(controller, bytesWritten);
-        }
-        function ReadableByteStreamControllerRespondWithNewView(controller, view) {
-          var firstDescriptor = controller._pendingPullIntos.peek();
-          if (firstDescriptor.byteOffset + firstDescriptor.bytesFilled !== view.byteOffset) {
-            throw new RangeError("The region specified by view does not match byobRequest");
-          }
-          if (firstDescriptor.byteLength !== view.byteLength) {
-            throw new RangeError("The buffer of view has different capacity than byobRequest");
-          }
-          firstDescriptor.buffer = view.buffer;
-          ReadableByteStreamControllerRespondInternal(controller, view.byteLength);
-        }
-        function SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, autoAllocateChunkSize) {
-          controller._controlledReadableByteStream = stream;
-          controller._pullAgain = false;
-          controller._pulling = false;
-          controller._byobRequest = void 0;
-          controller._queue = controller._queueTotalSize = void 0;
-          ResetQueue(controller);
-          controller._closeRequested = false;
-          controller._started = false;
-          controller._strategyHWM = ValidateAndNormalizeHighWaterMark(highWaterMark);
-          controller._pullAlgorithm = pullAlgorithm;
-          controller._cancelAlgorithm = cancelAlgorithm;
-          controller._autoAllocateChunkSize = autoAllocateChunkSize;
-          controller._pendingPullIntos = new SimpleQueue();
-          stream._readableStreamController = controller;
-          var startResult = startAlgorithm();
-          uponPromise(promiseResolvedWith(startResult), function() {
-            controller._started = true;
-            ReadableByteStreamControllerCallPullIfNeeded(controller);
-          }, function(r) {
-            ReadableByteStreamControllerError(controller, r);
-          });
-        }
-        function SetUpReadableByteStreamControllerFromUnderlyingSource(stream, underlyingByteSource, highWaterMark) {
-          var controller = Object.create(ReadableByteStreamController.prototype);
-          function startAlgorithm() {
-            return InvokeOrNoop(underlyingByteSource, "start", [controller]);
-          }
-          var pullAlgorithm = CreateAlgorithmFromUnderlyingMethod(underlyingByteSource, "pull", 0, [controller]);
-          var cancelAlgorithm = CreateAlgorithmFromUnderlyingMethod(underlyingByteSource, "cancel", 1, []);
-          var autoAllocateChunkSize = underlyingByteSource.autoAllocateChunkSize;
-          if (autoAllocateChunkSize !== void 0) {
-            autoAllocateChunkSize = Number(autoAllocateChunkSize);
-            if (NumberIsInteger(autoAllocateChunkSize) === false || autoAllocateChunkSize <= 0) {
-              throw new RangeError("autoAllocateChunkSize must be a positive integer");
-            }
-          }
-          SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, autoAllocateChunkSize);
-        }
-        function SetUpReadableStreamBYOBRequest(request, controller, view) {
-          request._associatedReadableByteStreamController = controller;
-          request._view = view;
-        }
-        function byobRequestBrandCheckException(name) {
-          return new TypeError("ReadableStreamBYOBRequest.prototype." + name + " can only be used on a ReadableStreamBYOBRequest");
-        }
-        function byteStreamControllerBrandCheckException(name) {
-          return new TypeError("ReadableByteStreamController.prototype." + name + " can only be used on a ReadableByteStreamController");
-        }
-        function AcquireReadableStreamBYOBReader(stream, forAuthorCode) {
-          if (forAuthorCode === void 0) {
-            forAuthorCode = false;
-          }
-          var reader = new ReadableStreamBYOBReader(stream);
-          reader._forAuthorCode = forAuthorCode;
-          return reader;
-        }
-        function ReadableStreamAddReadIntoRequest(stream) {
-          var promise = newPromise(function(resolve, reject) {
-            var readIntoRequest = {
-              _resolve: resolve,
-              _reject: reject
-            };
-            stream._reader._readIntoRequests.push(readIntoRequest);
-          });
-          return promise;
-        }
-        function ReadableStreamFulfillReadIntoRequest(stream, chunk, done) {
-          var reader = stream._reader;
-          var readIntoRequest = reader._readIntoRequests.shift();
-          readIntoRequest._resolve(ReadableStreamCreateReadResult(chunk, done, reader._forAuthorCode));
-        }
-        function ReadableStreamGetNumReadIntoRequests(stream) {
-          return stream._reader._readIntoRequests.length;
-        }
-        function ReadableStreamHasBYOBReader(stream) {
-          var reader = stream._reader;
-          if (reader === void 0) {
-            return false;
-          }
-          if (!IsReadableStreamBYOBReader(reader)) {
-            return false;
-          }
-          return true;
-        }
-        var ReadableStreamBYOBReader = function() {
-          function ReadableStreamBYOBReader2(stream) {
-            if (!IsReadableStream(stream)) {
-              throw new TypeError("ReadableStreamBYOBReader can only be constructed with a ReadableStream instance given a byte source");
-            }
-            if (IsReadableByteStreamController(stream._readableStreamController) === false) {
-              throw new TypeError("Cannot construct a ReadableStreamBYOBReader for a stream not constructed with a byte source");
-            }
-            if (IsReadableStreamLocked(stream)) {
-              throw new TypeError("This stream has already been locked for exclusive reading by another reader");
-            }
-            ReadableStreamReaderGenericInitialize(this, stream);
-            this._readIntoRequests = new SimpleQueue();
-          }
-          Object.defineProperty(ReadableStreamBYOBReader2.prototype, "closed", {
-            get: function() {
-              if (!IsReadableStreamBYOBReader(this)) {
-                return promiseRejectedWith(byobReaderBrandCheckException("closed"));
-              }
-              return this._closedPromise;
-            },
-            enumerable: true,
-            configurable: true
-          });
-          ReadableStreamBYOBReader2.prototype.cancel = function(reason) {
-            if (!IsReadableStreamBYOBReader(this)) {
-              return promiseRejectedWith(byobReaderBrandCheckException("cancel"));
-            }
-            if (this._ownerReadableStream === void 0) {
-              return promiseRejectedWith(readerLockException("cancel"));
-            }
-            return ReadableStreamReaderGenericCancel(this, reason);
-          };
-          ReadableStreamBYOBReader2.prototype.read = function(view) {
-            if (!IsReadableStreamBYOBReader(this)) {
-              return promiseRejectedWith(byobReaderBrandCheckException("read"));
-            }
-            if (this._ownerReadableStream === void 0) {
-              return promiseRejectedWith(readerLockException("read from"));
-            }
-            if (!ArrayBuffer.isView(view)) {
-              return promiseRejectedWith(new TypeError("view must be an array buffer view"));
-            }
-            if (IsDetachedBuffer(view.buffer) === true)
-              ;
-            if (view.byteLength === 0) {
-              return promiseRejectedWith(new TypeError("view must have non-zero byteLength"));
-            }
-            return ReadableStreamBYOBReaderRead(this, view);
-          };
-          ReadableStreamBYOBReader2.prototype.releaseLock = function() {
-            if (!IsReadableStreamBYOBReader(this)) {
-              throw byobReaderBrandCheckException("releaseLock");
-            }
-            if (this._ownerReadableStream === void 0) {
-              return;
-            }
-            if (this._readIntoRequests.length > 0) {
-              throw new TypeError("Tried to release a reader lock when that reader has pending read() calls un-settled");
-            }
-            ReadableStreamReaderGenericRelease(this);
-          };
-          return ReadableStreamBYOBReader2;
-        }();
-        function IsReadableStreamBYOBReader(x) {
-          if (!typeIsObject(x)) {
-            return false;
-          }
-          if (!Object.prototype.hasOwnProperty.call(x, "_readIntoRequests")) {
-            return false;
-          }
-          return true;
-        }
-        function ReadableStreamBYOBReaderRead(reader, view) {
-          var stream = reader._ownerReadableStream;
-          stream._disturbed = true;
-          if (stream._state === "errored") {
-            return promiseRejectedWith(stream._storedError);
-          }
-          return ReadableByteStreamControllerPullInto(stream._readableStreamController, view);
-        }
-        function byobReaderBrandCheckException(name) {
-          return new TypeError("ReadableStreamBYOBReader.prototype." + name + " can only be used on a ReadableStreamBYOBReader");
-        }
-        var ReadableStream = function() {
-          function ReadableStream2(underlyingSource, strategy) {
-            if (underlyingSource === void 0) {
-              underlyingSource = {};
-            }
-            if (strategy === void 0) {
-              strategy = {};
-            }
-            InitializeReadableStream(this);
-            var size = strategy.size;
-            var highWaterMark = strategy.highWaterMark;
-            var type = underlyingSource.type;
-            var typeString = String(type);
-            if (typeString === "bytes") {
-              if (size !== void 0) {
-                throw new RangeError("The strategy for a byte stream cannot have a size function");
-              }
-              if (highWaterMark === void 0) {
-                highWaterMark = 0;
-              }
-              highWaterMark = ValidateAndNormalizeHighWaterMark(highWaterMark);
-              SetUpReadableByteStreamControllerFromUnderlyingSource(this, underlyingSource, highWaterMark);
-            } else if (type === void 0) {
-              var sizeAlgorithm = MakeSizeAlgorithmFromSizeFunction(size);
-              if (highWaterMark === void 0) {
-                highWaterMark = 1;
-              }
-              highWaterMark = ValidateAndNormalizeHighWaterMark(highWaterMark);
-              SetUpReadableStreamDefaultControllerFromUnderlyingSource(this, underlyingSource, highWaterMark, sizeAlgorithm);
-            } else {
-              throw new RangeError("Invalid type is specified");
-            }
-          }
-          Object.defineProperty(ReadableStream2.prototype, "locked", {
-            get: function() {
-              if (IsReadableStream(this) === false) {
-                throw streamBrandCheckException$1("locked");
-              }
-              return IsReadableStreamLocked(this);
-            },
-            enumerable: true,
-            configurable: true
-          });
-          ReadableStream2.prototype.cancel = function(reason) {
-            if (IsReadableStream(this) === false) {
-              return promiseRejectedWith(streamBrandCheckException$1("cancel"));
-            }
-            if (IsReadableStreamLocked(this) === true) {
-              return promiseRejectedWith(new TypeError("Cannot cancel a stream that already has a reader"));
-            }
-            return ReadableStreamCancel(this, reason);
-          };
-          ReadableStream2.prototype.getReader = function(_a2) {
-            var mode = (_a2 === void 0 ? {} : _a2).mode;
-            if (IsReadableStream(this) === false) {
-              throw streamBrandCheckException$1("getReader");
-            }
-            if (mode === void 0) {
-              return AcquireReadableStreamDefaultReader(this, true);
-            }
-            mode = String(mode);
-            if (mode === "byob") {
-              return AcquireReadableStreamBYOBReader(this, true);
-            }
-            throw new RangeError("Invalid mode is specified");
-          };
-          ReadableStream2.prototype.pipeThrough = function(_a2, _b) {
-            var writable = _a2.writable, readable = _a2.readable;
-            var _c = _b === void 0 ? {} : _b, preventClose = _c.preventClose, preventAbort = _c.preventAbort, preventCancel = _c.preventCancel, signal = _c.signal;
-            if (IsReadableStream(this) === false) {
-              throw streamBrandCheckException$1("pipeThrough");
-            }
-            if (IsWritableStream(writable) === false) {
-              throw new TypeError("writable argument to pipeThrough must be a WritableStream");
-            }
-            if (IsReadableStream(readable) === false) {
-              throw new TypeError("readable argument to pipeThrough must be a ReadableStream");
-            }
-            preventClose = Boolean(preventClose);
-            preventAbort = Boolean(preventAbort);
-            preventCancel = Boolean(preventCancel);
-            if (signal !== void 0 && !isAbortSignal(signal)) {
-              throw new TypeError("ReadableStream.prototype.pipeThrough's signal option must be an AbortSignal");
-            }
-            if (IsReadableStreamLocked(this) === true) {
-              throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked ReadableStream");
-            }
-            if (IsWritableStreamLocked(writable) === true) {
-              throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked WritableStream");
-            }
-            var promise = ReadableStreamPipeTo(this, writable, preventClose, preventAbort, preventCancel, signal);
-            setPromiseIsHandledToTrue(promise);
-            return readable;
-          };
-          ReadableStream2.prototype.pipeTo = function(dest, _a2) {
-            var _b = _a2 === void 0 ? {} : _a2, preventClose = _b.preventClose, preventAbort = _b.preventAbort, preventCancel = _b.preventCancel, signal = _b.signal;
-            if (IsReadableStream(this) === false) {
-              return promiseRejectedWith(streamBrandCheckException$1("pipeTo"));
-            }
-            if (IsWritableStream(dest) === false) {
-              return promiseRejectedWith(new TypeError("ReadableStream.prototype.pipeTo's first argument must be a WritableStream"));
-            }
-            preventClose = Boolean(preventClose);
-            preventAbort = Boolean(preventAbort);
-            preventCancel = Boolean(preventCancel);
-            if (signal !== void 0 && !isAbortSignal(signal)) {
-              return promiseRejectedWith(new TypeError("ReadableStream.prototype.pipeTo's signal option must be an AbortSignal"));
-            }
-            if (IsReadableStreamLocked(this) === true) {
-              return promiseRejectedWith(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked ReadableStream"));
-            }
-            if (IsWritableStreamLocked(dest) === true) {
-              return promiseRejectedWith(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked WritableStream"));
-            }
-            return ReadableStreamPipeTo(this, dest, preventClose, preventAbort, preventCancel, signal);
-          };
-          ReadableStream2.prototype.tee = function() {
-            if (IsReadableStream(this) === false) {
-              throw streamBrandCheckException$1("tee");
-            }
-            var branches = ReadableStreamTee(this);
-            return createArrayFromList(branches);
-          };
-          ReadableStream2.prototype.getIterator = function(_a2) {
-            var _b = (_a2 === void 0 ? {} : _a2).preventCancel, preventCancel = _b === void 0 ? false : _b;
-            if (IsReadableStream(this) === false) {
-              throw streamBrandCheckException$1("getIterator");
-            }
-            return AcquireReadableStreamAsyncIterator(this, preventCancel);
-          };
-          return ReadableStream2;
-        }();
-        if (typeof SymbolPolyfill.asyncIterator === "symbol") {
-          Object.defineProperty(ReadableStream.prototype, SymbolPolyfill.asyncIterator, {
-            value: ReadableStream.prototype.getIterator,
-            enumerable: false,
-            writable: true,
-            configurable: true
-          });
-        }
-        function CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm) {
-          if (highWaterMark === void 0) {
-            highWaterMark = 1;
-          }
-          if (sizeAlgorithm === void 0) {
-            sizeAlgorithm = function() {
-              return 1;
-            };
-          }
-          var stream = Object.create(ReadableStream.prototype);
-          InitializeReadableStream(stream);
-          var controller = Object.create(ReadableStreamDefaultController.prototype);
-          SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm);
-          return stream;
-        }
-        function InitializeReadableStream(stream) {
-          stream._state = "readable";
-          stream._reader = void 0;
-          stream._storedError = void 0;
-          stream._disturbed = false;
-        }
-        function IsReadableStream(x) {
-          if (!typeIsObject(x)) {
-            return false;
-          }
-          if (!Object.prototype.hasOwnProperty.call(x, "_readableStreamController")) {
-            return false;
-          }
-          return true;
-        }
-        function IsReadableStreamLocked(stream) {
-          if (stream._reader === void 0) {
-            return false;
-          }
-          return true;
-        }
-        function ReadableStreamCancel(stream, reason) {
-          stream._disturbed = true;
-          if (stream._state === "closed") {
-            return promiseResolvedWith(void 0);
-          }
-          if (stream._state === "errored") {
-            return promiseRejectedWith(stream._storedError);
-          }
-          ReadableStreamClose(stream);
-          var sourceCancelPromise = stream._readableStreamController[CancelSteps](reason);
-          return transformPromiseWith(sourceCancelPromise, noop);
-        }
-        function ReadableStreamClose(stream) {
-          stream._state = "closed";
-          var reader = stream._reader;
-          if (reader === void 0) {
-            return;
-          }
-          if (IsReadableStreamDefaultReader(reader)) {
-            reader._readRequests.forEach(function(readRequest) {
-              readRequest._resolve(ReadableStreamCreateReadResult(void 0, true, reader._forAuthorCode));
-            });
-            reader._readRequests = new SimpleQueue();
-          }
-          defaultReaderClosedPromiseResolve(reader);
-        }
-        function ReadableStreamError(stream, e) {
-          stream._state = "errored";
-          stream._storedError = e;
-          var reader = stream._reader;
-          if (reader === void 0) {
-            return;
-          }
-          if (IsReadableStreamDefaultReader(reader)) {
-            reader._readRequests.forEach(function(readRequest) {
-              readRequest._reject(e);
-            });
-            reader._readRequests = new SimpleQueue();
-          } else {
-            reader._readIntoRequests.forEach(function(readIntoRequest) {
-              readIntoRequest._reject(e);
-            });
-            reader._readIntoRequests = new SimpleQueue();
-          }
-          defaultReaderClosedPromiseReject(reader, e);
-        }
-        function streamBrandCheckException$1(name) {
-          return new TypeError("ReadableStream.prototype." + name + " can only be used on a ReadableStream");
-        }
-        var ByteLengthQueuingStrategy = function() {
-          function ByteLengthQueuingStrategy2(_a2) {
-            var highWaterMark = _a2.highWaterMark;
-            this.highWaterMark = highWaterMark;
-          }
-          ByteLengthQueuingStrategy2.prototype.size = function(chunk) {
-            return chunk.byteLength;
-          };
-          return ByteLengthQueuingStrategy2;
-        }();
-        var CountQueuingStrategy = function() {
-          function CountQueuingStrategy2(_a2) {
-            var highWaterMark = _a2.highWaterMark;
-            this.highWaterMark = highWaterMark;
-          }
-          CountQueuingStrategy2.prototype.size = function() {
-            return 1;
-          };
-          return CountQueuingStrategy2;
-        }();
-        var TransformStream = function() {
-          function TransformStream2(transformer, writableStrategy, readableStrategy) {
-            if (transformer === void 0) {
-              transformer = {};
-            }
-            if (writableStrategy === void 0) {
-              writableStrategy = {};
-            }
-            if (readableStrategy === void 0) {
-              readableStrategy = {};
-            }
-            var writableSizeFunction = writableStrategy.size;
-            var writableHighWaterMark = writableStrategy.highWaterMark;
-            var readableSizeFunction = readableStrategy.size;
-            var readableHighWaterMark = readableStrategy.highWaterMark;
-            var writableType = transformer.writableType;
-            if (writableType !== void 0) {
-              throw new RangeError("Invalid writable type specified");
-            }
-            var writableSizeAlgorithm = MakeSizeAlgorithmFromSizeFunction(writableSizeFunction);
-            if (writableHighWaterMark === void 0) {
-              writableHighWaterMark = 1;
-            }
-            writableHighWaterMark = ValidateAndNormalizeHighWaterMark(writableHighWaterMark);
-            var readableType = transformer.readableType;
-            if (readableType !== void 0) {
-              throw new RangeError("Invalid readable type specified");
-            }
-            var readableSizeAlgorithm = MakeSizeAlgorithmFromSizeFunction(readableSizeFunction);
-            if (readableHighWaterMark === void 0) {
-              readableHighWaterMark = 0;
-            }
-            readableHighWaterMark = ValidateAndNormalizeHighWaterMark(readableHighWaterMark);
-            var startPromise_resolve;
-            var startPromise = newPromise(function(resolve) {
-              startPromise_resolve = resolve;
-            });
-            InitializeTransformStream(this, startPromise, writableHighWaterMark, writableSizeAlgorithm, readableHighWaterMark, readableSizeAlgorithm);
-            SetUpTransformStreamDefaultControllerFromTransformer(this, transformer);
-            var startResult = InvokeOrNoop(transformer, "start", [this._transformStreamController]);
-            startPromise_resolve(startResult);
-          }
-          Object.defineProperty(TransformStream2.prototype, "readable", {
-            get: function() {
-              if (IsTransformStream(this) === false) {
-                throw streamBrandCheckException$2("readable");
-              }
-              return this._readable;
-            },
-            enumerable: true,
-            configurable: true
-          });
-          Object.defineProperty(TransformStream2.prototype, "writable", {
-            get: function() {
-              if (IsTransformStream(this) === false) {
-                throw streamBrandCheckException$2("writable");
-              }
-              return this._writable;
-            },
-            enumerable: true,
-            configurable: true
-          });
-          return TransformStream2;
-        }();
-        function InitializeTransformStream(stream, startPromise, writableHighWaterMark, writableSizeAlgorithm, readableHighWaterMark, readableSizeAlgorithm) {
-          function startAlgorithm() {
-            return startPromise;
-          }
-          function writeAlgorithm(chunk) {
-            return TransformStreamDefaultSinkWriteAlgorithm(stream, chunk);
-          }
-          function abortAlgorithm(reason) {
-            return TransformStreamDefaultSinkAbortAlgorithm(stream, reason);
-          }
-          function closeAlgorithm() {
-            return TransformStreamDefaultSinkCloseAlgorithm(stream);
-          }
-          stream._writable = CreateWritableStream(startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, writableHighWaterMark, writableSizeAlgorithm);
-          function pullAlgorithm() {
-            return TransformStreamDefaultSourcePullAlgorithm(stream);
-          }
-          function cancelAlgorithm(reason) {
-            TransformStreamErrorWritableAndUnblockWrite(stream, reason);
-            return promiseResolvedWith(void 0);
-          }
-          stream._readable = CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, readableHighWaterMark, readableSizeAlgorithm);
-          stream._backpressure = void 0;
-          stream._backpressureChangePromise = void 0;
-          stream._backpressureChangePromise_resolve = void 0;
-          TransformStreamSetBackpressure(stream, true);
-          stream._transformStreamController = void 0;
-        }
-        function IsTransformStream(x) {
-          if (!typeIsObject(x)) {
-            return false;
-          }
-          if (!Object.prototype.hasOwnProperty.call(x, "_transformStreamController")) {
-            return false;
-          }
-          return true;
-        }
-        function TransformStreamError(stream, e) {
-          ReadableStreamDefaultControllerError(stream._readable._readableStreamController, e);
-          TransformStreamErrorWritableAndUnblockWrite(stream, e);
-        }
-        function TransformStreamErrorWritableAndUnblockWrite(stream, e) {
-          TransformStreamDefaultControllerClearAlgorithms(stream._transformStreamController);
-          WritableStreamDefaultControllerErrorIfNeeded(stream._writable._writableStreamController, e);
-          if (stream._backpressure === true) {
-            TransformStreamSetBackpressure(stream, false);
-          }
-        }
-        function TransformStreamSetBackpressure(stream, backpressure) {
-          if (stream._backpressureChangePromise !== void 0) {
-            stream._backpressureChangePromise_resolve();
-          }
-          stream._backpressureChangePromise = newPromise(function(resolve) {
-            stream._backpressureChangePromise_resolve = resolve;
-          });
-          stream._backpressure = backpressure;
-        }
-        var TransformStreamDefaultController = function() {
-          function TransformStreamDefaultController2() {
-            throw new TypeError("TransformStreamDefaultController instances cannot be created directly");
-          }
-          Object.defineProperty(TransformStreamDefaultController2.prototype, "desiredSize", {
-            get: function() {
-              if (IsTransformStreamDefaultController(this) === false) {
-                throw defaultControllerBrandCheckException$1("desiredSize");
-              }
-              var readableController = this._controlledTransformStream._readable._readableStreamController;
-              return ReadableStreamDefaultControllerGetDesiredSize(readableController);
-            },
-            enumerable: true,
-            configurable: true
-          });
-          TransformStreamDefaultController2.prototype.enqueue = function(chunk) {
-            if (IsTransformStreamDefaultController(this) === false) {
-              throw defaultControllerBrandCheckException$1("enqueue");
-            }
-            TransformStreamDefaultControllerEnqueue(this, chunk);
-          };
-          TransformStreamDefaultController2.prototype.error = function(reason) {
-            if (IsTransformStreamDefaultController(this) === false) {
-              throw defaultControllerBrandCheckException$1("error");
-            }
-            TransformStreamDefaultControllerError(this, reason);
-          };
-          TransformStreamDefaultController2.prototype.terminate = function() {
-            if (IsTransformStreamDefaultController(this) === false) {
-              throw defaultControllerBrandCheckException$1("terminate");
-            }
-            TransformStreamDefaultControllerTerminate(this);
-          };
-          return TransformStreamDefaultController2;
-        }();
-        function IsTransformStreamDefaultController(x) {
-          if (!typeIsObject(x)) {
-            return false;
-          }
-          if (!Object.prototype.hasOwnProperty.call(x, "_controlledTransformStream")) {
-            return false;
-          }
-          return true;
-        }
-        function SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm) {
-          controller._controlledTransformStream = stream;
-          stream._transformStreamController = controller;
-          controller._transformAlgorithm = transformAlgorithm;
-          controller._flushAlgorithm = flushAlgorithm;
-        }
-        function SetUpTransformStreamDefaultControllerFromTransformer(stream, transformer) {
-          var controller = Object.create(TransformStreamDefaultController.prototype);
-          var transformAlgorithm = function(chunk) {
-            try {
-              TransformStreamDefaultControllerEnqueue(controller, chunk);
-              return promiseResolvedWith(void 0);
-            } catch (transformResultE) {
-              return promiseRejectedWith(transformResultE);
-            }
-          };
-          var transformMethod = transformer.transform;
-          if (transformMethod !== void 0) {
-            if (typeof transformMethod !== "function") {
-              throw new TypeError("transform is not a method");
-            }
-            transformAlgorithm = function(chunk) {
-              return PromiseCall(transformMethod, transformer, [chunk, controller]);
-            };
-          }
-          var flushAlgorithm = CreateAlgorithmFromUnderlyingMethod(transformer, "flush", 0, [controller]);
-          SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm);
-        }
-        function TransformStreamDefaultControllerClearAlgorithms(controller) {
-          controller._transformAlgorithm = void 0;
-          controller._flushAlgorithm = void 0;
-        }
-        function TransformStreamDefaultControllerEnqueue(controller, chunk) {
-          var stream = controller._controlledTransformStream;
-          var readableController = stream._readable._readableStreamController;
-          if (ReadableStreamDefaultControllerCanCloseOrEnqueue(readableController) === false) {
-            throw new TypeError("Readable side is not in a state that permits enqueue");
-          }
-          try {
-            ReadableStreamDefaultControllerEnqueue(readableController, chunk);
-          } catch (e) {
-            TransformStreamErrorWritableAndUnblockWrite(stream, e);
-            throw stream._readable._storedError;
-          }
-          var backpressure = ReadableStreamDefaultControllerHasBackpressure(readableController);
-          if (backpressure !== stream._backpressure) {
-            TransformStreamSetBackpressure(stream, true);
-          }
-        }
-        function TransformStreamDefaultControllerError(controller, e) {
-          TransformStreamError(controller._controlledTransformStream, e);
-        }
-        function TransformStreamDefaultControllerPerformTransform(controller, chunk) {
-          var transformPromise = controller._transformAlgorithm(chunk);
-          return transformPromiseWith(transformPromise, void 0, function(r) {
-            TransformStreamError(controller._controlledTransformStream, r);
-            throw r;
-          });
-        }
-        function TransformStreamDefaultControllerTerminate(controller) {
-          var stream = controller._controlledTransformStream;
-          var readableController = stream._readable._readableStreamController;
-          if (ReadableStreamDefaultControllerCanCloseOrEnqueue(readableController) === true) {
-            ReadableStreamDefaultControllerClose(readableController);
-          }
-          var error = new TypeError("TransformStream terminated");
-          TransformStreamErrorWritableAndUnblockWrite(stream, error);
-        }
-        function TransformStreamDefaultSinkWriteAlgorithm(stream, chunk) {
-          var controller = stream._transformStreamController;
-          if (stream._backpressure === true) {
-            var backpressureChangePromise = stream._backpressureChangePromise;
-            return transformPromiseWith(backpressureChangePromise, function() {
-              var writable = stream._writable;
-              var state = writable._state;
-              if (state === "erroring") {
-                throw writable._storedError;
-              }
-              return TransformStreamDefaultControllerPerformTransform(controller, chunk);
-            });
-          }
-          return TransformStreamDefaultControllerPerformTransform(controller, chunk);
-        }
-        function TransformStreamDefaultSinkAbortAlgorithm(stream, reason) {
-          TransformStreamError(stream, reason);
-          return promiseResolvedWith(void 0);
-        }
-        function TransformStreamDefaultSinkCloseAlgorithm(stream) {
-          var readable = stream._readable;
-          var controller = stream._transformStreamController;
-          var flushPromise = controller._flushAlgorithm();
-          TransformStreamDefaultControllerClearAlgorithms(controller);
-          return transformPromiseWith(flushPromise, function() {
-            if (readable._state === "errored") {
-              throw readable._storedError;
-            }
-            var readableController = readable._readableStreamController;
-            if (ReadableStreamDefaultControllerCanCloseOrEnqueue(readableController) === true) {
-              ReadableStreamDefaultControllerClose(readableController);
-            }
-          }, function(r) {
-            TransformStreamError(stream, r);
-            throw readable._storedError;
-          });
-        }
-        function TransformStreamDefaultSourcePullAlgorithm(stream) {
-          TransformStreamSetBackpressure(stream, false);
-          return stream._backpressureChangePromise;
-        }
-        function defaultControllerBrandCheckException$1(name) {
-          return new TypeError("TransformStreamDefaultController.prototype." + name + " can only be used on a TransformStreamDefaultController");
-        }
-        function streamBrandCheckException$2(name) {
-          return new TypeError("TransformStream.prototype." + name + " can only be used on a TransformStream");
-        }
-        exports2.ByteLengthQueuingStrategy = ByteLengthQueuingStrategy;
-        exports2.CountQueuingStrategy = CountQueuingStrategy;
-        exports2.ReadableStream = ReadableStream;
-        exports2.TransformStream = TransformStream;
-        exports2.WritableStream = WritableStream;
-        Object.defineProperty(exports2, "__esModule", { value: true });
-      });
-    }
-  });
-
-  // ../../node_modules/flatgeobuf/dist/flatgeobuf-geojson.min.js
-  var require_flatgeobuf_geojson_min = __commonJS({
-    "../../node_modules/flatgeobuf/dist/flatgeobuf-geojson.min.js"(exports, module) {
-      !function(t, e) {
-        typeof exports == "object" && typeof module != "undefined" ? e(exports, require_ponyfill()) : typeof define == "function" && define.amd ? define(["exports", "web-streams-polyfill/ponyfill"], e) : e((t = t || self).flatgeobuf = {}, t.ponyfill);
-      }(exports, function(t, e) {
-        "use strict";
-        class r {
-          constructor(t2, e2) {
-            this.name = t2, this.type = e2;
-          }
-        }
-        var i;
-        !function(t2) {
-          t2[t2.Byte = 0] = "Byte", t2[t2.UByte = 1] = "UByte", t2[t2.Bool = 2] = "Bool", t2[t2.Short = 3] = "Short", t2[t2.UShort = 4] = "UShort", t2[t2.Int = 5] = "Int", t2[t2.UInt = 6] = "UInt", t2[t2.Long = 7] = "Long", t2[t2.ULong = 8] = "ULong", t2[t2.Float = 9] = "Float", t2[t2.Double = 10] = "Double", t2[t2.String = 11] = "String", t2[t2.Json = 12] = "Json", t2[t2.DateTime = 13] = "DateTime", t2[t2.Binary = 14] = "Binary";
-        }(i || (i = {}));
-        var n = i;
-        class s {
-          constructor(t2, e2, r2) {
-            this.geometryType = t2, this.columns = e2, this.featuresCount = r2;
-          }
-        }
-        var o, a, b, u, h = {};
-        h.SIZEOF_SHORT = 2, h.SIZEOF_INT = 4, h.FILE_IDENTIFIER_LENGTH = 4, h.SIZE_PREFIX_LENGTH = 4, h.Encoding = { UTF8_BYTES: 1, UTF16_STRING: 2 }, h.int32 = new Int32Array(2), h.float32 = new Float32Array(h.int32.buffer), h.float64 = new Float64Array(h.int32.buffer), h.isLittleEndian = new Uint16Array(new Uint8Array([1, 0]).buffer)[0] === 1, h.Long = function(t2, e2) {
-          this.low = 0 | t2, this.high = 0 | e2;
-        }, h.Long.create = function(t2, e2) {
-          return t2 == 0 && e2 == 0 ? h.Long.ZERO : new h.Long(t2, e2);
-        }, h.Long.prototype.toFloat64 = function() {
-          return (this.low >>> 0) + 4294967296 * this.high;
-        }, h.Long.prototype.equals = function(t2) {
-          return this.low == t2.low && this.high == t2.high;
-        }, h.Long.ZERO = new h.Long(0, 0), h.Builder = function(t2) {
-          if (t2)
-            e2 = t2;
-          else
-            var e2 = 1024;
-          this.bb = h.ByteBuffer.allocate(e2), this.space = e2, this.minalign = 1, this.vtable = null, this.vtable_in_use = 0, this.isNested = false, this.object_start = 0, this.vtables = [], this.vector_num_elems = 0, this.force_defaults = false;
-        }, h.Builder.prototype.clear = function() {
-          this.bb.clear(), this.space = this.bb.capacity(), this.minalign = 1, this.vtable = null, this.vtable_in_use = 0, this.isNested = false, this.object_start = 0, this.vtables = [], this.vector_num_elems = 0, this.force_defaults = false;
-        }, h.Builder.prototype.forceDefaults = function(t2) {
-          this.force_defaults = t2;
-        }, h.Builder.prototype.dataBuffer = function() {
-          return this.bb;
-        }, h.Builder.prototype.asUint8Array = function() {
-          return this.bb.bytes().subarray(this.bb.position(), this.bb.position() + this.offset());
-        }, h.Builder.prototype.prep = function(t2, e2) {
-          t2 > this.minalign && (this.minalign = t2);
-          for (var r2 = 1 + ~(this.bb.capacity() - this.space + e2) & t2 - 1; this.space < r2 + t2 + e2; ) {
-            var i2 = this.bb.capacity();
-            this.bb = h.Builder.growByteBuffer(this.bb), this.space += this.bb.capacity() - i2;
-          }
-          this.pad(r2);
-        }, h.Builder.prototype.pad = function(t2) {
-          for (var e2 = 0; e2 < t2; e2++)
-            this.bb.writeInt8(--this.space, 0);
-        }, h.Builder.prototype.writeInt8 = function(t2) {
-          this.bb.writeInt8(this.space -= 1, t2);
-        }, h.Builder.prototype.writeInt16 = function(t2) {
-          this.bb.writeInt16(this.space -= 2, t2);
-        }, h.Builder.prototype.writeInt32 = function(t2) {
-          this.bb.writeInt32(this.space -= 4, t2);
-        }, h.Builder.prototype.writeInt64 = function(t2) {
-          this.bb.writeInt64(this.space -= 8, t2);
-        }, h.Builder.prototype.writeFloat32 = function(t2) {
-          this.bb.writeFloat32(this.space -= 4, t2);
-        }, h.Builder.prototype.writeFloat64 = function(t2) {
-          this.bb.writeFloat64(this.space -= 8, t2);
-        }, h.Builder.prototype.addInt8 = function(t2) {
-          this.prep(1, 0), this.writeInt8(t2);
-        }, h.Builder.prototype.addInt16 = function(t2) {
-          this.prep(2, 0), this.writeInt16(t2);
-        }, h.Builder.prototype.addInt32 = function(t2) {
-          this.prep(4, 0), this.writeInt32(t2);
-        }, h.Builder.prototype.addInt64 = function(t2) {
-          this.prep(8, 0), this.writeInt64(t2);
-        }, h.Builder.prototype.addFloat32 = function(t2) {
-          this.prep(4, 0), this.writeFloat32(t2);
-        }, h.Builder.prototype.addFloat64 = function(t2) {
-          this.prep(8, 0), this.writeFloat64(t2);
-        }, h.Builder.prototype.addFieldInt8 = function(t2, e2, r2) {
-          (this.force_defaults || e2 != r2) && (this.addInt8(e2), this.slot(t2));
-        }, h.Builder.prototype.addFieldInt16 = function(t2, e2, r2) {
-          (this.force_defaults || e2 != r2) && (this.addInt16(e2), this.slot(t2));
-        }, h.Builder.prototype.addFieldInt32 = function(t2, e2, r2) {
-          (this.force_defaults || e2 != r2) && (this.addInt32(e2), this.slot(t2));
-        }, h.Builder.prototype.addFieldInt64 = function(t2, e2, r2) {
-          !this.force_defaults && e2.equals(r2) || (this.addInt64(e2), this.slot(t2));
-        }, h.Builder.prototype.addFieldFloat32 = function(t2, e2, r2) {
-          (this.force_defaults || e2 != r2) && (this.addFloat32(e2), this.slot(t2));
-        }, h.Builder.prototype.addFieldFloat64 = function(t2, e2, r2) {
-          (this.force_defaults || e2 != r2) && (this.addFloat64(e2), this.slot(t2));
-        }, h.Builder.prototype.addFieldOffset = function(t2, e2, r2) {
-          (this.force_defaults || e2 != r2) && (this.addOffset(e2), this.slot(t2));
-        }, h.Builder.prototype.addFieldStruct = function(t2, e2, r2) {
-          e2 != r2 && (this.nested(e2), this.slot(t2));
-        }, h.Builder.prototype.nested = function(t2) {
-          if (t2 != this.offset())
-            throw new Error("FlatBuffers: struct must be serialized inline.");
-        }, h.Builder.prototype.notNested = function() {
-          if (this.isNested)
-            throw new Error("FlatBuffers: object serialization must not be nested.");
-        }, h.Builder.prototype.slot = function(t2) {
-          this.vtable[t2] = this.offset();
-        }, h.Builder.prototype.offset = function() {
-          return this.bb.capacity() - this.space;
-        }, h.Builder.growByteBuffer = function(t2) {
-          var e2 = t2.capacity();
-          if (3221225472 & e2)
-            throw new Error("FlatBuffers: cannot grow buffer beyond 2 gigabytes.");
-          var r2 = e2 << 1, i2 = h.ByteBuffer.allocate(r2);
-          return i2.setPosition(r2 - e2), i2.bytes().set(t2.bytes(), r2 - e2), i2;
-        }, h.Builder.prototype.addOffset = function(t2) {
-          this.prep(h.SIZEOF_INT, 0), this.writeInt32(this.offset() - t2 + h.SIZEOF_INT);
-        }, h.Builder.prototype.startObject = function(t2) {
-          this.notNested(), this.vtable == null && (this.vtable = []), this.vtable_in_use = t2;
-          for (var e2 = 0; e2 < t2; e2++)
-            this.vtable[e2] = 0;
-          this.isNested = true, this.object_start = this.offset();
-        }, h.Builder.prototype.endObject = function() {
-          if (this.vtable == null || !this.isNested)
-            throw new Error("FlatBuffers: endObject called without startObject");
-          this.addInt32(0);
-          for (var t2 = this.offset(), e2 = this.vtable_in_use - 1; e2 >= 0 && this.vtable[e2] == 0; e2--)
-            ;
-          for (var r2 = e2 + 1; e2 >= 0; e2--)
-            this.addInt16(this.vtable[e2] != 0 ? t2 - this.vtable[e2] : 0);
-          this.addInt16(t2 - this.object_start);
-          var i2 = (r2 + 2) * h.SIZEOF_SHORT;
-          this.addInt16(i2);
-          var n2 = 0, s2 = this.space;
-          t:
-            for (e2 = 0; e2 < this.vtables.length; e2++) {
-              var o2 = this.bb.capacity() - this.vtables[e2];
-              if (i2 == this.bb.readInt16(o2)) {
-                for (var a2 = h.SIZEOF_SHORT; a2 < i2; a2 += h.SIZEOF_SHORT)
-                  if (this.bb.readInt16(s2 + a2) != this.bb.readInt16(o2 + a2))
-                    continue t;
-                n2 = this.vtables[e2];
-                break;
-              }
-            }
-          return n2 ? (this.space = this.bb.capacity() - t2, this.bb.writeInt32(this.space, n2 - t2)) : (this.vtables.push(this.offset()), this.bb.writeInt32(this.bb.capacity() - t2, this.offset() - t2)), this.isNested = false, t2;
-        }, h.Builder.prototype.finish = function(t2, e2, r2) {
-          var i2 = r2 ? h.SIZE_PREFIX_LENGTH : 0;
-          if (e2) {
-            var n2 = e2;
-            if (this.prep(this.minalign, h.SIZEOF_INT + h.FILE_IDENTIFIER_LENGTH + i2), n2.length != h.FILE_IDENTIFIER_LENGTH)
-              throw new Error("FlatBuffers: file identifier must be length " + h.FILE_IDENTIFIER_LENGTH);
-            for (var s2 = h.FILE_IDENTIFIER_LENGTH - 1; s2 >= 0; s2--)
-              this.writeInt8(n2.charCodeAt(s2));
-          }
-          this.prep(this.minalign, h.SIZEOF_INT + i2), this.addOffset(t2), i2 && this.addInt32(this.bb.capacity() - this.space), this.bb.setPosition(this.space);
-        }, h.Builder.prototype.finishSizePrefixed = function(t2, e2) {
-          this.finish(t2, e2, true);
-        }, h.Builder.prototype.requiredField = function(t2, e2) {
-          var r2 = this.bb.capacity() - t2, i2 = r2 - this.bb.readInt32(r2);
-          if (!(this.bb.readInt16(i2 + e2) != 0))
-            throw new Error("FlatBuffers: field " + e2 + " must be set");
-        }, h.Builder.prototype.startVector = function(t2, e2, r2) {
-          this.notNested(), this.vector_num_elems = e2, this.prep(h.SIZEOF_INT, t2 * e2), this.prep(r2, t2 * e2);
-        }, h.Builder.prototype.endVector = function() {
-          return this.writeInt32(this.vector_num_elems), this.offset();
-        }, h.Builder.prototype.createString = function(t2) {
-          if (t2 instanceof Uint8Array)
-            var e2 = t2;
-          else {
-            e2 = [];
-            for (var r2 = 0; r2 < t2.length; ) {
-              var i2, n2 = t2.charCodeAt(r2++);
-              if (n2 < 55296 || n2 >= 56320)
-                i2 = n2;
-              else
-                i2 = (n2 << 10) + t2.charCodeAt(r2++) + -56613888;
-              i2 < 128 ? e2.push(i2) : (i2 < 2048 ? e2.push(i2 >> 6 & 31 | 192) : (i2 < 65536 ? e2.push(i2 >> 12 & 15 | 224) : e2.push(i2 >> 18 & 7 | 240, i2 >> 12 & 63 | 128), e2.push(i2 >> 6 & 63 | 128)), e2.push(63 & i2 | 128));
-            }
-          }
-          this.addInt8(0), this.startVector(1, e2.length, 1), this.bb.setPosition(this.space -= e2.length);
-          r2 = 0;
-          for (var s2 = this.space, o2 = this.bb.bytes(); r2 < e2.length; r2++)
-            o2[s2++] = e2[r2];
-          return this.endVector();
-        }, h.Builder.prototype.createLong = function(t2, e2) {
-          return h.Long.create(t2, e2);
-        }, h.ByteBuffer = function(t2) {
-          this.bytes_ = t2, this.position_ = 0;
-        }, h.ByteBuffer.allocate = function(t2) {
-          return new h.ByteBuffer(new Uint8Array(t2));
-        }, h.ByteBuffer.prototype.clear = function() {
-          this.position_ = 0;
-        }, h.ByteBuffer.prototype.bytes = function() {
-          return this.bytes_;
-        }, h.ByteBuffer.prototype.position = function() {
-          return this.position_;
-        }, h.ByteBuffer.prototype.setPosition = function(t2) {
-          this.position_ = t2;
-        }, h.ByteBuffer.prototype.capacity = function() {
-          return this.bytes_.length;
-        }, h.ByteBuffer.prototype.readInt8 = function(t2) {
-          return this.readUint8(t2) << 24 >> 24;
-        }, h.ByteBuffer.prototype.readUint8 = function(t2) {
-          return this.bytes_[t2];
-        }, h.ByteBuffer.prototype.readInt16 = function(t2) {
-          return this.readUint16(t2) << 16 >> 16;
-        }, h.ByteBuffer.prototype.readUint16 = function(t2) {
-          return this.bytes_[t2] | this.bytes_[t2 + 1] << 8;
-        }, h.ByteBuffer.prototype.readInt32 = function(t2) {
-          return this.bytes_[t2] | this.bytes_[t2 + 1] << 8 | this.bytes_[t2 + 2] << 16 | this.bytes_[t2 + 3] << 24;
-        }, h.ByteBuffer.prototype.readUint32 = function(t2) {
-          return this.readInt32(t2) >>> 0;
-        }, h.ByteBuffer.prototype.readInt64 = function(t2) {
-          return new h.Long(this.readInt32(t2), this.readInt32(t2 + 4));
-        }, h.ByteBuffer.prototype.readUint64 = function(t2) {
-          return new h.Long(this.readUint32(t2), this.readUint32(t2 + 4));
-        }, h.ByteBuffer.prototype.readFloat32 = function(t2) {
-          return h.int32[0] = this.readInt32(t2), h.float32[0];
-        }, h.ByteBuffer.prototype.readFloat64 = function(t2) {
-          return h.int32[h.isLittleEndian ? 0 : 1] = this.readInt32(t2), h.int32[h.isLittleEndian ? 1 : 0] = this.readInt32(t2 + 4), h.float64[0];
-        }, h.ByteBuffer.prototype.writeInt8 = function(t2, e2) {
-          this.bytes_[t2] = e2;
-        }, h.ByteBuffer.prototype.writeUint8 = function(t2, e2) {
-          this.bytes_[t2] = e2;
-        }, h.ByteBuffer.prototype.writeInt16 = function(t2, e2) {
-          this.bytes_[t2] = e2, this.bytes_[t2 + 1] = e2 >> 8;
-        }, h.ByteBuffer.prototype.writeUint16 = function(t2, e2) {
-          this.bytes_[t2] = e2, this.bytes_[t2 + 1] = e2 >> 8;
-        }, h.ByteBuffer.prototype.writeInt32 = function(t2, e2) {
-          this.bytes_[t2] = e2, this.bytes_[t2 + 1] = e2 >> 8, this.bytes_[t2 + 2] = e2 >> 16, this.bytes_[t2 + 3] = e2 >> 24;
-        }, h.ByteBuffer.prototype.writeUint32 = function(t2, e2) {
-          this.bytes_[t2] = e2, this.bytes_[t2 + 1] = e2 >> 8, this.bytes_[t2 + 2] = e2 >> 16, this.bytes_[t2 + 3] = e2 >> 24;
-        }, h.ByteBuffer.prototype.writeInt64 = function(t2, e2) {
-          this.writeInt32(t2, e2.low), this.writeInt32(t2 + 4, e2.high);
-        }, h.ByteBuffer.prototype.writeUint64 = function(t2, e2) {
-          this.writeUint32(t2, e2.low), this.writeUint32(t2 + 4, e2.high);
-        }, h.ByteBuffer.prototype.writeFloat32 = function(t2, e2) {
-          h.float32[0] = e2, this.writeInt32(t2, h.int32[0]);
-        }, h.ByteBuffer.prototype.writeFloat64 = function(t2, e2) {
-          h.float64[0] = e2, this.writeInt32(t2, h.int32[h.isLittleEndian ? 0 : 1]), this.writeInt32(t2 + 4, h.int32[h.isLittleEndian ? 1 : 0]);
-        }, h.ByteBuffer.prototype.getBufferIdentifier = function() {
-          if (this.bytes_.length < this.position_ + h.SIZEOF_INT + h.FILE_IDENTIFIER_LENGTH)
-            throw new Error("FlatBuffers: ByteBuffer is too short to contain an identifier.");
-          for (var t2 = "", e2 = 0; e2 < h.FILE_IDENTIFIER_LENGTH; e2++)
-            t2 += String.fromCharCode(this.readInt8(this.position_ + h.SIZEOF_INT + e2));
-          return t2;
-        }, h.ByteBuffer.prototype.__offset = function(t2, e2) {
-          var r2 = t2 - this.readInt32(t2);
-          return e2 < this.readInt16(r2) ? this.readInt16(r2 + e2) : 0;
-        }, h.ByteBuffer.prototype.__union = function(t2, e2) {
-          return t2.bb_pos = e2 + this.readInt32(e2), t2.bb = this, t2;
-        }, h.ByteBuffer.prototype.__string = function(t2, e2) {
-          t2 += this.readInt32(t2);
-          var r2 = this.readInt32(t2), i2 = "", n2 = 0;
-          if (t2 += h.SIZEOF_INT, e2 === h.Encoding.UTF8_BYTES)
-            return this.bytes_.subarray(t2, t2 + r2);
-          for (; n2 < r2; ) {
-            var s2, o2 = this.readUint8(t2 + n2++);
-            if (o2 < 192)
-              s2 = o2;
-            else {
-              var a2 = this.readUint8(t2 + n2++);
-              if (o2 < 224)
-                s2 = (31 & o2) << 6 | 63 & a2;
-              else {
-                var b2 = this.readUint8(t2 + n2++);
-                if (o2 < 240)
-                  s2 = (15 & o2) << 12 | (63 & a2) << 6 | 63 & b2;
-                else
-                  s2 = (7 & o2) << 18 | (63 & a2) << 12 | (63 & b2) << 6 | 63 & this.readUint8(t2 + n2++);
-              }
-            }
-            s2 < 65536 ? i2 += String.fromCharCode(s2) : (s2 -= 65536, i2 += String.fromCharCode(55296 + (s2 >> 10), 56320 + (1023 & s2)));
-          }
-          return i2;
-        }, h.ByteBuffer.prototype.__indirect = function(t2) {
-          return t2 + this.readInt32(t2);
-        }, h.ByteBuffer.prototype.__vector = function(t2) {
-          return t2 + this.readInt32(t2) + h.SIZEOF_INT;
-        }, h.ByteBuffer.prototype.__vector_len = function(t2) {
-          return this.readInt32(t2 + this.readInt32(t2));
-        }, h.ByteBuffer.prototype.__has_identifier = function(t2) {
-          if (t2.length != h.FILE_IDENTIFIER_LENGTH)
-            throw new Error("FlatBuffers: file identifier must be length " + h.FILE_IDENTIFIER_LENGTH);
-          for (var e2 = 0; e2 < h.FILE_IDENTIFIER_LENGTH; e2++)
-            if (t2.charCodeAt(e2) != this.readInt8(this.position_ + h.SIZEOF_INT + e2))
-              return false;
-          return true;
-        }, h.ByteBuffer.prototype.createLong = function(t2, e2) {
-          return h.Long.create(t2, e2);
-        }, function(t2) {
-          t2[t2.Unknown = 0] = "Unknown", t2[t2.Point = 1] = "Point", t2[t2.LineString = 2] = "LineString", t2[t2.Polygon = 3] = "Polygon", t2[t2.MultiPoint = 4] = "MultiPoint", t2[t2.MultiLineString = 5] = "MultiLineString", t2[t2.MultiPolygon = 6] = "MultiPolygon", t2[t2.GeometryCollection = 7] = "GeometryCollection", t2[t2.CircularString = 8] = "CircularString", t2[t2.CompoundCurve = 9] = "CompoundCurve", t2[t2.CurvePolygon = 10] = "CurvePolygon", t2[t2.MultiCurve = 11] = "MultiCurve", t2[t2.MultiSurface = 12] = "MultiSurface", t2[t2.Curve = 13] = "Curve", t2[t2.Surface = 14] = "Surface", t2[t2.PolyhedralSurface = 15] = "PolyhedralSurface", t2[t2.TIN = 16] = "TIN", t2[t2.Triangle = 17] = "Triangle";
-        }(o || (o = {})), function(t2) {
-          t2[t2.Byte = 0] = "Byte", t2[t2.UByte = 1] = "UByte", t2[t2.Bool = 2] = "Bool", t2[t2.Short = 3] = "Short", t2[t2.UShort = 4] = "UShort", t2[t2.Int = 5] = "Int", t2[t2.UInt = 6] = "UInt", t2[t2.Long = 7] = "Long", t2[t2.ULong = 8] = "ULong", t2[t2.Float = 9] = "Float", t2[t2.Double = 10] = "Double", t2[t2.String = 11] = "String", t2[t2.Json = 12] = "Json", t2[t2.DateTime = 13] = "DateTime", t2[t2.Binary = 14] = "Binary";
-        }(a || (a = {}));
-        class f {
-          constructor() {
-            this.bb = null, this.bb_pos = 0;
-          }
-          __init(t2, e2) {
-            return this.bb_pos = t2, this.bb = e2, this;
-          }
-          static getRoot(t2, e2) {
-            return (e2 || new f()).__init(t2.readInt32(t2.position()) + t2.position(), t2);
-          }
-          static getSizePrefixedRoot(t2, e2) {
-            return t2.setPosition(t2.position() + h.SIZE_PREFIX_LENGTH), (e2 || new f()).__init(t2.readInt32(t2.position()) + t2.position(), t2);
-          }
-          name(t2) {
-            var e2 = this.bb.__offset(this.bb_pos, 4);
-            return e2 ? this.bb.__string(this.bb_pos + e2, t2) : null;
-          }
-          type() {
-            var t2 = this.bb.__offset(this.bb_pos, 6);
-            return t2 ? this.bb.readUint8(this.bb_pos + t2) : a.Byte;
-          }
-          static start(t2) {
-            t2.startObject(2);
-          }
-          static addName(t2, e2) {
-            t2.addFieldOffset(0, e2, 0);
-          }
-          static addType(t2, e2) {
-            t2.addFieldInt8(1, e2, a.Byte);
-          }
-          static end(t2) {
-            var e2 = t2.endObject();
-            return t2.requiredField(e2, 4), e2;
-          }
-          static create(t2, e2, r2) {
-            return f.start(t2), f.addName(t2, e2), f.addType(t2, r2), f.end(t2);
-          }
-        }
-        class c {
-          constructor() {
-            this.bb = null, this.bb_pos = 0;
-          }
-          __init(t2, e2) {
-            return this.bb_pos = t2, this.bb = e2, this;
-          }
-          static getRoot(t2, e2) {
-            return (e2 || new c()).__init(t2.readInt32(t2.position()) + t2.position(), t2);
-          }
-          static getSizePrefixedRoot(t2, e2) {
-            return t2.setPosition(t2.position() + h.SIZE_PREFIX_LENGTH), (e2 || new c()).__init(t2.readInt32(t2.position()) + t2.position(), t2);
-          }
-          ends(t2) {
-            var e2 = this.bb.__offset(this.bb_pos, 4);
-            return e2 ? this.bb.readUint32(this.bb.__vector(this.bb_pos + e2) + 4 * t2) : 0;
-          }
-          endsLength() {
-            var t2 = this.bb.__offset(this.bb_pos, 4);
-            return t2 ? this.bb.__vector_len(this.bb_pos + t2) : 0;
-          }
-          endsArray() {
-            var t2 = this.bb.__offset(this.bb_pos, 4);
-            return t2 ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + t2), this.bb.__vector_len(this.bb_pos + t2)) : null;
-          }
-          xy(t2) {
-            var e2 = this.bb.__offset(this.bb_pos, 6);
-            return e2 ? this.bb.readFloat64(this.bb.__vector(this.bb_pos + e2) + 8 * t2) : 0;
-          }
-          xyLength() {
-            var t2 = this.bb.__offset(this.bb_pos, 6);
-            return t2 ? this.bb.__vector_len(this.bb_pos + t2) : 0;
-          }
-          xyArray() {
-            var t2 = this.bb.__offset(this.bb_pos, 6);
-            return t2 ? new Float64Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + t2), this.bb.__vector_len(this.bb_pos + t2)) : null;
-          }
-          z(t2) {
-            var e2 = this.bb.__offset(this.bb_pos, 8);
-            return e2 ? this.bb.readFloat64(this.bb.__vector(this.bb_pos + e2) + 8 * t2) : 0;
-          }
-          zLength() {
-            var t2 = this.bb.__offset(this.bb_pos, 8);
-            return t2 ? this.bb.__vector_len(this.bb_pos + t2) : 0;
-          }
-          zArray() {
-            var t2 = this.bb.__offset(this.bb_pos, 8);
-            return t2 ? new Float64Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + t2), this.bb.__vector_len(this.bb_pos + t2)) : null;
-          }
-          m(t2) {
-            var e2 = this.bb.__offset(this.bb_pos, 10);
-            return e2 ? this.bb.readFloat64(this.bb.__vector(this.bb_pos + e2) + 8 * t2) : 0;
-          }
-          mLength() {
-            var t2 = this.bb.__offset(this.bb_pos, 10);
-            return t2 ? this.bb.__vector_len(this.bb_pos + t2) : 0;
-          }
-          mArray() {
-            var t2 = this.bb.__offset(this.bb_pos, 10);
-            return t2 ? new Float64Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + t2), this.bb.__vector_len(this.bb_pos + t2)) : null;
-          }
-          t(t2) {
-            var e2 = this.bb.__offset(this.bb_pos, 12);
-            return e2 ? this.bb.readFloat64(this.bb.__vector(this.bb_pos + e2) + 8 * t2) : 0;
-          }
-          tLength() {
-            var t2 = this.bb.__offset(this.bb_pos, 12);
-            return t2 ? this.bb.__vector_len(this.bb_pos + t2) : 0;
-          }
-          tArray() {
-            var t2 = this.bb.__offset(this.bb_pos, 12);
-            return t2 ? new Float64Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + t2), this.bb.__vector_len(this.bb_pos + t2)) : null;
-          }
-          tm(t2) {
-            var e2 = this.bb.__offset(this.bb_pos, 14);
-            return e2 ? this.bb.readUint64(this.bb.__vector(this.bb_pos + e2) + 8 * t2) : this.bb.createLong(0, 0);
-          }
-          tmLength() {
-            var t2 = this.bb.__offset(this.bb_pos, 14);
-            return t2 ? this.bb.__vector_len(this.bb_pos + t2) : 0;
-          }
-          type() {
-            var t2 = this.bb.__offset(this.bb_pos, 16);
-            return t2 ? this.bb.readUint8(this.bb_pos + t2) : o.Unknown;
-          }
-          parts(t2, e2) {
-            var r2 = this.bb.__offset(this.bb_pos, 18);
-            return r2 ? (e2 || new c()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + r2) + 4 * t2), this.bb) : null;
-          }
-          partsLength() {
-            var t2 = this.bb.__offset(this.bb_pos, 18);
-            return t2 ? this.bb.__vector_len(this.bb_pos + t2) : 0;
-          }
-          static start(t2) {
-            t2.startObject(8);
-          }
-          static addEnds(t2, e2) {
-            t2.addFieldOffset(0, e2, 0);
-          }
-          static createEndsVector(t2, e2) {
-            t2.startVector(4, e2.length, 4);
-            for (var r2 = e2.length - 1; r2 >= 0; r2--)
-              t2.addInt32(e2[r2]);
-            return t2.endVector();
-          }
-          static startEndsVector(t2, e2) {
-            t2.startVector(4, e2, 4);
-          }
-          static addXy(t2, e2) {
-            t2.addFieldOffset(1, e2, 0);
-          }
-          static createXyVector(t2, e2) {
-            t2.startVector(8, e2.length, 8);
-            for (var r2 = e2.length - 1; r2 >= 0; r2--)
-              t2.addFloat64(e2[r2]);
-            return t2.endVector();
-          }
-          static startXyVector(t2, e2) {
-            t2.startVector(8, e2, 8);
-          }
-          static addZ(t2, e2) {
-            t2.addFieldOffset(2, e2, 0);
-          }
-          static createZVector(t2, e2) {
-            t2.startVector(8, e2.length, 8);
-            for (var r2 = e2.length - 1; r2 >= 0; r2--)
-              t2.addFloat64(e2[r2]);
-            return t2.endVector();
-          }
-          static startZVector(t2, e2) {
-            t2.startVector(8, e2, 8);
-          }
-          static addM(t2, e2) {
-            t2.addFieldOffset(3, e2, 0);
-          }
-          static createMVector(t2, e2) {
-            t2.startVector(8, e2.length, 8);
-            for (var r2 = e2.length - 1; r2 >= 0; r2--)
-              t2.addFloat64(e2[r2]);
-            return t2.endVector();
-          }
-          static startMVector(t2, e2) {
-            t2.startVector(8, e2, 8);
-          }
-          static addT(t2, e2) {
-            t2.addFieldOffset(4, e2, 0);
-          }
-          static createTVector(t2, e2) {
-            t2.startVector(8, e2.length, 8);
-            for (var r2 = e2.length - 1; r2 >= 0; r2--)
-              t2.addFloat64(e2[r2]);
-            return t2.endVector();
-          }
-          static startTVector(t2, e2) {
-            t2.startVector(8, e2, 8);
-          }
-          static addTm(t2, e2) {
-            t2.addFieldOffset(5, e2, 0);
-          }
-          static createTmVector(t2, e2) {
-            t2.startVector(8, e2.length, 8);
-            for (var r2 = e2.length - 1; r2 >= 0; r2--)
-              t2.addInt64(e2[r2]);
-            return t2.endVector();
-          }
-          static startTmVector(t2, e2) {
-            t2.startVector(8, e2, 8);
-          }
-          static addType(t2, e2) {
-            t2.addFieldInt8(6, e2, o.Unknown);
-          }
-          static addParts(t2, e2) {
-            t2.addFieldOffset(7, e2, 0);
-          }
-          static createPartsVector(t2, e2) {
-            t2.startVector(4, e2.length, 4);
-            for (var r2 = e2.length - 1; r2 >= 0; r2--)
-              t2.addOffset(e2[r2]);
-            return t2.endVector();
-          }
-          static startPartsVector(t2, e2) {
-            t2.startVector(4, e2, 4);
-          }
-          static end(t2) {
-            return t2.endObject();
-          }
-          static create(t2, e2, r2, i2, n2, s2, o2, a2, b2) {
-            return c.start(t2), c.addEnds(t2, e2), c.addXy(t2, r2), c.addZ(t2, i2), c.addM(t2, n2), c.addT(t2, s2), c.addTm(t2, o2), c.addType(t2, a2), c.addParts(t2, b2), c.end(t2);
-          }
-        }
-        class d {
-          constructor() {
-            this.bb = null, this.bb_pos = 0;
-          }
-          __init(t2, e2) {
-            return this.bb_pos = t2, this.bb = e2, this;
-          }
-          static getRoot(t2, e2) {
-            return (e2 || new d()).__init(t2.readInt32(t2.position()) + t2.position(), t2);
-          }
-          static getSizePrefixedRoot(t2, e2) {
-            return t2.setPosition(t2.position() + h.SIZE_PREFIX_LENGTH), (e2 || new d()).__init(t2.readInt32(t2.position()) + t2.position(), t2);
-          }
-          geometry(t2) {
-            var e2 = this.bb.__offset(this.bb_pos, 4);
-            return e2 ? (t2 || new c()).__init(this.bb.__indirect(this.bb_pos + e2), this.bb) : null;
-          }
-          properties(t2) {
-            var e2 = this.bb.__offset(this.bb_pos, 6);
-            return e2 ? this.bb.readUint8(this.bb.__vector(this.bb_pos + e2) + t2) : 0;
-          }
-          propertiesLength() {
-            var t2 = this.bb.__offset(this.bb_pos, 6);
-            return t2 ? this.bb.__vector_len(this.bb_pos + t2) : 0;
-          }
-          propertiesArray() {
-            var t2 = this.bb.__offset(this.bb_pos, 6);
-            return t2 ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + t2), this.bb.__vector_len(this.bb_pos + t2)) : null;
-          }
-          columns(t2, e2) {
-            var r2 = this.bb.__offset(this.bb_pos, 8);
-            return r2 ? (e2 || new f()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + r2) + 4 * t2), this.bb) : null;
-          }
-          columnsLength() {
-            var t2 = this.bb.__offset(this.bb_pos, 8);
-            return t2 ? this.bb.__vector_len(this.bb_pos + t2) : 0;
-          }
-          static start(t2) {
-            t2.startObject(3);
-          }
-          static addGeometry(t2, e2) {
-            t2.addFieldOffset(0, e2, 0);
-          }
-          static addProperties(t2, e2) {
-            t2.addFieldOffset(1, e2, 0);
-          }
-          static createPropertiesVector(t2, e2) {
-            t2.startVector(1, e2.length, 1);
-            for (var r2 = e2.length - 1; r2 >= 0; r2--)
-              t2.addInt8(e2[r2]);
-            return t2.endVector();
-          }
-          static startPropertiesVector(t2, e2) {
-            t2.startVector(1, e2, 1);
-          }
-          static addColumns(t2, e2) {
-            t2.addFieldOffset(2, e2, 0);
-          }
-          static createColumnsVector(t2, e2) {
-            t2.startVector(4, e2.length, 4);
-            for (var r2 = e2.length - 1; r2 >= 0; r2--)
-              t2.addOffset(e2[r2]);
-            return t2.endVector();
-          }
-          static startColumnsVector(t2, e2) {
-            t2.startVector(4, e2, 4);
-          }
-          static end(t2) {
-            return t2.endObject();
-          }
-          static finishBuffer(t2, e2) {
-            t2.finish(e2);
-          }
-          static finishSizePrefixedBuffer(t2, e2) {
-            t2.finish(e2, void 0, true);
-          }
-          static create(t2, e2, r2, i2) {
-            return d.start(t2), d.addGeometry(t2, e2), d.addProperties(t2, r2), d.addColumns(t2, i2), d.end(t2);
-          }
-        }
-        !function(t2) {
-          t2[t2.Unknown = 0] = "Unknown", t2[t2.Point = 1] = "Point", t2[t2.LineString = 2] = "LineString", t2[t2.Polygon = 3] = "Polygon", t2[t2.MultiPoint = 4] = "MultiPoint", t2[t2.MultiLineString = 5] = "MultiLineString", t2[t2.MultiPolygon = 6] = "MultiPolygon", t2[t2.GeometryCollection = 7] = "GeometryCollection", t2[t2.CircularString = 8] = "CircularString", t2[t2.CompoundCurve = 9] = "CompoundCurve", t2[t2.CurvePolygon = 10] = "CurvePolygon", t2[t2.MultiCurve = 11] = "MultiCurve", t2[t2.MultiSurface = 12] = "MultiSurface", t2[t2.Curve = 13] = "Curve", t2[t2.Surface = 14] = "Surface", t2[t2.PolyhedralSurface = 15] = "PolyhedralSurface", t2[t2.TIN = 16] = "TIN", t2[t2.Triangle = 17] = "Triangle";
-        }(b || (b = {})), function(t2) {
-          t2[t2.Byte = 0] = "Byte", t2[t2.UByte = 1] = "UByte", t2[t2.Bool = 2] = "Bool", t2[t2.Short = 3] = "Short", t2[t2.UShort = 4] = "UShort", t2[t2.Int = 5] = "Int", t2[t2.UInt = 6] = "UInt", t2[t2.Long = 7] = "Long", t2[t2.ULong = 8] = "ULong", t2[t2.Float = 9] = "Float", t2[t2.Double = 10] = "Double", t2[t2.String = 11] = "String", t2[t2.Json = 12] = "Json", t2[t2.DateTime = 13] = "DateTime", t2[t2.Binary = 14] = "Binary";
-        }(u || (u = {}));
-        class l {
-          constructor() {
-            this.bb = null, this.bb_pos = 0;
-          }
-          __init(t2, e2) {
-            return this.bb_pos = t2, this.bb = e2, this;
-          }
-          static getRoot(t2, e2) {
-            return (e2 || new l()).__init(t2.readInt32(t2.position()) + t2.position(), t2);
-          }
-          static getSizePrefixedRoot(t2, e2) {
-            return t2.setPosition(t2.position() + h.SIZE_PREFIX_LENGTH), (e2 || new l()).__init(t2.readInt32(t2.position()) + t2.position(), t2);
-          }
-          name(t2) {
-            var e2 = this.bb.__offset(this.bb_pos, 4);
-            return e2 ? this.bb.__string(this.bb_pos + e2, t2) : null;
-          }
-          type() {
-            var t2 = this.bb.__offset(this.bb_pos, 6);
-            return t2 ? this.bb.readUint8(this.bb_pos + t2) : u.Byte;
-          }
-          static start(t2) {
-            t2.startObject(2);
-          }
-          static addName(t2, e2) {
-            t2.addFieldOffset(0, e2, 0);
-          }
-          static addType(t2, e2) {
-            t2.addFieldInt8(1, e2, u.Byte);
-          }
-          static end(t2) {
-            var e2 = t2.endObject();
-            return t2.requiredField(e2, 4), e2;
-          }
-          static create(t2, e2, r2) {
-            return l.start(t2), l.addName(t2, e2), l.addType(t2, r2), l.end(t2);
-          }
-        }
-        class p {
-          constructor() {
-            this.bb = null, this.bb_pos = 0;
-          }
-          __init(t2, e2) {
-            return this.bb_pos = t2, this.bb = e2, this;
-          }
-          static getRoot(t2, e2) {
-            return (e2 || new p()).__init(t2.readInt32(t2.position()) + t2.position(), t2);
-          }
-          static getSizePrefixedRoot(t2, e2) {
-            return t2.setPosition(t2.position() + h.SIZE_PREFIX_LENGTH), (e2 || new p()).__init(t2.readInt32(t2.position()) + t2.position(), t2);
-          }
-          org(t2) {
-            var e2 = this.bb.__offset(this.bb_pos, 4);
-            return e2 ? this.bb.__string(this.bb_pos + e2, t2) : null;
-          }
-          code() {
-            var t2 = this.bb.__offset(this.bb_pos, 6);
-            return t2 ? this.bb.readInt32(this.bb_pos + t2) : 0;
-          }
-          name(t2) {
-            var e2 = this.bb.__offset(this.bb_pos, 8);
-            return e2 ? this.bb.__string(this.bb_pos + e2, t2) : null;
-          }
-          description(t2) {
-            var e2 = this.bb.__offset(this.bb_pos, 10);
-            return e2 ? this.bb.__string(this.bb_pos + e2, t2) : null;
-          }
-          wkt(t2) {
-            var e2 = this.bb.__offset(this.bb_pos, 12);
-            return e2 ? this.bb.__string(this.bb_pos + e2, t2) : null;
-          }
-          static start(t2) {
-            t2.startObject(5);
-          }
-          static addOrg(t2, e2) {
-            t2.addFieldOffset(0, e2, 0);
-          }
-          static addCode(t2, e2) {
-            t2.addFieldInt32(1, e2, 0);
-          }
-          static addName(t2, e2) {
-            t2.addFieldOffset(2, e2, 0);
-          }
-          static addDescription(t2, e2) {
-            t2.addFieldOffset(3, e2, 0);
-          }
-          static addWkt(t2, e2) {
-            t2.addFieldOffset(4, e2, 0);
-          }
-          static end(t2) {
-            return t2.endObject();
-          }
-          static create(t2, e2, r2, i2, n2, s2) {
-            return p.start(t2), p.addOrg(t2, e2), p.addCode(t2, r2), p.addName(t2, i2), p.addDescription(t2, n2), p.addWkt(t2, s2), p.end(t2);
-          }
-        }
-        class _ {
-          constructor() {
-            this.bb = null, this.bb_pos = 0;
-          }
-          __init(t2, e2) {
-            return this.bb_pos = t2, this.bb = e2, this;
-          }
-          static getRoot(t2, e2) {
-            return (e2 || new _()).__init(t2.readInt32(t2.position()) + t2.position(), t2);
-          }
-          static getSizePrefixedRoot(t2, e2) {
-            return t2.setPosition(t2.position() + h.SIZE_PREFIX_LENGTH), (e2 || new _()).__init(t2.readInt32(t2.position()) + t2.position(), t2);
-          }
-          name(t2) {
-            var e2 = this.bb.__offset(this.bb_pos, 4);
-            return e2 ? this.bb.__string(this.bb_pos + e2, t2) : null;
-          }
-          envelope(t2) {
-            var e2 = this.bb.__offset(this.bb_pos, 6);
-            return e2 ? this.bb.readFloat64(this.bb.__vector(this.bb_pos + e2) + 8 * t2) : 0;
-          }
-          envelopeLength() {
-            var t2 = this.bb.__offset(this.bb_pos, 6);
-            return t2 ? this.bb.__vector_len(this.bb_pos + t2) : 0;
-          }
-          envelopeArray() {
-            var t2 = this.bb.__offset(this.bb_pos, 6);
-            return t2 ? new Float64Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + t2), this.bb.__vector_len(this.bb_pos + t2)) : null;
-          }
-          geometryType() {
-            var t2 = this.bb.__offset(this.bb_pos, 8);
-            return t2 ? this.bb.readUint8(this.bb_pos + t2) : b.Unknown;
-          }
-          hasZ() {
-            var t2 = this.bb.__offset(this.bb_pos, 10);
-            return !!t2 && !!this.bb.readInt8(this.bb_pos + t2);
-          }
-          hasM() {
-            var t2 = this.bb.__offset(this.bb_pos, 12);
-            return !!t2 && !!this.bb.readInt8(this.bb_pos + t2);
-          }
-          hasT() {
-            var t2 = this.bb.__offset(this.bb_pos, 14);
-            return !!t2 && !!this.bb.readInt8(this.bb_pos + t2);
-          }
-          hasTM() {
-            var t2 = this.bb.__offset(this.bb_pos, 16);
-            return !!t2 && !!this.bb.readInt8(this.bb_pos + t2);
-          }
-          columns(t2, e2) {
-            var r2 = this.bb.__offset(this.bb_pos, 18);
-            return r2 ? (e2 || new l()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + r2) + 4 * t2), this.bb) : null;
-          }
-          columnsLength() {
-            var t2 = this.bb.__offset(this.bb_pos, 18);
-            return t2 ? this.bb.__vector_len(this.bb_pos + t2) : 0;
-          }
-          featuresCount() {
-            var t2 = this.bb.__offset(this.bb_pos, 20);
-            return t2 ? this.bb.readUint64(this.bb_pos + t2) : this.bb.createLong(0, 0);
-          }
-          indexNodeSize() {
-            var t2 = this.bb.__offset(this.bb_pos, 22);
-            return t2 ? this.bb.readUint16(this.bb_pos + t2) : 16;
-          }
-          crs(t2) {
-            var e2 = this.bb.__offset(this.bb_pos, 24);
-            return e2 ? (t2 || new p()).__init(this.bb.__indirect(this.bb_pos + e2), this.bb) : null;
-          }
-          static start(t2) {
-            t2.startObject(11);
-          }
-          static addName(t2, e2) {
-            t2.addFieldOffset(0, e2, 0);
-          }
-          static addEnvelope(t2, e2) {
-            t2.addFieldOffset(1, e2, 0);
-          }
-          static createEnvelopeVector(t2, e2) {
-            t2.startVector(8, e2.length, 8);
-            for (var r2 = e2.length - 1; r2 >= 0; r2--)
-              t2.addFloat64(e2[r2]);
-            return t2.endVector();
-          }
-          static startEnvelopeVector(t2, e2) {
-            t2.startVector(8, e2, 8);
-          }
-          static addGeometryType(t2, e2) {
-            t2.addFieldInt8(2, e2, b.Unknown);
-          }
-          static addHasZ(t2, e2) {
-            t2.addFieldInt8(3, +e2, 0);
-          }
-          static addHasM(t2, e2) {
-            t2.addFieldInt8(4, +e2, 0);
-          }
-          static addHasT(t2, e2) {
-            t2.addFieldInt8(5, +e2, 0);
-          }
-          static addHasTM(t2, e2) {
-            t2.addFieldInt8(6, +e2, 0);
-          }
-          static addColumns(t2, e2) {
-            t2.addFieldOffset(7, e2, 0);
-          }
-          static createColumnsVector(t2, e2) {
-            t2.startVector(4, e2.length, 4);
-            for (var r2 = e2.length - 1; r2 >= 0; r2--)
-              t2.addOffset(e2[r2]);
-            return t2.endVector();
-          }
-          static startColumnsVector(t2, e2) {
-            t2.startVector(4, e2, 4);
-          }
-          static addFeaturesCount(t2, e2) {
-            t2.addFieldInt64(8, e2, t2.createLong(0, 0));
-          }
-          static addIndexNodeSize(t2, e2) {
-            t2.addFieldInt16(9, e2, 16);
-          }
-          static addCrs(t2, e2) {
-            t2.addFieldOffset(10, e2, 0);
-          }
-          static end(t2) {
-            return t2.endObject();
-          }
-          static finishBuffer(t2, e2) {
-            t2.finish(e2);
-          }
-          static finishSizePrefixedBuffer(t2, e2) {
-            t2.finish(e2, void 0, true);
-          }
-          static create(t2, e2, r2, i2, n2, s2, o2, a2, b2, u2, h2, f2) {
-            return _.start(t2), _.addName(t2, e2), _.addEnvelope(t2, r2), _.addGeometryType(t2, i2), _.addHasZ(t2, n2), _.addHasM(t2, s2), _.addHasT(t2, o2), _.addHasTM(t2, a2), _.addColumns(t2, b2), _.addFeaturesCount(t2, u2), _.addIndexNodeSize(t2, h2), _.addCrs(t2, f2), _.end(t2);
-          }
-        }
-        function y(t2) {
-          return t2.reduce((t3, e2) => Array.isArray(e2) ? t3.concat(y(e2)) : t3.concat(e2), []);
-        }
-        function g(t2) {
-          const e2 = [];
-          for (let r2 = 0; r2 < t2.length; r2 += 2)
-            e2.push([t2[r2], t2[r2 + 1]]);
-          return e2;
-        }
-        function v(t2) {
-          return b[t2];
-        }
-        function I(t2) {
-          const e2 = t2.coordinates;
-          let r2 = null, i2 = null, n2 = null, s2 = v(t2.type), o2 = 0;
-          switch (t2.type) {
-            case "Point":
-              r2 = e2;
-              break;
-            case "MultiPoint":
-            case "LineString":
-              r2 = y(e2);
-              break;
-            case "MultiLineString":
-            case "Polygon":
-              const s3 = e2;
-              r2 = y(s3), s3.length > 1 && (i2 = s3.map((t3) => o2 += t3.length));
-              break;
-            case "MultiPolygon":
-              n2 = e2.map((t3) => ({ type: "Polygon", coordinates: t3 })).map(I);
-              break;
-            case "GeometryCollection":
-              n2 = t2.geometries.map(I);
-          }
-          return { xy: r2, ends: i2, type: s2, parts: n2 };
-        }
-        function w(t2, e2) {
-          if (!e2 || e2.length === 0)
-            return [g(t2)];
-          let r2 = 0;
-          return Array.from(e2).map((e3) => t2.slice(r2, r2 = e3 << 1)).map((t3) => g(t3));
-        }
-        function B(t2, e2) {
-          if (e2 == b.GeometryCollection) {
-            const r3 = [];
-            for (let e3 = 0; e3 < t2.partsLength(); e3++) {
-              const i2 = t2.parts(e3), n2 = i2.type();
-              r3.push(B(i2, n2));
-            }
-            return { type: b[e2], geometries: r3 };
-          }
-          if (e2 == b.MultiPolygon) {
-            const r3 = [];
-            for (let e3 = 0; e3 < t2.partsLength(); e3++) {
-              const i2 = t2.parts(e3);
-              r3.push(B(i2, b.Polygon));
-            }
-            return { type: b[e2], coordinates: r3.map((t3) => t3.coordinates) };
-          }
-          const r2 = function(t3, e3) {
-            const r3 = t3.xyArray();
-            switch (e3) {
-              case b.Point:
-                return Array.from(r3);
-              case b.MultiPoint:
-              case b.LineString:
-                return g(r3);
-              case b.MultiLineString:
-              case b.Polygon:
-                return w(r3, t3.endsArray());
-            }
-          }(t2, e2);
-          return { type: b[e2], coordinates: r2 };
-        }
-        function m(t2, e2) {
-          const r2 = e2.columns, i2 = new h.Builder(0), s2 = new Uint8Array(1e5);
-          let o2 = 0;
-          if (r2) {
-            const e3 = new DataView(s2.buffer);
-            for (let i3 = 0; i3 < r2.length; i3++) {
-              const a3 = r2[i3], b3 = t2.properties[a3.name];
-              if (b3 !== null)
-                switch (e3.setUint16(o2, i3, true), o2 += 2, a3.type) {
-                  case n.Bool:
-                    e3.setUint8(o2, b3), o2 += 1;
-                    break;
-                  case n.Short:
-                    e3.setInt16(o2, b3, true), o2 += 2;
-                    break;
-                  case n.UShort:
-                    e3.setUint16(o2, b3, true), o2 += 2;
-                    break;
-                  case n.Int:
-                    e3.setInt32(o2, b3, true), o2 += 4;
-                    break;
-                  case n.UInt:
-                    e3.setUint32(o2, b3, true), o2 += 4;
-                    break;
-                  case n.Long:
-                    e3.setBigInt64(o2, BigInt(b3), true), o2 += 8;
-                    break;
-                  case n.Long:
-                    e3.setBigUint64(o2, BigInt(b3), true), o2 += 8;
-                    break;
-                  case n.Double:
-                    e3.setFloat64(o2, b3, true), o2 += 8;
-                    break;
-                  case n.String:
-                    const t3 = b3, r3 = new TextEncoder().encode(t3);
-                    e3.setUint32(o2, r3.length, true), o2 += 4, s2.set(r3, o2), o2 += r3.length;
-                    break;
-                  default:
-                    throw new Error("Unknown type");
-                }
-            }
-          }
-          let a2 = null;
-          o2 > 0 && (a2 = d.createPropertiesVector(i2, s2.slice(0, o2)));
-          const b2 = function t3(e3, r3) {
-            const { xy: i3, ends: n2, parts: s3, type: o3 } = r3;
-            if (s3) {
-              const r4 = s3.map((r5) => t3(e3, r5)), i4 = c.createPartsVector(e3, r4);
-              return c.start(e3), c.addParts(e3, i4), c.end(e3);
-            }
-            const a3 = c.createXyVector(e3, i3);
-            let b3 = null;
-            return n2 && (b3 = c.createEndsVector(e3, n2)), c.start(e3), b3 && c.addEnds(e3, b3), c.addXy(e3, a3), c.addType(e3, o3), c.end(e3);
-          }(i2, I(t2.geometry));
-          d.start(i2), d.addGeometry(i2, b2), a2 && d.addProperties(i2, a2);
-          const u2 = d.end(i2);
-          return i2.finishSizePrefixed(u2), i2.asUint8Array();
-        }
-        function F(t2, e2) {
-          const r2 = e2.columns;
-          let i2;
-          i2 = B(t2.geometry(), e2.geometryType);
-          const s2 = function(t3, e3) {
-            if (!e3 || e3.length === 0)
-              return;
-            const r3 = t3.propertiesArray(), i3 = new DataView(r3.buffer, r3.byteOffset), s3 = t3.propertiesLength();
-            let o3 = 0;
-            const a2 = {};
-            for (; o3 < s3; ) {
-              const t4 = i3.getUint16(o3, true);
-              o3 += 2;
-              const s4 = e3[t4];
-              switch (s4.type) {
-                case n.Bool:
-                  a2[s4.name] = !!i3.getUint8(o3), o3 += 1;
-                  break;
-                case n.Byte:
-                  a2[s4.name] = i3.getInt8(o3), o3 += 1;
-                  break;
-                case n.UByte:
-                  a2[s4.name] = i3.getUint8(o3), o3 += 1;
-                  break;
-                case n.Short:
-                  a2[s4.name] = i3.getInt16(o3, true), o3 += 2;
-                  break;
-                case n.UShort:
-                  a2[s4.name] = i3.getUint16(o3, true), o3 += 2;
-                  break;
-                case n.Int:
-                  a2[s4.name] = i3.getInt32(o3, true), o3 += 4;
-                  break;
-                case n.UInt:
-                  a2[s4.name] = i3.getUint32(o3, true), o3 += 4;
-                  break;
-                case n.Long:
-                  a2[s4.name] = Number(i3.getBigInt64(o3, true)), o3 += 8;
-                  break;
-                case n.ULong:
-                  a2[s4.name] = Number(i3.getBigUint64(o3, true)), o3 += 8;
-                  break;
-                case n.Double:
-                  a2[s4.name] = i3.getFloat64(o3, true), o3 += 8;
-                  break;
-                case n.DateTime:
-                case n.String: {
-                  const t5 = i3.getUint32(o3, true);
-                  o3 += 4;
-                  const e4 = new TextDecoder();
-                  a2[s4.name] = e4.decode(r3.subarray(o3, o3 + t5)), o3 += t5;
-                  break;
-                }
-                default:
-                  throw new Error("Unknown type " + s4.type);
-              }
-            }
-            return a2;
-          }(t2, r2), o2 = { type: "Feature", geometry: i2 };
-          return s2 && (o2.properties = s2), o2;
-        }
-        function E(t2) {
-          var e2;
-          if (typeof Symbol != "undefined") {
-            if (Symbol.asyncIterator && (e2 = t2[Symbol.asyncIterator]) != null)
-              return e2.call(t2);
-            if (Symbol.iterator && (e2 = t2[Symbol.iterator]) != null)
-              return e2.call(t2);
-          }
-          throw new TypeError("Object is not async iterable");
-        }
-        function S(t2) {
-          this.wrapped = t2;
-        }
-        function U(t2) {
-          var e2, r2;
-          function i2(e3, r3) {
-            try {
-              var s2 = t2[e3](r3), o2 = s2.value, a2 = o2 instanceof S;
-              Promise.resolve(a2 ? o2.wrapped : o2).then(function(t3) {
-                a2 ? i2(e3 === "return" ? "return" : "next", t3) : n2(s2.done ? "return" : "normal", t3);
-              }, function(t3) {
-                i2("throw", t3);
-              });
-            } catch (t3) {
-              n2("throw", t3);
-            }
-          }
-          function n2(t3, n3) {
-            switch (t3) {
-              case "return":
-                e2.resolve({ value: n3, done: true });
-                break;
-              case "throw":
-                e2.reject(n3);
-                break;
-              default:
-                e2.resolve({ value: n3, done: false });
-            }
-            (e2 = e2.next) ? i2(e2.key, e2.arg) : r2 = null;
-          }
-          this._invoke = function(t3, n3) {
-            return new Promise(function(s2, o2) {
-              var a2 = { key: t3, arg: n3, resolve: s2, reject: o2, next: null };
-              r2 ? r2 = r2.next = a2 : (e2 = r2 = a2, i2(t3, n3));
-            });
-          }, typeof t2.return != "function" && (this.return = void 0);
-        }
-        function T(t2) {
-          return function() {
-            return new U(t2.apply(this, arguments));
-          };
-        }
-        function L(t2) {
-          return new S(t2);
-        }
-        typeof Symbol == "function" && Symbol.asyncIterator && (U.prototype[Symbol.asyncIterator] = function() {
-          return this;
-        }), U.prototype.next = function(t2) {
-          return this._invoke("next", t2);
-        }, U.prototype.throw = function(t2) {
-          return this._invoke("throw", t2);
-        }, U.prototype.return = function(t2) {
-          return this._invoke("return", t2);
-        };
-        var P = new Uint8Array(0);
-        function O(t2, e2) {
-          if (!t2.length)
-            return e2;
-          if (!e2.length)
-            return t2;
-          var r2 = new Uint8Array(t2.length + e2.length);
-          return r2.set(t2), r2.set(e2, t2.length), r2;
-        }
-        function N(t2) {
-          this._source = t2, this._array = P, this._index = 0;
-        }
-        N.prototype.read = function() {
-          var t2 = this, e2 = t2._array.subarray(t2._index);
-          return t2._source.read().then(function(r2) {
-            return t2._array = P, t2._index = 0, r2.done ? e2.length > 0 ? { done: false, value: e2 } : { done: true, value: void 0 } : { done: false, value: O(e2, r2.value) };
-          });
-        }, N.prototype.slice = function(t2) {
-          if ((t2 |= 0) < 0)
-            throw new Error("invalid length");
-          var e2 = this, r2 = this._array.length - this._index;
-          if (this._index + t2 <= this._array.length)
-            return Promise.resolve(this._array.subarray(this._index, this._index += t2));
-          var i2 = new Uint8Array(t2);
-          return i2.set(this._array.subarray(this._index)), function n2() {
-            return e2._source.read().then(function(s2) {
-              return s2.done ? (e2._array = P, e2._index = 0, r2 > 0 ? i2.subarray(0, r2) : null) : r2 + s2.value.length >= t2 ? (e2._array = s2.value, e2._index = t2 - r2, i2.set(s2.value.subarray(0, t2 - r2), r2), i2) : (i2.set(s2.value, r2), r2 += s2.value.length, n2());
-            });
-          }();
-        }, N.prototype.cancel = function() {
-          return this._source.cancel();
-        };
-        function V(t2, e2) {
-          e2 = Math.min(Math.max(+e2, 2), 65535);
-          let r2 = t2, i2 = r2;
-          do {
-            r2 = Math.ceil(r2 / e2), i2 += r2;
-          } while (r2 !== 1);
-          return 40 * i2;
-        }
-        function C(t2, e2) {
-          if (e2 < 2)
-            throw new Error("Node size must be at least 2");
-          if (t2 === 0)
-            throw new Error("Number of items must be greater than 0");
-          let r2 = t2, i2 = r2;
-          const n2 = [r2];
-          do {
-            r2 = Math.ceil(r2 / e2), i2 += r2, n2.push(r2);
-          } while (r2 !== 1);
-          const s2 = [];
-          r2 = i2;
-          for (let t3 of n2)
-            s2.push(r2 - t3), r2 -= t3;
-          s2.reverse(), n2.reverse();
-          const o2 = [];
-          for (let t3 = 0; t3 < n2.length; t3++)
-            o2.push([s2[t3], s2[t3] + n2[t3]]);
-          return o2.reverse(), o2;
-        }
-        function A(t2, e2, r2, i2) {
-          return x.apply(this, arguments);
-        }
-        function x() {
-          return (x = T(function* (t2, e2, r2, i2) {
-            const { minX: n2, minY: s2, maxX: o2, maxY: a2 } = r2, b2 = C(t2, e2), [[u2, h2]] = b2, f2 = [];
-            for (f2.push([0, b2.length - 1]); f2.length !== 0; ) {
-              const [r3, c2] = f2.pop(), d2 = r3 >= h2 - t2, [, l2] = b2[c2], p2 = Math.min(r3 + e2, l2), _2 = p2 - r3, y2 = yield L(i2(40 * r3, 40 * _2)), g2 = new Float64Array(y2), v2 = new Uint32Array(y2);
-              for (let t3 = r3; t3 < p2; t3++) {
-                const e3 = 5 * (t3 - r3);
-                if (o2 < g2[e3 + 0])
-                  continue;
-                if (a2 < g2[e3 + 1])
-                  continue;
-                if (n2 > g2[e3 + 2])
-                  continue;
-                if (s2 > g2[e3 + 3])
-                  continue;
-                const i3 = v2[8 + (e3 << 1)];
-                d2 ? yield [i3, t3 - u2] : f2.push([i3, c2 - 1]);
-              }
-              f2.sort((t3, e3) => e3[0] - t3[0]);
-            }
-          })).apply(this, arguments);
-        }
-        const k = new Uint8Array([102, 103, 98, 3, 102, 103, 98, 0]);
-        function R(t2, e2) {
-          const r2 = typeof (i2 = t2).slice == "function" ? i2 : new N(typeof i2.read == "function" ? i2 : i2.getReader());
-          var i2;
-          return M(async (t3) => await r2.slice(t3), void 0, void 0, e2);
-        }
-        function M(t2, e2, r2, i2) {
-          return G.apply(this, arguments);
-        }
-        function G() {
-          return (G = T(function* (t2, e2, i2, n2) {
-            let o2 = 0, a2 = new Uint8Array(yield L(t2(8)));
-            if (o2 += 8, !a2.every((t3, e3) => k[e3] === t3))
-              throw new Error("Not a FlatGeobuf file");
-            a2 = new Uint8Array(yield L(t2(4))), o2 += 4;
-            let b2 = new h.ByteBuffer(a2);
-            const u2 = b2.readUint32(0);
-            a2 = new Uint8Array(yield L(t2(u2))), o2 += u2, b2 = new h.ByteBuffer(a2);
-            const f2 = _.getRoot(b2), c2 = f2.featuresCount().toFloat64(), d2 = [];
-            for (let t3 = 0; t3 < f2.columnsLength(); t3++) {
-              const e3 = f2.columns(t3);
-              d2.push(new r(e3.name(), e3.type()));
-            }
-            const l2 = new s(f2.geometryType(), d2, c2), p2 = f2.indexNodeSize();
-            if (p2 > 0) {
-              const r2 = V(c2, p2);
-              if (i2) {
-                const s2 = async (r3, i3) => (await e2(o2 + r3), await t2(i3)), a3 = [];
-                var y2, g2 = true, v2 = false;
-                try {
-                  for (var I2, w2, B2 = E(A(c2, p2, i2, s2)); g2 = (I2 = yield L(B2.next())).done, w2 = yield L(I2.value), !g2; g2 = true) {
-                    let [t3] = w2;
-                    a3.push(t3);
-                  }
-                } catch (t3) {
-                  v2 = true, y2 = t3;
-                } finally {
-                  try {
-                    g2 || B2.return == null || (yield L(B2.return()));
-                  } finally {
-                    if (v2)
-                      throw y2;
-                  }
-                }
-                o2 += r2;
-                var m2, F2 = true, S2 = false;
-                try {
-                  for (var U2, T2, P2 = E(a3); F2 = (U2 = yield L(P2.next())).done, T2 = yield L(U2.value), !F2; F2 = true) {
-                    let r3 = T2;
-                    yield L(e2(o2 + r3)), yield D(t2, l2, n2);
-                  }
-                } catch (t3) {
-                  S2 = true, m2 = t3;
-                } finally {
-                  try {
-                    F2 || P2.return == null || (yield L(P2.return()));
-                  } finally {
-                    if (S2)
-                      throw m2;
-                  }
-                }
-                return;
-              }
-              e2 ? yield L(e2(o2 + r2)) : yield L(t2(r2)), o2 += r2;
-            }
-            let O2;
-            for (; O2 = yield L(D(t2, l2, n2)); )
-              yield O2;
-          })).apply(this, arguments);
-        }
-        async function D(t2, e2, r2) {
-          let i2 = new Uint8Array(await t2(4));
-          if (i2.byteLength === 0)
-            return null;
-          let n2 = new h.ByteBuffer(i2);
-          const s2 = n2.readUint32(0);
-          i2 = new Uint8Array(await t2(s2));
-          const o2 = new Uint8Array(s2 + 4);
-          return o2.set(i2, 4), n2 = new h.ByteBuffer(o2), n2.setPosition(4), r2(d.getRoot(n2), e2);
-        }
-        function Z(t2) {
-          const e2 = new h.Builder(0);
-          let r2 = null;
-          t2.columns && (r2 = _.createColumnsVector(e2, t2.columns.map((t3) => function(t4, e3) {
-            const r3 = t4.createString(e3.name);
-            return l.start(t4), l.addName(t4, r3), l.addType(t4, e3.type), l.end(t4);
-          }(e2, t3))));
-          const i2 = e2.createString("L1");
-          _.start(e2), _.addFeaturesCount(e2, new h.Long(t2.featuresCount, 0)), _.addGeometryType(e2, t2.geometryType), _.addIndexNodeSize(e2, 0), r2 && _.addColumns(e2, r2), _.addName(e2, i2);
-          const n2 = _.end(e2);
-          return e2.finishSizePrefixed(n2), e2.asUint8Array();
-        }
-        function H(t2) {
-          const e2 = function(t3) {
-            const e3 = t3.features[0], i3 = e3.properties;
-            let o3 = null;
-            i3 && (o3 = Object.keys(i3).map((t4) => new r(t4, function(t5) {
-              if (typeof t5 == "boolean")
-                return n.Bool;
-              if (typeof t5 == "number")
-                return t5 % 1 == 0 ? n.Int : n.Double;
-              if (typeof t5 == "string")
-                return n.String;
-              if (t5 === null)
-                return n.String;
-              throw new Error(`Unknown type (value '${t5}')`);
-            }(i3[t4]))));
-            const a3 = new Set();
-            for (const r2 of t3.features)
-              a3.add(e3.geometry.type);
-            return new s(v(e3.geometry.type), o3, t3.features.length);
-          }(t2), i2 = Z(e2), o2 = t2.features.map((t3) => m(t3, e2)), a2 = o2.map((t3) => t3.length).reduce((t3, e3) => t3 + e3), b2 = new Uint8Array(k.length + i2.length + a2);
-          b2.set(i2, k.length);
-          let u2 = k.length + i2.length;
-          for (const t3 of o2)
-            b2.set(t3, u2), u2 += t3.length;
-          return b2.set(k), b2;
-        }
-        function j(t2) {
-          return { type: "FeatureCollection", features: function(t3, e2) {
-            if (!t3.subarray(0, 7).every((t4, e3) => k[e3] === t4))
-              throw new Error("Not a FlatGeobuf file");
-            const i2 = new h.ByteBuffer(t3), n2 = i2.readUint32(k.length);
-            i2.setPosition(k.length + 4);
-            const o2 = _.getRoot(i2), a2 = o2.featuresCount().toFloat64(), b2 = [];
-            for (let t4 = 0; t4 < o2.columnsLength(); t4++) {
-              const e3 = o2.columns(t4);
-              b2.push(new r(e3.name(), e3.type()));
-            }
-            const u2 = new s(o2.geometryType(), b2, 0);
-            let f2 = k.length + 4 + n2;
-            const c2 = o2.indexNodeSize();
-            c2 > 0 && (f2 += V(a2, c2));
-            const l2 = [];
-            for (; f2 < i2.capacity(); ) {
-              const t4 = i2.readUint32(f2);
-              i2.setPosition(f2 + 4);
-              const r2 = d.getRoot(i2);
-              l2.push(e2(r2, u2)), f2 += 4 + t4;
-            }
-            return l2;
-          }(t2, (t3, e2) => F(t3, e2)) };
-        }
-        function z(t2, e2) {
-          return function(t3, e3, r2) {
-            let i2 = 0;
-            return M(async (e4) => {
-              const r3 = await fetch(t3, { headers: { Range: `bytes=${i2}-${i2 + e4 - 1}` } });
-              return i2 += e4, await r3.arrayBuffer();
-            }, async (t4) => {
-              i2 = t4;
-            }, e3, r2);
-          }(t2, e2, (t3, e3) => F(t3, e3));
-        }
-        t.deserialize = function(t2, r2) {
-          return t2 instanceof Uint8Array ? j(t2) : t2 instanceof e.ReadableStream ? R(t2, (t3, e2) => F(t3, e2)) : z(t2, r2);
-        }, t.serialize = function(t2) {
-          return H(t2);
-        }, Object.defineProperty(t, "__esModule", { value: true });
-      });
-    }
-  });
-
-  // src/lib/parse-flatgeobuf.ts
-  function parseFlatGeobuf(input, options) {
-    if (input.byteLength === 0) {
-      return [];
-    }
-    const arr = new Uint8Array(input);
-    const { features } = (0, import_flatgeobuf_geojson.deserialize)(arr);
-    return features;
-  }
-  function parseFlatGeobufInBatches(stream, options) {
-    const iterator = (0, import_flatgeobuf_geojson.deserializeStream)(stream);
-    return iterator;
-  }
-  var import_flatgeobuf_geojson;
-  var init_parse_flatgeobuf = __esm({
-    "src/lib/parse-flatgeobuf.ts"() {
-      import_flatgeobuf_geojson = __toModule(require_flatgeobuf_geojson_min());
-    }
-  });
-
-  // src/index.ts
-  var src_exports = {};
-  __export(src_exports, {
-    FlatGeobufLoader: () => FlatGeobufLoader2,
-    FlatGeobufWorkerLoader: () => FlatGeobufLoader,
-    _typecheckFlatGeobufLoader: () => _typecheckFlatGeobufLoader
-  });
-  var FlatGeobufLoader2, _typecheckFlatGeobufLoader;
-  var init_src = __esm({
-    "src/index.ts"() {
-      init_flatgeobuf_loader();
-      init_parse_flatgeobuf();
-      FlatGeobufLoader2 = {
-        ...FlatGeobufLoader,
-        parse: async (arrayBuffer, options) => parseFlatGeobuf(arrayBuffer, options),
-        parseSync: parseFlatGeobuf,
-        parseInBatchesFromStream: parseFlatGeobufInBatches,
-        binary: true
-      };
-      _typecheckFlatGeobufLoader = FlatGeobufLoader2;
-    }
-  });
-
-  // src/bundle.ts
-  var require_bundle = __commonJS({
-    "src/bundle.ts"(exports, module) {
-      var moduleExports = (init_src(), src_exports);
-      globalThis.loaders = globalThis.loaders || {};
-      module.exports = Object.assign(globalThis.loaders, moduleExports);
-    }
-  });
-  require_bundle();
-})();
+"use strict";
+// @ts-nocheck
+const moduleExports = require('./index');
+globalThis.loaders = globalThis.loaders || {};
+module.exports = Object.assign(globalThis.loaders, moduleExports);