@loaders.gl/wms 3.3.0-alpha.10 → 3.3.0-alpha.11

package/dist/dist.min.js

@@ -1577,7 +1577,7 @@
     const parser = new import_fast_xml_parser.XMLParser({
       ignoreAttributes: false,
       attributeNamePrefix: "",
-      ...options
+      ...options?.xml
     });
     const parsedXML = parser.parse(text);
     return parsedXML;
@@ -1623,7 +1623,7 @@
     }
   });
 
-  // src/lib/parse-wms.ts
+  // src/lib/wms/parse-wms.ts
   function parseWMSCapabilities(text, options) {
     const parsedXML = XMLLoader.parseTextSync(text, options);
     const xmlCapabilities = parsedXML.WMT_MS_Capabilities || parsedXML.WMS_Capabilities || parsedXML;
@@ -1658,11 +1658,21 @@
       srs: xmlLayer?.SRS || [],
       layers: []
     };
-    for (const xmlSubLayer of xmlLayer?.Layer || []) {
+    const xmlLayers = getXMLArray(xmlLayer?.Layer);
+    for (const xmlSubLayer of xmlLayers) {
       layer.layers?.push(extractLayer(xmlSubLayer));
     }
     return layer;
   }
+  function getXMLArray(xmlValue) {
+    if (Array.isArray(xmlValue)) {
+      return xmlValue;
+    }
+    if (xmlValue) {
+      return [xmlValue];
+    }
+    return [];
+  }
   function parseWMSFeatureInfo(text, options) {
     const parsedXML = XMLLoader.parseTextSync(text, options);
     const xmlFeatureInfo = parsedXML.FeatureInfoResponse?.FIELDS || [];
@@ -1673,32 +1683,72 @@
   }
   function extractFeature(xmlFeature) {
     const xmlFields = xmlFeature || {};
-    return { attributes: xmlFields };
+    return {
+      attributes: xmlFields,
+      type: "",
+      bounds: { bottom: 0, top: 0, left: 0, right: 0 }
+    };
+  }
+  function parseWMSLayerDescription(text, options) {
+    const parsedXML = XMLLoader.parseTextSync(text, options);
+    return parsedXML;
+  }
+  function parseWMSError(text, options) {
+    const parsedXML = XMLLoader.parseTextSync(text, options);
+    const error = parsedXML?.ServiceExceptionReport?.ServiceException || "Unknown error";
+    return String(error);
   }
   var init_parse_wms = __esm({
-    "src/lib/parse-wms.ts"() {
+    "src/lib/wms/parse-wms.ts"() {
       init_src();
     }
   });
 
-  // src/wms-capabilities-loader.ts
+  // src/wms-error-loader.ts
   function testXMLFile2(text) {
     return text.startsWith("<?xml");
   }
-  var VERSION2, WMSCapabilitiesLoader;
+  var VERSION2, WMSErrorLoader;
+  var init_wms_error_loader = __esm({
+    "src/wms-error-loader.ts"() {
+      init_parse_wms();
+      VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      WMSErrorLoader = {
+        name: "WMS Error",
+        id: "wms-capabilities",
+        module: "wms",
+        version: VERSION2,
+        worker: false,
+        extensions: ["xml"],
+        mimeTypes: ["application/vnd.ogc.se_xml", "application/xml", "text/xml"],
+        testText: testXMLFile2,
+        options: {
+          wms: {}
+        },
+        parse: async (arrayBuffer, options) => parseWMSError(new TextDecoder().decode(arrayBuffer), options),
+        parseTextSync: (text, options) => parseWMSError(text, options)
+      };
+    }
+  });
+
+  // src/wms-capabilities-loader.ts
+  function testXMLFile3(text) {
+    return text.startsWith("<?xml");
+  }
+  var VERSION3, WMSCapabilitiesLoader;
   var init_wms_capabilities_loader = __esm({
     "src/wms-capabilities-loader.ts"() {
       init_parse_wms();
-      VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
       WMSCapabilitiesLoader = {
         name: "WMS Capabilities",
         id: "wms-capabilities",
         module: "wms",
-        version: VERSION2,
+        version: VERSION3,
         worker: false,
         extensions: ["xml"],
         mimeTypes: ["application/vnd.ogc.wms_xml", "application/xml", "text/xml"],
-        testText: testXMLFile2,
+        testText: testXMLFile3,
         options: {
           wms: {}
         },
@@ -1734,17 +1784,17 @@
         ...WMSCapabilitiesLoader,
         name: "WMS DescribeLayer",
         id: "wms-layer-description",
-        parse: async (arrayBuffer, options) => parseWMSFeatureInfo(new TextDecoder().decode(arrayBuffer), options),
-        parseTextSync: (text, options) => parseWMSFeatureInfo(text, options)
+        parse: async (arrayBuffer, options) => parseWMSLayerDescription(new TextDecoder().decode(arrayBuffer), options),
+        parseTextSync: (text, options) => parseWMSLayerDescription(text, options)
       };
     }
   });
 
   // ../images/src/lib/utils/version.ts
-  var VERSION3;
+  var VERSION4;
   var init_version = __esm({
     "../images/src/lib/utils/version.ts"() {
-      VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
     }
   });
 
@@ -2178,7 +2228,7 @@
         id: "image",
         module: "images",
         name: "Images",
-        version: VERSION3,
+        version: VERSION4,
         mimeTypes: MIME_TYPES,
         extensions: EXTENSIONS,
         parse: parseImage,
@@ -2195,55 +2245,3444 @@
     }
   });
 
-  // src/lib/data-sources/wms-data-source.ts
-  var WMSDataSource;
-  var init_wms_data_source = __esm({
-    "src/lib/data-sources/wms-data-source.ts"() {
+  // src/lib/data-sources/wms-service.ts
+  var WMS_GET_CAPABILITIES_DEFAULT_PARAMETERS, WMS_GET_MAP_DEFAULT_PARAMETERS, WMS_GET_FEATURE_INFO_DEFAULT_PARAMETERS, WMS_DESCRIBE_LAYER_DEFAULT_PARAMETERS, WMS_GET_LEGEND_GRAPHIC_DEFAULT_PARAMETERS, WMSService;
+  var init_wms_service = __esm({
+    "src/lib/data-sources/wms-service.ts"() {
       init_src4();
       init_src3();
-      WMSDataSource = class {
+      WMS_GET_CAPABILITIES_DEFAULT_PARAMETERS = {
+        service: "WMS",
+        version: "1.1.1",
+        request: "GetCapabilities"
+      };
+      WMS_GET_MAP_DEFAULT_PARAMETERS = {
+        service: "WMS",
+        version: "1.1.1",
+        request: "GetMap",
+        layers: [],
+        styles: void 0,
+        bbox: [-77.87304, 40.78975, -77.85828, 40.80228],
+        width: 1200,
+        height: 900,
+        srs: "EPSG:4326",
+        format: "image/png"
+      };
+      WMS_GET_FEATURE_INFO_DEFAULT_PARAMETERS = {
+        service: "WMS",
+        version: "1.1.1",
+        request: "GetFeatureInfo",
+        layers: [],
+        styles: void 0,
+        bbox: [-77.87304, 40.78975, -77.85828, 40.80228],
+        width: 1200,
+        height: 900,
+        srs: "EPSG:4326",
+        format: "image/png",
+        x: void 0,
+        y: void 0,
+        query_layers: [],
+        info_format: "text/plain"
+      };
+      WMS_DESCRIBE_LAYER_DEFAULT_PARAMETERS = {
+        service: "WMS",
+        version: "1.1.1",
+        request: "DescribeLayer"
+      };
+      WMS_GET_LEGEND_GRAPHIC_DEFAULT_PARAMETERS = {
+        service: "WMS",
+        version: "1.1.1",
+        request: "GetLegendGraphic"
+      };
+      WMSService = class {
         constructor(props) {
           this.url = props.url;
           this.loadOptions = props.loadOptions || {};
           this.fetch = props.fetch || fetch;
         }
-        async getCapabilities(options) {
-          const url = this.getUrl({ request: "GetCapabilities", ...options });
+        getCapabilitiesURL(parameters, extra) {
+          const options = {
+            ...WMS_GET_CAPABILITIES_DEFAULT_PARAMETERS,
+            ...parameters,
+            ...extra
+          };
+          return this.getWMSUrl(options, extra);
+        }
+        getMapURL(parameters, extra) {
+          const options = {
+            ...WMS_GET_MAP_DEFAULT_PARAMETERS,
+            ...parameters,
+            ...extra
+          };
+          return this.getWMSUrl(options, extra);
+        }
+        getFeatureInfoURL(parameters, extra) {
+          const options = {
+            ...WMS_GET_FEATURE_INFO_DEFAULT_PARAMETERS,
+            ...parameters,
+            ...extra
+          };
+          return this.getWMSUrl(options, extra);
+        }
+        describeLayerURL(parameters, extra) {
+          const options = {
+            ...WMS_DESCRIBE_LAYER_DEFAULT_PARAMETERS,
+            ...parameters,
+            ...extra
+          };
+          return this.getWMSUrl(options, extra);
+        }
+        getLegendGraphicURL(parameters, extra) {
+          const options = {
+            ...WMS_GET_LEGEND_GRAPHIC_DEFAULT_PARAMETERS,
+            ...parameters,
+            ...extra
+          };
+          return this.getWMSUrl(options, extra);
+        }
+        async getCapabilities(parameters, extra) {
+          const url = this.getCapabilitiesURL(parameters, extra);
           const response = await this.fetch(url, this.loadOptions);
+          await this.checkResponse(response);
           const arrayBuffer = await response.arrayBuffer();
           return await WMSCapabilitiesLoader.parse(arrayBuffer, this.loadOptions);
         }
-        async getImage(options) {
-          const url = this.getUrl({ request: "GetMap", ...options });
+        async getMap(options, extra) {
+          const url = this.getMapURL(options, extra);
           const response = await this.fetch(url, this.loadOptions);
+          await this.checkResponse(response);
           const arrayBuffer = await response.arrayBuffer();
           return await ImageLoader.parse(arrayBuffer, this.loadOptions);
         }
-        async getFeatureInfo(options) {
-          const url = this.getUrl({ request: "GetFeatureInfo", ...options });
+        async getFeatureInfo(options, extra) {
+          const url = this.getFeatureInfoURL(options, extra);
           const response = await this.fetch(url, this.loadOptions);
+          await this.checkResponse(response);
           const arrayBuffer = await response.arrayBuffer();
           return await WMSFeatureInfoLoader.parse(arrayBuffer, this.loadOptions);
         }
-        async getLayerInfo(options) {
-          const url = this.getUrl({ request: "GetLayerInfo", ...options });
+        async describeLayer(options, extra) {
+          const url = this.describeLayerURL(options, extra);
           const response = await this.fetch(url, this.loadOptions);
+          await this.checkResponse(response);
           const arrayBuffer = await response.arrayBuffer();
           return await WMSLayerDescriptionLoader.parse(arrayBuffer, this.loadOptions);
         }
-        async getLegendImage(options) {
-          const url = this.getUrl({ request: "GetLegendImage", ...options });
+        async getLegendGraphic(options, extra) {
+          const url = this.getLegendGraphicURL(options, extra);
           const response = await this.fetch(url, this.loadOptions);
+          await this.checkResponse(response);
           const arrayBuffer = await response.arrayBuffer();
           return await ImageLoader.parse(arrayBuffer, this.loadOptions);
         }
-        getUrl(options) {
+        getWMSUrl(options, extra) {
           let url = `${this.url}?REQUEST=${options.request}`;
           if (options.layers?.length) {
             url += `&LAYERS=[${options.layers.join(",")}]`;
           }
           return url;
         }
+        async checkResponse(response) {
+          if (!response.ok || response.headers["content-type"] === WMSErrorLoader.mimeTypes[0]) {
+            const arrayBuffer = await response.arrayBuffer();
+            const error = await WMSErrorLoader.parse(arrayBuffer, this.loadOptions);
+            throw new Error(error);
+          }
+        }
+      };
+    }
+  });
+
+  // src/lib/wfs/parse-wfs.ts
+  function parseWFSCapabilities(text, options) {
+    options = { ...options, xml: { ...options?.xml, removeNSPrefix: true } };
+    const parsedXML = XMLLoader.parseTextSync(text, options);
+    const xmlCapabilities = parsedXML.Capabilities || parsedXML;
+    return uncapitalizeKeys(xmlCapabilities);
+  }
+  function uncapitalizeKeys(object) {
+    if (object && typeof object === "object") {
+      const newObject = {};
+      for (const [key, value] of Object.entries(object)) {
+        newObject[uncapitalize(key)] = uncapitalizeKeys(value);
+      }
+      return newObject;
+    }
+    return object;
+  }
+  function uncapitalize(str) {
+    return typeof str === "string" ? str.charAt(0).toLowerCase() + str.slice(1) : str;
+  }
+  var init_parse_wfs = __esm({
+    "src/lib/wfs/parse-wfs.ts"() {
+      init_src();
+    }
+  });
+
+  // src/wfs-capabilities-loader.ts
+  function testXMLFile4(text) {
+    return text.startsWith("<?xml");
+  }
+  var VERSION5, WFSCapabilitiesLoader;
+  var init_wfs_capabilities_loader = __esm({
+    "src/wfs-capabilities-loader.ts"() {
+      init_parse_wfs();
+      VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      WFSCapabilitiesLoader = {
+        name: "WFS Capabilities",
+        id: "wfs-capabilities",
+        module: "wms",
+        version: VERSION5,
+        worker: false,
+        extensions: ["xml"],
+        mimeTypes: ["application/vnd.ogc.wfs_xml", "application/xml", "text/xml"],
+        testText: testXMLFile4,
+        options: {
+          wms: {}
+        },
+        parse: async (arrayBuffer, options) => parseWFSCapabilities(new TextDecoder().decode(arrayBuffer), options),
+        parseTextSync: (text, options) => parseWFSCapabilities(text, options)
+      };
+    }
+  });
+
+  // src/lib/wmts/parse-wmts.ts
+  function parseWMTSCapabilities(text, options) {
+    options = { ...options, xml: { ...options?.xml, removeNSPrefix: true } };
+    const parsedXML = XMLLoader.parseTextSync(text, options);
+    const xmlCapabilities = parsedXML.Capabilities || parsedXML;
+    return uncapitalizeKeys2(xmlCapabilities);
+  }
+  function uncapitalizeKeys2(object) {
+    if (object && typeof object === "object") {
+      const newObject = {};
+      for (const [key, value] of Object.entries(object)) {
+        newObject[uncapitalize2(key)] = uncapitalizeKeys2(value);
+      }
+      return newObject;
+    }
+    return object;
+  }
+  function uncapitalize2(str) {
+    return typeof str === "string" ? str.charAt(0).toLowerCase() + str.slice(1) : str;
+  }
+  var init_parse_wmts = __esm({
+    "src/lib/wmts/parse-wmts.ts"() {
+      init_src();
+    }
+  });
+
+  // src/wmts-capabilities-loader.ts
+  function testXMLFile5(text) {
+    return text.startsWith("<?xml");
+  }
+  var VERSION6, WMTSCapabilitiesLoader;
+  var init_wmts_capabilities_loader = __esm({
+    "src/wmts-capabilities-loader.ts"() {
+      init_parse_wmts();
+      VERSION6 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      WMTSCapabilitiesLoader = {
+        name: "WMTS Capabilities",
+        id: "wmts-capabilities",
+        module: "wms",
+        version: VERSION6,
+        worker: false,
+        extensions: ["xml"],
+        mimeTypes: ["application/vnd.ogc.wmts_xml", "application/xml", "text/xml"],
+        testText: testXMLFile5,
+        options: {
+          wms: {}
+        },
+        parse: async (arrayBuffer, options) => parseWMTSCapabilities(new TextDecoder().decode(arrayBuffer), options),
+        parseTextSync: (text, options) => parseWMTSCapabilities(text, options)
+      };
+    }
+  });
+
+  // ../../node_modules/buf-compare/index.js
+  var require_buf_compare = __commonJS({
+    "../../node_modules/buf-compare/index.js"(exports, module) {
+      "use strict";
+      module.exports = Buffer.compare || function(a, b) {
+        if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
+          throw new TypeError("Arguments must be Buffers");
+        }
+        if (a === b) {
+          return 0;
+        }
+        var x = a.length;
+        var y = b.length;
+        var len = Math.min(x, y);
+        for (var i = 0; i < len; i++) {
+          if (a[i] !== b[i]) {
+            break;
+          }
+        }
+        if (i !== len) {
+          x = a[i];
+          y = b[i];
+        }
+        return x < y ? -1 : y < x ? 1 : 0;
+      };
+    }
+  });
+
+  // ../../node_modules/is-error/index.js
+  var require_is_error = __commonJS({
+    "../../node_modules/is-error/index.js"(exports, module) {
+      "use strict";
+      var objectToString = Object.prototype.toString;
+      var getPrototypeOf = Object.getPrototypeOf;
+      var ERROR_TYPE = "[object Error]";
+      module.exports = function isError(err) {
+        if (typeof err !== "object") {
+          return false;
+        }
+        if (err instanceof Error) {
+          return true;
+        }
+        while (err) {
+          if (objectToString.call(err) === ERROR_TYPE) {
+            return true;
+          }
+          err = getPrototypeOf(err);
+        }
+        return false;
+      };
+    }
+  });
+
+  // ../../node_modules/util/support/isBufferBrowser.js
+  var require_isBufferBrowser = __commonJS({
+    "../../node_modules/util/support/isBufferBrowser.js"(exports, module) {
+      module.exports = function isBuffer(arg) {
+        return arg && typeof arg === "object" && typeof arg.copy === "function" && typeof arg.fill === "function" && typeof arg.readUInt8 === "function";
+      };
+    }
+  });
+
+  // ../../node_modules/util/node_modules/inherits/inherits_browser.js
+  var require_inherits_browser = __commonJS({
+    "../../node_modules/util/node_modules/inherits/inherits_browser.js"(exports, module) {
+      if (typeof Object.create === "function") {
+        module.exports = function inherits(ctor, superCtor) {
+          ctor.super_ = superCtor;
+          ctor.prototype = Object.create(superCtor.prototype, {
+            constructor: {
+              value: ctor,
+              enumerable: false,
+              writable: true,
+              configurable: true
+            }
+          });
+        };
+      } else {
+        module.exports = function inherits(ctor, superCtor) {
+          ctor.super_ = superCtor;
+          var TempCtor = function() {
+          };
+          TempCtor.prototype = superCtor.prototype;
+          ctor.prototype = new TempCtor();
+          ctor.prototype.constructor = ctor;
+        };
+      }
+    }
+  });
+
+  // ../../node_modules/util/util.js
+  var require_util2 = __commonJS({
+    "../../node_modules/util/util.js"(exports) {
+      var getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors || function getOwnPropertyDescriptors2(obj) {
+        var keys = Object.keys(obj);
+        var descriptors = {};
+        for (var i = 0; i < keys.length; i++) {
+          descriptors[keys[i]] = Object.getOwnPropertyDescriptor(obj, keys[i]);
+        }
+        return descriptors;
+      };
+      var formatRegExp = /%[sdj%]/g;
+      exports.format = function(f) {
+        if (!isString(f)) {
+          var objects = [];
+          for (var i = 0; i < arguments.length; i++) {
+            objects.push(inspect(arguments[i]));
+          }
+          return objects.join(" ");
+        }
+        var i = 1;
+        var args = arguments;
+        var len = args.length;
+        var str = String(f).replace(formatRegExp, function(x2) {
+          if (x2 === "%%")
+            return "%";
+          if (i >= len)
+            return x2;
+          switch (x2) {
+            case "%s":
+              return String(args[i++]);
+            case "%d":
+              return Number(args[i++]);
+            case "%j":
+              try {
+                return JSON.stringify(args[i++]);
+              } catch (_) {
+                return "[Circular]";
+              }
+            default:
+              return x2;
+          }
+        });
+        for (var x = args[i]; i < len; x = args[++i]) {
+          if (isNull(x) || !isObject2(x)) {
+            str += " " + x;
+          } else {
+            str += " " + inspect(x);
+          }
+        }
+        return str;
+      };
+      exports.deprecate = function(fn, msg) {
+        if (typeof process !== "undefined" && process.noDeprecation === true) {
+          return fn;
+        }
+        if (typeof process === "undefined") {
+          return function() {
+            return exports.deprecate(fn, msg).apply(this, arguments);
+          };
+        }
+        var warned = false;
+        function deprecated() {
+          if (!warned) {
+            if (process.throwDeprecation) {
+              throw new Error(msg);
+            } else if (process.traceDeprecation) {
+              console.trace(msg);
+            } else {
+              console.error(msg);
+            }
+            warned = true;
+          }
+          return fn.apply(this, arguments);
+        }
+        return deprecated;
+      };
+      var debugs = {};
+      var debugEnviron;
+      exports.debuglog = function(set) {
+        if (isUndefined(debugEnviron))
+          debugEnviron = process.env.NODE_DEBUG || "";
+        set = set.toUpperCase();
+        if (!debugs[set]) {
+          if (new RegExp("\\b" + set + "\\b", "i").test(debugEnviron)) {
+            var pid = process.pid;
+            debugs[set] = function() {
+              var msg = exports.format.apply(exports, arguments);
+              console.error("%s %d: %s", set, pid, msg);
+            };
+          } else {
+            debugs[set] = function() {
+            };
+          }
+        }
+        return debugs[set];
+      };
+      function inspect(obj, opts) {
+        var ctx = {
+          seen: [],
+          stylize: stylizeNoColor
+        };
+        if (arguments.length >= 3)
+          ctx.depth = arguments[2];
+        if (arguments.length >= 4)
+          ctx.colors = arguments[3];
+        if (isBoolean(opts)) {
+          ctx.showHidden = opts;
+        } else if (opts) {
+          exports._extend(ctx, opts);
+        }
+        if (isUndefined(ctx.showHidden))
+          ctx.showHidden = false;
+        if (isUndefined(ctx.depth))
+          ctx.depth = 2;
+        if (isUndefined(ctx.colors))
+          ctx.colors = false;
+        if (isUndefined(ctx.customInspect))
+          ctx.customInspect = true;
+        if (ctx.colors)
+          ctx.stylize = stylizeWithColor;
+        return formatValue(ctx, obj, ctx.depth);
+      }
+      exports.inspect = inspect;
+      inspect.colors = {
+        "bold": [1, 22],
+        "italic": [3, 23],
+        "underline": [4, 24],
+        "inverse": [7, 27],
+        "white": [37, 39],
+        "grey": [90, 39],
+        "black": [30, 39],
+        "blue": [34, 39],
+        "cyan": [36, 39],
+        "green": [32, 39],
+        "magenta": [35, 39],
+        "red": [31, 39],
+        "yellow": [33, 39]
+      };
+      inspect.styles = {
+        "special": "cyan",
+        "number": "yellow",
+        "boolean": "yellow",
+        "undefined": "grey",
+        "null": "bold",
+        "string": "green",
+        "date": "magenta",
+        "regexp": "red"
+      };
+      function stylizeWithColor(str, styleType) {
+        var style = inspect.styles[styleType];
+        if (style) {
+          return "[" + inspect.colors[style][0] + "m" + str + "[" + inspect.colors[style][1] + "m";
+        } else {
+          return str;
+        }
+      }
+      function stylizeNoColor(str, styleType) {
+        return str;
+      }
+      function arrayToHash(array) {
+        var hash = {};
+        array.forEach(function(val, idx) {
+          hash[val] = true;
+        });
+        return hash;
+      }
+      function formatValue(ctx, value, recurseTimes) {
+        if (ctx.customInspect && value && isFunction(value.inspect) && value.inspect !== exports.inspect && !(value.constructor && value.constructor.prototype === value)) {
+          var ret = value.inspect(recurseTimes, ctx);
+          if (!isString(ret)) {
+            ret = formatValue(ctx, ret, recurseTimes);
+          }
+          return ret;
+        }
+        var primitive = formatPrimitive(ctx, value);
+        if (primitive) {
+          return primitive;
+        }
+        var keys = Object.keys(value);
+        var visibleKeys = arrayToHash(keys);
+        if (ctx.showHidden) {
+          keys = Object.getOwnPropertyNames(value);
+        }
+        if (isError(value) && (keys.indexOf("message") >= 0 || keys.indexOf("description") >= 0)) {
+          return formatError(value);
+        }
+        if (keys.length === 0) {
+          if (isFunction(value)) {
+            var name = value.name ? ": " + value.name : "";
+            return ctx.stylize("[Function" + name + "]", "special");
+          }
+          if (isRegExp(value)) {
+            return ctx.stylize(RegExp.prototype.toString.call(value), "regexp");
+          }
+          if (isDate(value)) {
+            return ctx.stylize(Date.prototype.toString.call(value), "date");
+          }
+          if (isError(value)) {
+            return formatError(value);
+          }
+        }
+        var base = "", array = false, braces = ["{", "}"];
+        if (isArray(value)) {
+          array = true;
+          braces = ["[", "]"];
+        }
+        if (isFunction(value)) {
+          var n = value.name ? ": " + value.name : "";
+          base = " [Function" + n + "]";
+        }
+        if (isRegExp(value)) {
+          base = " " + RegExp.prototype.toString.call(value);
+        }
+        if (isDate(value)) {
+          base = " " + Date.prototype.toUTCString.call(value);
+        }
+        if (isError(value)) {
+          base = " " + formatError(value);
+        }
+        if (keys.length === 0 && (!array || value.length == 0)) {
+          return braces[0] + base + braces[1];
+        }
+        if (recurseTimes < 0) {
+          if (isRegExp(value)) {
+            return ctx.stylize(RegExp.prototype.toString.call(value), "regexp");
+          } else {
+            return ctx.stylize("[Object]", "special");
+          }
+        }
+        ctx.seen.push(value);
+        var output;
+        if (array) {
+          output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
+        } else {
+          output = keys.map(function(key) {
+            return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
+          });
+        }
+        ctx.seen.pop();
+        return reduceToSingleString(output, base, braces);
+      }
+      function formatPrimitive(ctx, value) {
+        if (isUndefined(value))
+          return ctx.stylize("undefined", "undefined");
+        if (isString(value)) {
+          var simple = "'" + JSON.stringify(value).replace(/^"|"$/g, "").replace(/'/g, "\\'").replace(/\\"/g, '"') + "'";
+          return ctx.stylize(simple, "string");
+        }
+        if (isNumber2(value))
+          return ctx.stylize("" + value, "number");
+        if (isBoolean(value))
+          return ctx.stylize("" + value, "boolean");
+        if (isNull(value))
+          return ctx.stylize("null", "null");
+      }
+      function formatError(value) {
+        return "[" + Error.prototype.toString.call(value) + "]";
+      }
+      function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
+        var output = [];
+        for (var i = 0, l = value.length; i < l; ++i) {
+          if (hasOwnProperty(value, String(i))) {
+            output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, String(i), true));
+          } else {
+            output.push("");
+          }
+        }
+        keys.forEach(function(key) {
+          if (!key.match(/^\d+$/)) {
+            output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, key, true));
+          }
+        });
+        return output;
+      }
+      function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
+        var name, str, desc;
+        desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
+        if (desc.get) {
+          if (desc.set) {
+            str = ctx.stylize("[Getter/Setter]", "special");
+          } else {
+            str = ctx.stylize("[Getter]", "special");
+          }
+        } else {
+          if (desc.set) {
+            str = ctx.stylize("[Setter]", "special");
+          }
+        }
+        if (!hasOwnProperty(visibleKeys, key)) {
+          name = "[" + key + "]";
+        }
+        if (!str) {
+          if (ctx.seen.indexOf(desc.value) < 0) {
+            if (isNull(recurseTimes)) {
+              str = formatValue(ctx, desc.value, null);
+            } else {
+              str = formatValue(ctx, desc.value, recurseTimes - 1);
+            }
+            if (str.indexOf("\n") > -1) {
+              if (array) {
+                str = str.split("\n").map(function(line) {
+                  return "  " + line;
+                }).join("\n").substr(2);
+              } else {
+                str = "\n" + str.split("\n").map(function(line) {
+                  return "   " + line;
+                }).join("\n");
+              }
+            }
+          } else {
+            str = ctx.stylize("[Circular]", "special");
+          }
+        }
+        if (isUndefined(name)) {
+          if (array && key.match(/^\d+$/)) {
+            return str;
+          }
+          name = JSON.stringify("" + key);
+          if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
+            name = name.substr(1, name.length - 2);
+            name = ctx.stylize(name, "name");
+          } else {
+            name = name.replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'");
+            name = ctx.stylize(name, "string");
+          }
+        }
+        return name + ": " + str;
+      }
+      function reduceToSingleString(output, base, braces) {
+        var numLinesEst = 0;
+        var length = output.reduce(function(prev, cur) {
+          numLinesEst++;
+          if (cur.indexOf("\n") >= 0)
+            numLinesEst++;
+          return prev + cur.replace(/\u001b\[\d\d?m/g, "").length + 1;
+        }, 0);
+        if (length > 60) {
+          return braces[0] + (base === "" ? "" : base + "\n ") + " " + output.join(",\n  ") + " " + braces[1];
+        }
+        return braces[0] + base + " " + output.join(", ") + " " + braces[1];
+      }
+      function isArray(ar) {
+        return Array.isArray(ar);
+      }
+      exports.isArray = isArray;
+      function isBoolean(arg) {
+        return typeof arg === "boolean";
+      }
+      exports.isBoolean = isBoolean;
+      function isNull(arg) {
+        return arg === null;
+      }
+      exports.isNull = isNull;
+      function isNullOrUndefined(arg) {
+        return arg == null;
+      }
+      exports.isNullOrUndefined = isNullOrUndefined;
+      function isNumber2(arg) {
+        return typeof arg === "number";
+      }
+      exports.isNumber = isNumber2;
+      function isString(arg) {
+        return typeof arg === "string";
+      }
+      exports.isString = isString;
+      function isSymbol(arg) {
+        return typeof arg === "symbol";
+      }
+      exports.isSymbol = isSymbol;
+      function isUndefined(arg) {
+        return arg === void 0;
+      }
+      exports.isUndefined = isUndefined;
+      function isRegExp(re) {
+        return isObject2(re) && objectToString(re) === "[object RegExp]";
+      }
+      exports.isRegExp = isRegExp;
+      function isObject2(arg) {
+        return typeof arg === "object" && arg !== null;
+      }
+      exports.isObject = isObject2;
+      function isDate(d) {
+        return isObject2(d) && objectToString(d) === "[object Date]";
+      }
+      exports.isDate = isDate;
+      function isError(e) {
+        return isObject2(e) && (objectToString(e) === "[object Error]" || e instanceof Error);
+      }
+      exports.isError = isError;
+      function isFunction(arg) {
+        return typeof arg === "function";
+      }
+      exports.isFunction = isFunction;
+      function isPrimitive(arg) {
+        return arg === null || typeof arg === "boolean" || typeof arg === "number" || typeof arg === "string" || typeof arg === "symbol" || typeof arg === "undefined";
+      }
+      exports.isPrimitive = isPrimitive;
+      exports.isBuffer = require_isBufferBrowser();
+      function objectToString(o) {
+        return Object.prototype.toString.call(o);
+      }
+      function pad(n) {
+        return n < 10 ? "0" + n.toString(10) : n.toString(10);
+      }
+      var months = [
+        "Jan",
+        "Feb",
+        "Mar",
+        "Apr",
+        "May",
+        "Jun",
+        "Jul",
+        "Aug",
+        "Sep",
+        "Oct",
+        "Nov",
+        "Dec"
+      ];
+      function timestamp() {
+        var d = new Date();
+        var time = [
+          pad(d.getHours()),
+          pad(d.getMinutes()),
+          pad(d.getSeconds())
+        ].join(":");
+        return [d.getDate(), months[d.getMonth()], time].join(" ");
+      }
+      exports.log = function() {
+        console.log("%s - %s", timestamp(), exports.format.apply(exports, arguments));
+      };
+      exports.inherits = require_inherits_browser();
+      exports._extend = function(origin, add) {
+        if (!add || !isObject2(add))
+          return origin;
+        var keys = Object.keys(add);
+        var i = keys.length;
+        while (i--) {
+          origin[keys[i]] = add[keys[i]];
+        }
+        return origin;
+      };
+      function hasOwnProperty(obj, prop) {
+        return Object.prototype.hasOwnProperty.call(obj, prop);
+      }
+      var kCustomPromisifiedSymbol = typeof Symbol !== "undefined" ? Symbol("util.promisify.custom") : void 0;
+      exports.promisify = function promisify(original) {
+        if (typeof original !== "function")
+          throw new TypeError('The "original" argument must be of type Function');
+        if (kCustomPromisifiedSymbol && original[kCustomPromisifiedSymbol]) {
+          var fn = original[kCustomPromisifiedSymbol];
+          if (typeof fn !== "function") {
+            throw new TypeError('The "util.promisify.custom" argument must be of type Function');
+          }
+          Object.defineProperty(fn, kCustomPromisifiedSymbol, {
+            value: fn,
+            enumerable: false,
+            writable: false,
+            configurable: true
+          });
+          return fn;
+        }
+        function fn() {
+          var promiseResolve, promiseReject;
+          var promise = new Promise(function(resolve, reject) {
+            promiseResolve = resolve;
+            promiseReject = reject;
+          });
+          var args = [];
+          for (var i = 0; i < arguments.length; i++) {
+            args.push(arguments[i]);
+          }
+          args.push(function(err, value) {
+            if (err) {
+              promiseReject(err);
+            } else {
+              promiseResolve(value);
+            }
+          });
+          try {
+            original.apply(this, args);
+          } catch (err) {
+            promiseReject(err);
+          }
+          return promise;
+        }
+        Object.setPrototypeOf(fn, Object.getPrototypeOf(original));
+        if (kCustomPromisifiedSymbol)
+          Object.defineProperty(fn, kCustomPromisifiedSymbol, {
+            value: fn,
+            enumerable: false,
+            writable: false,
+            configurable: true
+          });
+        return Object.defineProperties(fn, getOwnPropertyDescriptors(original));
+      };
+      exports.promisify.custom = kCustomPromisifiedSymbol;
+      function callbackifyOnRejected(reason, cb) {
+        if (!reason) {
+          var newReason = new Error("Promise was rejected with a falsy value");
+          newReason.reason = reason;
+          reason = newReason;
+        }
+        return cb(reason);
+      }
+      function callbackify(original) {
+        if (typeof original !== "function") {
+          throw new TypeError('The "original" argument must be of type Function');
+        }
+        function callbackified() {
+          var args = [];
+          for (var i = 0; i < arguments.length; i++) {
+            args.push(arguments[i]);
+          }
+          var maybeCb = args.pop();
+          if (typeof maybeCb !== "function") {
+            throw new TypeError("The last argument must be of type Function");
+          }
+          var self2 = this;
+          var cb = function() {
+            return maybeCb.apply(self2, arguments);
+          };
+          original.apply(this, args).then(function(ret) {
+            process.nextTick(cb, null, ret);
+          }, function(rej) {
+            process.nextTick(callbackifyOnRejected, rej, cb);
+          });
+        }
+        Object.setPrototypeOf(callbackified, Object.getPrototypeOf(original));
+        Object.defineProperties(callbackified, getOwnPropertyDescriptors(original));
+        return callbackified;
+      }
+      exports.callbackify = callbackify;
+    }
+  });
+
+  // ../../node_modules/base64-js/index.js
+  var require_base64_js = __commonJS({
+    "../../node_modules/base64-js/index.js"(exports) {
+      "use strict";
+      exports.byteLength = byteLength;
+      exports.toByteArray = toByteArray;
+      exports.fromByteArray = fromByteArray;
+      var lookup = [];
+      var revLookup = [];
+      var Arr = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
+      var code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+      for (i = 0, len = code.length; i < len; ++i) {
+        lookup[i] = code[i];
+        revLookup[code.charCodeAt(i)] = i;
+      }
+      var i;
+      var len;
+      revLookup["-".charCodeAt(0)] = 62;
+      revLookup["_".charCodeAt(0)] = 63;
+      function getLens(b64) {
+        var len2 = b64.length;
+        if (len2 % 4 > 0) {
+          throw new Error("Invalid string. Length must be a multiple of 4");
+        }
+        var validLen = b64.indexOf("=");
+        if (validLen === -1)
+          validLen = len2;
+        var placeHoldersLen = validLen === len2 ? 0 : 4 - validLen % 4;
+        return [validLen, placeHoldersLen];
+      }
+      function byteLength(b64) {
+        var lens = getLens(b64);
+        var validLen = lens[0];
+        var placeHoldersLen = lens[1];
+        return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+      }
+      function _byteLength(b64, validLen, placeHoldersLen) {
+        return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+      }
+      function toByteArray(b64) {
+        var tmp;
+        var lens = getLens(b64);
+        var validLen = lens[0];
+        var placeHoldersLen = lens[1];
+        var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));
+        var curByte = 0;
+        var len2 = placeHoldersLen > 0 ? validLen - 4 : validLen;
+        var i2;
+        for (i2 = 0; i2 < len2; i2 += 4) {
+          tmp = revLookup[b64.charCodeAt(i2)] << 18 | revLookup[b64.charCodeAt(i2 + 1)] << 12 | revLookup[b64.charCodeAt(i2 + 2)] << 6 | revLookup[b64.charCodeAt(i2 + 3)];
+          arr[curByte++] = tmp >> 16 & 255;
+          arr[curByte++] = tmp >> 8 & 255;
+          arr[curByte++] = tmp & 255;
+        }
+        if (placeHoldersLen === 2) {
+          tmp = revLookup[b64.charCodeAt(i2)] << 2 | revLookup[b64.charCodeAt(i2 + 1)] >> 4;
+          arr[curByte++] = tmp & 255;
+        }
+        if (placeHoldersLen === 1) {
+          tmp = revLookup[b64.charCodeAt(i2)] << 10 | revLookup[b64.charCodeAt(i2 + 1)] << 4 | revLookup[b64.charCodeAt(i2 + 2)] >> 2;
+          arr[curByte++] = tmp >> 8 & 255;
+          arr[curByte++] = tmp & 255;
+        }
+        return arr;
+      }
+      function tripletToBase64(num) {
+        return lookup[num >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[num & 63];
+      }
+      function encodeChunk(uint8, start, end) {
+        var tmp;
+        var output = [];
+        for (var i2 = start; i2 < end; i2 += 3) {
+          tmp = (uint8[i2] << 16 & 16711680) + (uint8[i2 + 1] << 8 & 65280) + (uint8[i2 + 2] & 255);
+          output.push(tripletToBase64(tmp));
+        }
+        return output.join("");
+      }
+      function fromByteArray(uint8) {
+        var tmp;
+        var len2 = uint8.length;
+        var extraBytes = len2 % 3;
+        var parts = [];
+        var maxChunkLength = 16383;
+        for (var i2 = 0, len22 = len2 - extraBytes; i2 < len22; i2 += maxChunkLength) {
+          parts.push(encodeChunk(uint8, i2, i2 + maxChunkLength > len22 ? len22 : i2 + maxChunkLength));
+        }
+        if (extraBytes === 1) {
+          tmp = uint8[len2 - 1];
+          parts.push(lookup[tmp >> 2] + lookup[tmp << 4 & 63] + "==");
+        } else if (extraBytes === 2) {
+          tmp = (uint8[len2 - 2] << 8) + uint8[len2 - 1];
+          parts.push(lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + "=");
+        }
+        return parts.join("");
+      }
+    }
+  });
+
+  // ../../node_modules/ieee754/index.js
+  var require_ieee754 = __commonJS({
+    "../../node_modules/ieee754/index.js"(exports) {
+      exports.read = function(buffer, offset, isLE, mLen, nBytes) {
+        var e, m;
+        var eLen = nBytes * 8 - mLen - 1;
+        var eMax = (1 << eLen) - 1;
+        var eBias = eMax >> 1;
+        var nBits = -7;
+        var i = isLE ? nBytes - 1 : 0;
+        var d = isLE ? -1 : 1;
+        var s = buffer[offset + i];
+        i += d;
+        e = s & (1 << -nBits) - 1;
+        s >>= -nBits;
+        nBits += eLen;
+        for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {
+        }
+        m = e & (1 << -nBits) - 1;
+        e >>= -nBits;
+        nBits += mLen;
+        for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {
+        }
+        if (e === 0) {
+          e = 1 - eBias;
+        } else if (e === eMax) {
+          return m ? NaN : (s ? -1 : 1) * Infinity;
+        } else {
+          m = m + Math.pow(2, mLen);
+          e = e - eBias;
+        }
+        return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
+      };
+      exports.write = function(buffer, value, offset, isLE, mLen, nBytes) {
+        var e, m, c;
+        var eLen = nBytes * 8 - mLen - 1;
+        var eMax = (1 << eLen) - 1;
+        var eBias = eMax >> 1;
+        var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
+        var i = isLE ? 0 : nBytes - 1;
+        var d = isLE ? 1 : -1;
+        var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
+        value = Math.abs(value);
+        if (isNaN(value) || value === Infinity) {
+          m = isNaN(value) ? 1 : 0;
+          e = eMax;
+        } else {
+          e = Math.floor(Math.log(value) / Math.LN2);
+          if (value * (c = Math.pow(2, -e)) < 1) {
+            e--;
+            c *= 2;
+          }
+          if (e + eBias >= 1) {
+            value += rt / c;
+          } else {
+            value += rt * Math.pow(2, 1 - eBias);
+          }
+          if (value * c >= 2) {
+            e++;
+            c /= 2;
+          }
+          if (e + eBias >= eMax) {
+            m = 0;
+            e = eMax;
+          } else if (e + eBias >= 1) {
+            m = (value * c - 1) * Math.pow(2, mLen);
+            e = e + eBias;
+          } else {
+            m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
+            e = 0;
+          }
+        }
+        for (; mLen >= 8; buffer[offset + i] = m & 255, i += d, m /= 256, mLen -= 8) {
+        }
+        e = e << mLen | m;
+        eLen += mLen;
+        for (; eLen > 0; buffer[offset + i] = e & 255, i += d, e /= 256, eLen -= 8) {
+        }
+        buffer[offset + i - d] |= s * 128;
+      };
+    }
+  });
+
+  // ../../node_modules/buffer/index.js
+  var require_buffer = __commonJS({
+    "../../node_modules/buffer/index.js"(exports) {
+      "use strict";
+      var base64 = require_base64_js();
+      var ieee754 = require_ieee754();
+      var customInspectSymbol = typeof Symbol === "function" && typeof Symbol["for"] === "function" ? Symbol["for"]("nodejs.util.inspect.custom") : null;
+      exports.Buffer = Buffer2;
+      exports.SlowBuffer = SlowBuffer;
+      exports.INSPECT_MAX_BYTES = 50;
+      var K_MAX_LENGTH = 2147483647;
+      exports.kMaxLength = K_MAX_LENGTH;
+      Buffer2.TYPED_ARRAY_SUPPORT = typedArraySupport();
+      if (!Buffer2.TYPED_ARRAY_SUPPORT && typeof console !== "undefined" && typeof console.error === "function") {
+        console.error("This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support.");
+      }
+      function typedArraySupport() {
+        try {
+          var arr = new Uint8Array(1);
+          var proto = { foo: function() {
+            return 42;
+          } };
+          Object.setPrototypeOf(proto, Uint8Array.prototype);
+          Object.setPrototypeOf(arr, proto);
+          return arr.foo() === 42;
+        } catch (e) {
+          return false;
+        }
+      }
+      Object.defineProperty(Buffer2.prototype, "parent", {
+        enumerable: true,
+        get: function() {
+          if (!Buffer2.isBuffer(this))
+            return void 0;
+          return this.buffer;
+        }
+      });
+      Object.defineProperty(Buffer2.prototype, "offset", {
+        enumerable: true,
+        get: function() {
+          if (!Buffer2.isBuffer(this))
+            return void 0;
+          return this.byteOffset;
+        }
+      });
+      function createBuffer(length) {
+        if (length > K_MAX_LENGTH) {
+          throw new RangeError('The value "' + length + '" is invalid for option "size"');
+        }
+        var buf = new Uint8Array(length);
+        Object.setPrototypeOf(buf, Buffer2.prototype);
+        return buf;
+      }
+      function Buffer2(arg, encodingOrOffset, length) {
+        if (typeof arg === "number") {
+          if (typeof encodingOrOffset === "string") {
+            throw new TypeError('The "string" argument must be of type string. Received type number');
+          }
+          return allocUnsafe(arg);
+        }
+        return from(arg, encodingOrOffset, length);
+      }
+      Buffer2.poolSize = 8192;
+      function from(value, encodingOrOffset, length) {
+        if (typeof value === "string") {
+          return fromString(value, encodingOrOffset);
+        }
+        if (ArrayBuffer.isView(value)) {
+          return fromArrayView(value);
+        }
+        if (value == null) {
+          throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value);
+        }
+        if (isInstance(value, ArrayBuffer) || value && isInstance(value.buffer, ArrayBuffer)) {
+          return fromArrayBuffer(value, encodingOrOffset, length);
+        }
+        if (typeof SharedArrayBuffer !== "undefined" && (isInstance(value, SharedArrayBuffer) || value && isInstance(value.buffer, SharedArrayBuffer))) {
+          return fromArrayBuffer(value, encodingOrOffset, length);
+        }
+        if (typeof value === "number") {
+          throw new TypeError('The "value" argument must not be of type number. Received type number');
+        }
+        var valueOf = value.valueOf && value.valueOf();
+        if (valueOf != null && valueOf !== value) {
+          return Buffer2.from(valueOf, encodingOrOffset, length);
+        }
+        var b = fromObject(value);
+        if (b)
+          return b;
+        if (typeof Symbol !== "undefined" && Symbol.toPrimitive != null && typeof value[Symbol.toPrimitive] === "function") {
+          return Buffer2.from(value[Symbol.toPrimitive]("string"), encodingOrOffset, length);
+        }
+        throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value);
+      }
+      Buffer2.from = function(value, encodingOrOffset, length) {
+        return from(value, encodingOrOffset, length);
+      };
+      Object.setPrototypeOf(Buffer2.prototype, Uint8Array.prototype);
+      Object.setPrototypeOf(Buffer2, Uint8Array);
+      function assertSize(size) {
+        if (typeof size !== "number") {
+          throw new TypeError('"size" argument must be of type number');
+        } else if (size < 0) {
+          throw new RangeError('The value "' + size + '" is invalid for option "size"');
+        }
+      }
+      function alloc(size, fill, encoding) {
+        assertSize(size);
+        if (size <= 0) {
+          return createBuffer(size);
+        }
+        if (fill !== void 0) {
+          return typeof encoding === "string" ? createBuffer(size).fill(fill, encoding) : createBuffer(size).fill(fill);
+        }
+        return createBuffer(size);
+      }
+      Buffer2.alloc = function(size, fill, encoding) {
+        return alloc(size, fill, encoding);
+      };
+      function allocUnsafe(size) {
+        assertSize(size);
+        return createBuffer(size < 0 ? 0 : checked(size) | 0);
+      }
+      Buffer2.allocUnsafe = function(size) {
+        return allocUnsafe(size);
+      };
+      Buffer2.allocUnsafeSlow = function(size) {
+        return allocUnsafe(size);
+      };
+      function fromString(string, encoding) {
+        if (typeof encoding !== "string" || encoding === "") {
+          encoding = "utf8";
+        }
+        if (!Buffer2.isEncoding(encoding)) {
+          throw new TypeError("Unknown encoding: " + encoding);
+        }
+        var length = byteLength(string, encoding) | 0;
+        var buf = createBuffer(length);
+        var actual = buf.write(string, encoding);
+        if (actual !== length) {
+          buf = buf.slice(0, actual);
+        }
+        return buf;
+      }
+      function fromArrayLike(array) {
+        var length = array.length < 0 ? 0 : checked(array.length) | 0;
+        var buf = createBuffer(length);
+        for (var i = 0; i < length; i += 1) {
+          buf[i] = array[i] & 255;
+        }
+        return buf;
+      }
+      function fromArrayView(arrayView) {
+        if (isInstance(arrayView, Uint8Array)) {
+          var copy = new Uint8Array(arrayView);
+          return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength);
+        }
+        return fromArrayLike(arrayView);
+      }
+      function fromArrayBuffer(array, byteOffset, length) {
+        if (byteOffset < 0 || array.byteLength < byteOffset) {
+          throw new RangeError('"offset" is outside of buffer bounds');
+        }
+        if (array.byteLength < byteOffset + (length || 0)) {
+          throw new RangeError('"length" is outside of buffer bounds');
+        }
+        var buf;
+        if (byteOffset === void 0 && length === void 0) {
+          buf = new Uint8Array(array);
+        } else if (length === void 0) {
+          buf = new Uint8Array(array, byteOffset);
+        } else {
+          buf = new Uint8Array(array, byteOffset, length);
+        }
+        Object.setPrototypeOf(buf, Buffer2.prototype);
+        return buf;
+      }
+      function fromObject(obj) {
+        if (Buffer2.isBuffer(obj)) {
+          var len = checked(obj.length) | 0;
+          var buf = createBuffer(len);
+          if (buf.length === 0) {
+            return buf;
+          }
+          obj.copy(buf, 0, 0, len);
+          return buf;
+        }
+        if (obj.length !== void 0) {
+          if (typeof obj.length !== "number" || numberIsNaN(obj.length)) {
+            return createBuffer(0);
+          }
+          return fromArrayLike(obj);
+        }
+        if (obj.type === "Buffer" && Array.isArray(obj.data)) {
+          return fromArrayLike(obj.data);
+        }
+      }
+      function checked(length) {
+        if (length >= K_MAX_LENGTH) {
+          throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + K_MAX_LENGTH.toString(16) + " bytes");
+        }
+        return length | 0;
+      }
+      function SlowBuffer(length) {
+        if (+length != length) {
+          length = 0;
+        }
+        return Buffer2.alloc(+length);
+      }
+      Buffer2.isBuffer = function isBuffer(b) {
+        return b != null && b._isBuffer === true && b !== Buffer2.prototype;
+      };
+      Buffer2.compare = function compare(a, b) {
+        if (isInstance(a, Uint8Array))
+          a = Buffer2.from(a, a.offset, a.byteLength);
+        if (isInstance(b, Uint8Array))
+          b = Buffer2.from(b, b.offset, b.byteLength);
+        if (!Buffer2.isBuffer(a) || !Buffer2.isBuffer(b)) {
+          throw new TypeError('The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array');
+        }
+        if (a === b)
+          return 0;
+        var x = a.length;
+        var y = b.length;
+        for (var i = 0, len = Math.min(x, y); i < len; ++i) {
+          if (a[i] !== b[i]) {
+            x = a[i];
+            y = b[i];
+            break;
+          }
+        }
+        if (x < y)
+          return -1;
+        if (y < x)
+          return 1;
+        return 0;
+      };
+      Buffer2.isEncoding = function isEncoding(encoding) {
+        switch (String(encoding).toLowerCase()) {
+          case "hex":
+          case "utf8":
+          case "utf-8":
+          case "ascii":
+          case "latin1":
+          case "binary":
+          case "base64":
+          case "ucs2":
+          case "ucs-2":
+          case "utf16le":
+          case "utf-16le":
+            return true;
+          default:
+            return false;
+        }
+      };
+      Buffer2.concat = function concat(list, length) {
+        if (!Array.isArray(list)) {
+          throw new TypeError('"list" argument must be an Array of Buffers');
+        }
+        if (list.length === 0) {
+          return Buffer2.alloc(0);
+        }
+        var i;
+        if (length === void 0) {
+          length = 0;
+          for (i = 0; i < list.length; ++i) {
+            length += list[i].length;
+          }
+        }
+        var buffer = Buffer2.allocUnsafe(length);
+        var pos = 0;
+        for (i = 0; i < list.length; ++i) {
+          var buf = list[i];
+          if (isInstance(buf, Uint8Array)) {
+            if (pos + buf.length > buffer.length) {
+              Buffer2.from(buf).copy(buffer, pos);
+            } else {
+              Uint8Array.prototype.set.call(buffer, buf, pos);
+            }
+          } else if (!Buffer2.isBuffer(buf)) {
+            throw new TypeError('"list" argument must be an Array of Buffers');
+          } else {
+            buf.copy(buffer, pos);
+          }
+          pos += buf.length;
+        }
+        return buffer;
+      };
+      function byteLength(string, encoding) {
+        if (Buffer2.isBuffer(string)) {
+          return string.length;
+        }
+        if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {
+          return string.byteLength;
+        }
+        if (typeof string !== "string") {
+          throw new TypeError('The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof string);
+        }
+        var len = string.length;
+        var mustMatch = arguments.length > 2 && arguments[2] === true;
+        if (!mustMatch && len === 0)
+          return 0;
+        var loweredCase = false;
+        for (; ; ) {
+          switch (encoding) {
+            case "ascii":
+            case "latin1":
+            case "binary":
+              return len;
+            case "utf8":
+            case "utf-8":
+              return utf8ToBytes(string).length;
+            case "ucs2":
+            case "ucs-2":
+            case "utf16le":
+            case "utf-16le":
+              return len * 2;
+            case "hex":
+              return len >>> 1;
+            case "base64":
+              return base64ToBytes(string).length;
+            default:
+              if (loweredCase) {
+                return mustMatch ? -1 : utf8ToBytes(string).length;
+              }
+              encoding = ("" + encoding).toLowerCase();
+              loweredCase = true;
+          }
+        }
+      }
+      Buffer2.byteLength = byteLength;
+      function slowToString(encoding, start, end) {
+        var loweredCase = false;
+        if (start === void 0 || start < 0) {
+          start = 0;
+        }
+        if (start > this.length) {
+          return "";
+        }
+        if (end === void 0 || end > this.length) {
+          end = this.length;
+        }
+        if (end <= 0) {
+          return "";
+        }
+        end >>>= 0;
+        start >>>= 0;
+        if (end <= start) {
+          return "";
+        }
+        if (!encoding)
+          encoding = "utf8";
+        while (true) {
+          switch (encoding) {
+            case "hex":
+              return hexSlice(this, start, end);
+            case "utf8":
+            case "utf-8":
+              return utf8Slice(this, start, end);
+            case "ascii":
+              return asciiSlice(this, start, end);
+            case "latin1":
+            case "binary":
+              return latin1Slice(this, start, end);
+            case "base64":
+              return base64Slice(this, start, end);
+            case "ucs2":
+            case "ucs-2":
+            case "utf16le":
+            case "utf-16le":
+              return utf16leSlice(this, start, end);
+            default:
+              if (loweredCase)
+                throw new TypeError("Unknown encoding: " + encoding);
+              encoding = (encoding + "").toLowerCase();
+              loweredCase = true;
+          }
+        }
+      }
+      Buffer2.prototype._isBuffer = true;
+      function swap(b, n, m) {
+        var i = b[n];
+        b[n] = b[m];
+        b[m] = i;
+      }
+      Buffer2.prototype.swap16 = function swap16() {
+        var len = this.length;
+        if (len % 2 !== 0) {
+          throw new RangeError("Buffer size must be a multiple of 16-bits");
+        }
+        for (var i = 0; i < len; i += 2) {
+          swap(this, i, i + 1);
+        }
+        return this;
+      };
+      Buffer2.prototype.swap32 = function swap32() {
+        var len = this.length;
+        if (len % 4 !== 0) {
+          throw new RangeError("Buffer size must be a multiple of 32-bits");
+        }
+        for (var i = 0; i < len; i += 4) {
+          swap(this, i, i + 3);
+          swap(this, i + 1, i + 2);
+        }
+        return this;
+      };
+      Buffer2.prototype.swap64 = function swap64() {
+        var len = this.length;
+        if (len % 8 !== 0) {
+          throw new RangeError("Buffer size must be a multiple of 64-bits");
+        }
+        for (var i = 0; i < len; i += 8) {
+          swap(this, i, i + 7);
+          swap(this, i + 1, i + 6);
+          swap(this, i + 2, i + 5);
+          swap(this, i + 3, i + 4);
+        }
+        return this;
+      };
+      Buffer2.prototype.toString = function toString() {
+        var length = this.length;
+        if (length === 0)
+          return "";
+        if (arguments.length === 0)
+          return utf8Slice(this, 0, length);
+        return slowToString.apply(this, arguments);
+      };
+      Buffer2.prototype.toLocaleString = Buffer2.prototype.toString;
+      Buffer2.prototype.equals = function equals(b) {
+        if (!Buffer2.isBuffer(b))
+          throw new TypeError("Argument must be a Buffer");
+        if (this === b)
+          return true;
+        return Buffer2.compare(this, b) === 0;
+      };
+      Buffer2.prototype.inspect = function inspect() {
+        var str = "";
+        var max = exports.INSPECT_MAX_BYTES;
+        str = this.toString("hex", 0, max).replace(/(.{2})/g, "$1 ").trim();
+        if (this.length > max)
+          str += " ... ";
+        return "<Buffer " + str + ">";
+      };
+      if (customInspectSymbol) {
+        Buffer2.prototype[customInspectSymbol] = Buffer2.prototype.inspect;
+      }
+      Buffer2.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {
+        if (isInstance(target, Uint8Array)) {
+          target = Buffer2.from(target, target.offset, target.byteLength);
+        }
+        if (!Buffer2.isBuffer(target)) {
+          throw new TypeError('The "target" argument must be one of type Buffer or Uint8Array. Received type ' + typeof target);
+        }
+        if (start === void 0) {
+          start = 0;
+        }
+        if (end === void 0) {
+          end = target ? target.length : 0;
+        }
+        if (thisStart === void 0) {
+          thisStart = 0;
+        }
+        if (thisEnd === void 0) {
+          thisEnd = this.length;
+        }
+        if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
+          throw new RangeError("out of range index");
+        }
+        if (thisStart >= thisEnd && start >= end) {
+          return 0;
+        }
+        if (thisStart >= thisEnd) {
+          return -1;
+        }
+        if (start >= end) {
+          return 1;
+        }
+        start >>>= 0;
+        end >>>= 0;
+        thisStart >>>= 0;
+        thisEnd >>>= 0;
+        if (this === target)
+          return 0;
+        var x = thisEnd - thisStart;
+        var y = end - start;
+        var len = Math.min(x, y);
+        var thisCopy = this.slice(thisStart, thisEnd);
+        var targetCopy = target.slice(start, end);
+        for (var i = 0; i < len; ++i) {
+          if (thisCopy[i] !== targetCopy[i]) {
+            x = thisCopy[i];
+            y = targetCopy[i];
+            break;
+          }
+        }
+        if (x < y)
+          return -1;
+        if (y < x)
+          return 1;
+        return 0;
+      };
+      function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
+        if (buffer.length === 0)
+          return -1;
+        if (typeof byteOffset === "string") {
+          encoding = byteOffset;
+          byteOffset = 0;
+        } else if (byteOffset > 2147483647) {
+          byteOffset = 2147483647;
+        } else if (byteOffset < -2147483648) {
+          byteOffset = -2147483648;
+        }
+        byteOffset = +byteOffset;
+        if (numberIsNaN(byteOffset)) {
+          byteOffset = dir ? 0 : buffer.length - 1;
+        }
+        if (byteOffset < 0)
+          byteOffset = buffer.length + byteOffset;
+        if (byteOffset >= buffer.length) {
+          if (dir)
+            return -1;
+          else
+            byteOffset = buffer.length - 1;
+        } else if (byteOffset < 0) {
+          if (dir)
+            byteOffset = 0;
+          else
+            return -1;
+        }
+        if (typeof val === "string") {
+          val = Buffer2.from(val, encoding);
+        }
+        if (Buffer2.isBuffer(val)) {
+          if (val.length === 0) {
+            return -1;
+          }
+          return arrayIndexOf(buffer, val, byteOffset, encoding, dir);
+        } else if (typeof val === "number") {
+          val = val & 255;
+          if (typeof Uint8Array.prototype.indexOf === "function") {
+            if (dir) {
+              return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset);
+            } else {
+              return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset);
+            }
+          }
+          return arrayIndexOf(buffer, [val], byteOffset, encoding, dir);
+        }
+        throw new TypeError("val must be string, number or Buffer");
+      }
+      function arrayIndexOf(arr, val, byteOffset, encoding, dir) {
+        var indexSize = 1;
+        var arrLength = arr.length;
+        var valLength = val.length;
+        if (encoding !== void 0) {
+          encoding = String(encoding).toLowerCase();
+          if (encoding === "ucs2" || encoding === "ucs-2" || encoding === "utf16le" || encoding === "utf-16le") {
+            if (arr.length < 2 || val.length < 2) {
+              return -1;
+            }
+            indexSize = 2;
+            arrLength /= 2;
+            valLength /= 2;
+            byteOffset /= 2;
+          }
+        }
+        function read(buf, i2) {
+          if (indexSize === 1) {
+            return buf[i2];
+          } else {
+            return buf.readUInt16BE(i2 * indexSize);
+          }
+        }
+        var i;
+        if (dir) {
+          var foundIndex = -1;
+          for (i = byteOffset; i < arrLength; i++) {
+            if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
+              if (foundIndex === -1)
+                foundIndex = i;
+              if (i - foundIndex + 1 === valLength)
+                return foundIndex * indexSize;
+            } else {
+              if (foundIndex !== -1)
+                i -= i - foundIndex;
+              foundIndex = -1;
+            }
+          }
+        } else {
+          if (byteOffset + valLength > arrLength)
+            byteOffset = arrLength - valLength;
+          for (i = byteOffset; i >= 0; i--) {
+            var found = true;
+            for (var j = 0; j < valLength; j++) {
+              if (read(arr, i + j) !== read(val, j)) {
+                found = false;
+                break;
+              }
+            }
+            if (found)
+              return i;
+          }
+        }
+        return -1;
+      }
+      Buffer2.prototype.includes = function includes(val, byteOffset, encoding) {
+        return this.indexOf(val, byteOffset, encoding) !== -1;
+      };
+      Buffer2.prototype.indexOf = function indexOf(val, byteOffset, encoding) {
+        return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
+      };
+      Buffer2.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {
+        return bidirectionalIndexOf(this, val, byteOffset, encoding, false);
+      };
+      function hexWrite(buf, string, offset, length) {
+        offset = Number(offset) || 0;
+        var remaining = buf.length - offset;
+        if (!length) {
+          length = remaining;
+        } else {
+          length = Number(length);
+          if (length > remaining) {
+            length = remaining;
+          }
+        }
+        var strLen = string.length;
+        if (length > strLen / 2) {
+          length = strLen / 2;
+        }
+        for (var i = 0; i < length; ++i) {
+          var parsed = parseInt(string.substr(i * 2, 2), 16);
+          if (numberIsNaN(parsed))
+            return i;
+          buf[offset + i] = parsed;
+        }
+        return i;
+      }
+      function utf8Write(buf, string, offset, length) {
+        return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length);
+      }
+      function asciiWrite(buf, string, offset, length) {
+        return blitBuffer(asciiToBytes(string), buf, offset, length);
+      }
+      function base64Write(buf, string, offset, length) {
+        return blitBuffer(base64ToBytes(string), buf, offset, length);
+      }
+      function ucs2Write(buf, string, offset, length) {
+        return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length);
+      }
+      Buffer2.prototype.write = function write(string, offset, length, encoding) {
+        if (offset === void 0) {
+          encoding = "utf8";
+          length = this.length;
+          offset = 0;
+        } else if (length === void 0 && typeof offset === "string") {
+          encoding = offset;
+          length = this.length;
+          offset = 0;
+        } else if (isFinite(offset)) {
+          offset = offset >>> 0;
+          if (isFinite(length)) {
+            length = length >>> 0;
+            if (encoding === void 0)
+              encoding = "utf8";
+          } else {
+            encoding = length;
+            length = void 0;
+          }
+        } else {
+          throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");
+        }
+        var remaining = this.length - offset;
+        if (length === void 0 || length > remaining)
+          length = remaining;
+        if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length) {
+          throw new RangeError("Attempt to write outside buffer bounds");
+        }
+        if (!encoding)
+          encoding = "utf8";
+        var loweredCase = false;
+        for (; ; ) {
+          switch (encoding) {
+            case "hex":
+              return hexWrite(this, string, offset, length);
+            case "utf8":
+            case "utf-8":
+              return utf8Write(this, string, offset, length);
+            case "ascii":
+            case "latin1":
+            case "binary":
+              return asciiWrite(this, string, offset, length);
+            case "base64":
+              return base64Write(this, string, offset, length);
+            case "ucs2":
+            case "ucs-2":
+            case "utf16le":
+            case "utf-16le":
+              return ucs2Write(this, string, offset, length);
+            default:
+              if (loweredCase)
+                throw new TypeError("Unknown encoding: " + encoding);
+              encoding = ("" + encoding).toLowerCase();
+              loweredCase = true;
+          }
+        }
+      };
+      Buffer2.prototype.toJSON = function toJSON() {
+        return {
+          type: "Buffer",
+          data: Array.prototype.slice.call(this._arr || this, 0)
+        };
+      };
+      function base64Slice(buf, start, end) {
+        if (start === 0 && end === buf.length) {
+          return base64.fromByteArray(buf);
+        } else {
+          return base64.fromByteArray(buf.slice(start, end));
+        }
+      }
+      function utf8Slice(buf, start, end) {
+        end = Math.min(buf.length, end);
+        var res = [];
+        var i = start;
+        while (i < end) {
+          var firstByte = buf[i];
+          var codePoint = null;
+          var bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
+          if (i + bytesPerSequence <= end) {
+            var secondByte, thirdByte, fourthByte, tempCodePoint;
+            switch (bytesPerSequence) {
+              case 1:
+                if (firstByte < 128) {
+                  codePoint = firstByte;
+                }
+                break;
+              case 2:
+                secondByte = buf[i + 1];
+                if ((secondByte & 192) === 128) {
+                  tempCodePoint = (firstByte & 31) << 6 | secondByte & 63;
+                  if (tempCodePoint > 127) {
+                    codePoint = tempCodePoint;
+                  }
+                }
+                break;
+              case 3:
+                secondByte = buf[i + 1];
+                thirdByte = buf[i + 2];
+                if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) {
+                  tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63;
+                  if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) {
+                    codePoint = tempCodePoint;
+                  }
+                }
+                break;
+              case 4:
+                secondByte = buf[i + 1];
+                thirdByte = buf[i + 2];
+                fourthByte = buf[i + 3];
+                if ((secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) {
+                  tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63;
+                  if (tempCodePoint > 65535 && tempCodePoint < 1114112) {
+                    codePoint = tempCodePoint;
+                  }
+                }
+            }
+          }
+          if (codePoint === null) {
+            codePoint = 65533;
+            bytesPerSequence = 1;
+          } else if (codePoint > 65535) {
+            codePoint -= 65536;
+            res.push(codePoint >>> 10 & 1023 | 55296);
+            codePoint = 56320 | codePoint & 1023;
+          }
+          res.push(codePoint);
+          i += bytesPerSequence;
+        }
+        return decodeCodePointsArray(res);
+      }
+      var MAX_ARGUMENTS_LENGTH = 4096;
+      function decodeCodePointsArray(codePoints) {
+        var len = codePoints.length;
+        if (len <= MAX_ARGUMENTS_LENGTH) {
+          return String.fromCharCode.apply(String, codePoints);
+        }
+        var res = "";
+        var i = 0;
+        while (i < len) {
+          res += String.fromCharCode.apply(String, codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH));
+        }
+        return res;
+      }
+      function asciiSlice(buf, start, end) {
+        var ret = "";
+        end = Math.min(buf.length, end);
+        for (var i = start; i < end; ++i) {
+          ret += String.fromCharCode(buf[i] & 127);
+        }
+        return ret;
+      }
+      function latin1Slice(buf, start, end) {
+        var ret = "";
+        end = Math.min(buf.length, end);
+        for (var i = start; i < end; ++i) {
+          ret += String.fromCharCode(buf[i]);
+        }
+        return ret;
+      }
+      function hexSlice(buf, start, end) {
+        var len = buf.length;
+        if (!start || start < 0)
+          start = 0;
+        if (!end || end < 0 || end > len)
+          end = len;
+        var out = "";
+        for (var i = start; i < end; ++i) {
+          out += hexSliceLookupTable[buf[i]];
+        }
+        return out;
+      }
+      function utf16leSlice(buf, start, end) {
+        var bytes = buf.slice(start, end);
+        var res = "";
+        for (var i = 0; i < bytes.length - 1; i += 2) {
+          res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);
+        }
+        return res;
+      }
+      Buffer2.prototype.slice = function slice(start, end) {
+        var len = this.length;
+        start = ~~start;
+        end = end === void 0 ? len : ~~end;
+        if (start < 0) {
+          start += len;
+          if (start < 0)
+            start = 0;
+        } else if (start > len) {
+          start = len;
+        }
+        if (end < 0) {
+          end += len;
+          if (end < 0)
+            end = 0;
+        } else if (end > len) {
+          end = len;
+        }
+        if (end < start)
+          end = start;
+        var newBuf = this.subarray(start, end);
+        Object.setPrototypeOf(newBuf, Buffer2.prototype);
+        return newBuf;
+      };
+      function checkOffset(offset, ext, length) {
+        if (offset % 1 !== 0 || offset < 0)
+          throw new RangeError("offset is not uint");
+        if (offset + ext > length)
+          throw new RangeError("Trying to access beyond buffer length");
+      }
+      Buffer2.prototype.readUintLE = Buffer2.prototype.readUIntLE = function readUIntLE(offset, byteLength2, noAssert) {
+        offset = offset >>> 0;
+        byteLength2 = byteLength2 >>> 0;
+        if (!noAssert)
+          checkOffset(offset, byteLength2, this.length);
+        var val = this[offset];
+        var mul = 1;
+        var i = 0;
+        while (++i < byteLength2 && (mul *= 256)) {
+          val += this[offset + i] * mul;
+        }
+        return val;
+      };
+      Buffer2.prototype.readUintBE = Buffer2.prototype.readUIntBE = function readUIntBE(offset, byteLength2, noAssert) {
+        offset = offset >>> 0;
+        byteLength2 = byteLength2 >>> 0;
+        if (!noAssert) {
+          checkOffset(offset, byteLength2, this.length);
+        }
+        var val = this[offset + --byteLength2];
+        var mul = 1;
+        while (byteLength2 > 0 && (mul *= 256)) {
+          val += this[offset + --byteLength2] * mul;
+        }
+        return val;
+      };
+      Buffer2.prototype.readUint8 = Buffer2.prototype.readUInt8 = function readUInt8(offset, noAssert) {
+        offset = offset >>> 0;
+        if (!noAssert)
+          checkOffset(offset, 1, this.length);
+        return this[offset];
+      };
+      Buffer2.prototype.readUint16LE = Buffer2.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
+        offset = offset >>> 0;
+        if (!noAssert)
+          checkOffset(offset, 2, this.length);
+        return this[offset] | this[offset + 1] << 8;
+      };
+      Buffer2.prototype.readUint16BE = Buffer2.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
+        offset = offset >>> 0;
+        if (!noAssert)
+          checkOffset(offset, 2, this.length);
+        return this[offset] << 8 | this[offset + 1];
+      };
+      Buffer2.prototype.readUint32LE = Buffer2.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {
+        offset = offset >>> 0;
+        if (!noAssert)
+          checkOffset(offset, 4, this.length);
+        return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 16777216;
+      };
+      Buffer2.prototype.readUint32BE = Buffer2.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {
+        offset = offset >>> 0;
+        if (!noAssert)
+          checkOffset(offset, 4, this.length);
+        return this[offset] * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);
+      };
+      Buffer2.prototype.readIntLE = function readIntLE(offset, byteLength2, noAssert) {
+        offset = offset >>> 0;
+        byteLength2 = byteLength2 >>> 0;
+        if (!noAssert)
+          checkOffset(offset, byteLength2, this.length);
+        var val = this[offset];
+        var mul = 1;
+        var i = 0;
+        while (++i < byteLength2 && (mul *= 256)) {
+          val += this[offset + i] * mul;
+        }
+        mul *= 128;
+        if (val >= mul)
+          val -= Math.pow(2, 8 * byteLength2);
+        return val;
+      };
+      Buffer2.prototype.readIntBE = function readIntBE(offset, byteLength2, noAssert) {
+        offset = offset >>> 0;
+        byteLength2 = byteLength2 >>> 0;
+        if (!noAssert)
+          checkOffset(offset, byteLength2, this.length);
+        var i = byteLength2;
+        var mul = 1;
+        var val = this[offset + --i];
+        while (i > 0 && (mul *= 256)) {
+          val += this[offset + --i] * mul;
+        }
+        mul *= 128;
+        if (val >= mul)
+          val -= Math.pow(2, 8 * byteLength2);
+        return val;
+      };
+      Buffer2.prototype.readInt8 = function readInt8(offset, noAssert) {
+        offset = offset >>> 0;
+        if (!noAssert)
+          checkOffset(offset, 1, this.length);
+        if (!(this[offset] & 128))
+          return this[offset];
+        return (255 - this[offset] + 1) * -1;
+      };
+      Buffer2.prototype.readInt16LE = function readInt16LE(offset, noAssert) {
+        offset = offset >>> 0;
+        if (!noAssert)
+          checkOffset(offset, 2, this.length);
+        var val = this[offset] | this[offset + 1] << 8;
+        return val & 32768 ? val | 4294901760 : val;
+      };
+      Buffer2.prototype.readInt16BE = function readInt16BE(offset, noAssert) {
+        offset = offset >>> 0;
+        if (!noAssert)
+          checkOffset(offset, 2, this.length);
+        var val = this[offset + 1] | this[offset] << 8;
+        return val & 32768 ? val | 4294901760 : val;
+      };
+      Buffer2.prototype.readInt32LE = function readInt32LE(offset, noAssert) {
+        offset = offset >>> 0;
+        if (!noAssert)
+          checkOffset(offset, 4, this.length);
+        return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;
+      };
+      Buffer2.prototype.readInt32BE = function readInt32BE(offset, noAssert) {
+        offset = offset >>> 0;
+        if (!noAssert)
+          checkOffset(offset, 4, this.length);
+        return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];
+      };
+      Buffer2.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
+        offset = offset >>> 0;
+        if (!noAssert)
+          checkOffset(offset, 4, this.length);
+        return ieee754.read(this, offset, true, 23, 4);
+      };
+      Buffer2.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
+        offset = offset >>> 0;
+        if (!noAssert)
+          checkOffset(offset, 4, this.length);
+        return ieee754.read(this, offset, false, 23, 4);
+      };
+      Buffer2.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {
+        offset = offset >>> 0;
+        if (!noAssert)
+          checkOffset(offset, 8, this.length);
+        return ieee754.read(this, offset, true, 52, 8);
+      };
+      Buffer2.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {
+        offset = offset >>> 0;
+        if (!noAssert)
+          checkOffset(offset, 8, this.length);
+        return ieee754.read(this, offset, false, 52, 8);
+      };
+      function checkInt(buf, value, offset, ext, max, min) {
+        if (!Buffer2.isBuffer(buf))
+          throw new TypeError('"buffer" argument must be a Buffer instance');
+        if (value > max || value < min)
+          throw new RangeError('"value" argument is out of bounds');
+        if (offset + ext > buf.length)
+          throw new RangeError("Index out of range");
+      }
+      Buffer2.prototype.writeUintLE = Buffer2.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength2, noAssert) {
+        value = +value;
+        offset = offset >>> 0;
+        byteLength2 = byteLength2 >>> 0;
+        if (!noAssert) {
+          var maxBytes = Math.pow(2, 8 * byteLength2) - 1;
+          checkInt(this, value, offset, byteLength2, maxBytes, 0);
+        }
+        var mul = 1;
+        var i = 0;
+        this[offset] = value & 255;
+        while (++i < byteLength2 && (mul *= 256)) {
+          this[offset + i] = value / mul & 255;
+        }
+        return offset + byteLength2;
+      };
+      Buffer2.prototype.writeUintBE = Buffer2.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength2, noAssert) {
+        value = +value;
+        offset = offset >>> 0;
+        byteLength2 = byteLength2 >>> 0;
+        if (!noAssert) {
+          var maxBytes = Math.pow(2, 8 * byteLength2) - 1;
+          checkInt(this, value, offset, byteLength2, maxBytes, 0);
+        }
+        var i = byteLength2 - 1;
+        var mul = 1;
+        this[offset + i] = value & 255;
+        while (--i >= 0 && (mul *= 256)) {
+          this[offset + i] = value / mul & 255;
+        }
+        return offset + byteLength2;
+      };
+      Buffer2.prototype.writeUint8 = Buffer2.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {
+        value = +value;
+        offset = offset >>> 0;
+        if (!noAssert)
+          checkInt(this, value, offset, 1, 255, 0);
+        this[offset] = value & 255;
+        return offset + 1;
+      };
+      Buffer2.prototype.writeUint16LE = Buffer2.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {
+        value = +value;
+        offset = offset >>> 0;
+        if (!noAssert)
+          checkInt(this, value, offset, 2, 65535, 0);
+        this[offset] = value & 255;
+        this[offset + 1] = value >>> 8;
+        return offset + 2;
+      };
+      Buffer2.prototype.writeUint16BE = Buffer2.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {
+        value = +value;
+        offset = offset >>> 0;
+        if (!noAssert)
+          checkInt(this, value, offset, 2, 65535, 0);
+        this[offset] = value >>> 8;
+        this[offset + 1] = value & 255;
+        return offset + 2;
+      };
+      Buffer2.prototype.writeUint32LE = Buffer2.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {
+        value = +value;
+        offset = offset >>> 0;
+        if (!noAssert)
+          checkInt(this, value, offset, 4, 4294967295, 0);
+        this[offset + 3] = value >>> 24;
+        this[offset + 2] = value >>> 16;
+        this[offset + 1] = value >>> 8;
+        this[offset] = value & 255;
+        return offset + 4;
+      };
+      Buffer2.prototype.writeUint32BE = Buffer2.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {
+        value = +value;
+        offset = offset >>> 0;
+        if (!noAssert)
+          checkInt(this, value, offset, 4, 4294967295, 0);
+        this[offset] = value >>> 24;
+        this[offset + 1] = value >>> 16;
+        this[offset + 2] = value >>> 8;
+        this[offset + 3] = value & 255;
+        return offset + 4;
+      };
+      Buffer2.prototype.writeIntLE = function writeIntLE(value, offset, byteLength2, noAssert) {
+        value = +value;
+        offset = offset >>> 0;
+        if (!noAssert) {
+          var limit = Math.pow(2, 8 * byteLength2 - 1);
+          checkInt(this, value, offset, byteLength2, limit - 1, -limit);
+        }
+        var i = 0;
+        var mul = 1;
+        var sub = 0;
+        this[offset] = value & 255;
+        while (++i < byteLength2 && (mul *= 256)) {
+          if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
+            sub = 1;
+          }
+          this[offset + i] = (value / mul >> 0) - sub & 255;
+        }
+        return offset + byteLength2;
+      };
+      Buffer2.prototype.writeIntBE = function writeIntBE(value, offset, byteLength2, noAssert) {
+        value = +value;
+        offset = offset >>> 0;
+        if (!noAssert) {
+          var limit = Math.pow(2, 8 * byteLength2 - 1);
+          checkInt(this, value, offset, byteLength2, limit - 1, -limit);
+        }
+        var i = byteLength2 - 1;
+        var mul = 1;
+        var sub = 0;
+        this[offset + i] = value & 255;
+        while (--i >= 0 && (mul *= 256)) {
+          if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
+            sub = 1;
+          }
+          this[offset + i] = (value / mul >> 0) - sub & 255;
+        }
+        return offset + byteLength2;
+      };
+      Buffer2.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {
+        value = +value;
+        offset = offset >>> 0;
+        if (!noAssert)
+          checkInt(this, value, offset, 1, 127, -128);
+        if (value < 0)
+          value = 255 + value + 1;
+        this[offset] = value & 255;
+        return offset + 1;
+      };
+      Buffer2.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) {
+        value = +value;
+        offset = offset >>> 0;
+        if (!noAssert)
+          checkInt(this, value, offset, 2, 32767, -32768);
+        this[offset] = value & 255;
+        this[offset + 1] = value >>> 8;
+        return offset + 2;
+      };
+      Buffer2.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) {
+        value = +value;
+        offset = offset >>> 0;
+        if (!noAssert)
+          checkInt(this, value, offset, 2, 32767, -32768);
+        this[offset] = value >>> 8;
+        this[offset + 1] = value & 255;
+        return offset + 2;
+      };
+      Buffer2.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) {
+        value = +value;
+        offset = offset >>> 0;
+        if (!noAssert)
+          checkInt(this, value, offset, 4, 2147483647, -2147483648);
+        this[offset] = value & 255;
+        this[offset + 1] = value >>> 8;
+        this[offset + 2] = value >>> 16;
+        this[offset + 3] = value >>> 24;
+        return offset + 4;
+      };
+      Buffer2.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) {
+        value = +value;
+        offset = offset >>> 0;
+        if (!noAssert)
+          checkInt(this, value, offset, 4, 2147483647, -2147483648);
+        if (value < 0)
+          value = 4294967295 + value + 1;
+        this[offset] = value >>> 24;
+        this[offset + 1] = value >>> 16;
+        this[offset + 2] = value >>> 8;
+        this[offset + 3] = value & 255;
+        return offset + 4;
+      };
+      function checkIEEE754(buf, value, offset, ext, max, min) {
+        if (offset + ext > buf.length)
+          throw new RangeError("Index out of range");
+        if (offset < 0)
+          throw new RangeError("Index out of range");
+      }
+      function writeFloat(buf, value, offset, littleEndian, noAssert) {
+        value = +value;
+        offset = offset >>> 0;
+        if (!noAssert) {
+          checkIEEE754(buf, value, offset, 4, 34028234663852886e22, -34028234663852886e22);
+        }
+        ieee754.write(buf, value, offset, littleEndian, 23, 4);
+        return offset + 4;
+      }
+      Buffer2.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {
+        return writeFloat(this, value, offset, true, noAssert);
+      };
+      Buffer2.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) {
+        return writeFloat(this, value, offset, false, noAssert);
+      };
+      function writeDouble(buf, value, offset, littleEndian, noAssert) {
+        value = +value;
+        offset = offset >>> 0;
+        if (!noAssert) {
+          checkIEEE754(buf, value, offset, 8, 17976931348623157e292, -17976931348623157e292);
+        }
+        ieee754.write(buf, value, offset, littleEndian, 52, 8);
+        return offset + 8;
+      }
+      Buffer2.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {
+        return writeDouble(this, value, offset, true, noAssert);
+      };
+      Buffer2.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {
+        return writeDouble(this, value, offset, false, noAssert);
+      };
+      Buffer2.prototype.copy = function copy(target, targetStart, start, end) {
+        if (!Buffer2.isBuffer(target))
+          throw new TypeError("argument should be a Buffer");
+        if (!start)
+          start = 0;
+        if (!end && end !== 0)
+          end = this.length;
+        if (targetStart >= target.length)
+          targetStart = target.length;
+        if (!targetStart)
+          targetStart = 0;
+        if (end > 0 && end < start)
+          end = start;
+        if (end === start)
+          return 0;
+        if (target.length === 0 || this.length === 0)
+          return 0;
+        if (targetStart < 0) {
+          throw new RangeError("targetStart out of bounds");
+        }
+        if (start < 0 || start >= this.length)
+          throw new RangeError("Index out of range");
+        if (end < 0)
+          throw new RangeError("sourceEnd out of bounds");
+        if (end > this.length)
+          end = this.length;
+        if (target.length - targetStart < end - start) {
+          end = target.length - targetStart + start;
+        }
+        var len = end - start;
+        if (this === target && typeof Uint8Array.prototype.copyWithin === "function") {
+          this.copyWithin(targetStart, start, end);
+        } else {
+          Uint8Array.prototype.set.call(target, this.subarray(start, end), targetStart);
+        }
+        return len;
+      };
+      Buffer2.prototype.fill = function fill(val, start, end, encoding) {
+        if (typeof val === "string") {
+          if (typeof start === "string") {
+            encoding = start;
+            start = 0;
+            end = this.length;
+          } else if (typeof end === "string") {
+            encoding = end;
+            end = this.length;
+          }
+          if (encoding !== void 0 && typeof encoding !== "string") {
+            throw new TypeError("encoding must be a string");
+          }
+          if (typeof encoding === "string" && !Buffer2.isEncoding(encoding)) {
+            throw new TypeError("Unknown encoding: " + encoding);
+          }
+          if (val.length === 1) {
+            var code = val.charCodeAt(0);
+            if (encoding === "utf8" && code < 128 || encoding === "latin1") {
+              val = code;
+            }
+          }
+        } else if (typeof val === "number") {
+          val = val & 255;
+        } else if (typeof val === "boolean") {
+          val = Number(val);
+        }
+        if (start < 0 || this.length < start || this.length < end) {
+          throw new RangeError("Out of range index");
+        }
+        if (end <= start) {
+          return this;
+        }
+        start = start >>> 0;
+        end = end === void 0 ? this.length : end >>> 0;
+        if (!val)
+          val = 0;
+        var i;
+        if (typeof val === "number") {
+          for (i = start; i < end; ++i) {
+            this[i] = val;
+          }
+        } else {
+          var bytes = Buffer2.isBuffer(val) ? val : Buffer2.from(val, encoding);
+          var len = bytes.length;
+          if (len === 0) {
+            throw new TypeError('The value "' + val + '" is invalid for argument "value"');
+          }
+          for (i = 0; i < end - start; ++i) {
+            this[i + start] = bytes[i % len];
+          }
+        }
+        return this;
+      };
+      var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;
+      function base64clean(str) {
+        str = str.split("=")[0];
+        str = str.trim().replace(INVALID_BASE64_RE, "");
+        if (str.length < 2)
+          return "";
+        while (str.length % 4 !== 0) {
+          str = str + "=";
+        }
+        return str;
+      }
+      function utf8ToBytes(string, units) {
+        units = units || Infinity;
+        var codePoint;
+        var length = string.length;
+        var leadSurrogate = null;
+        var bytes = [];
+        for (var i = 0; i < length; ++i) {
+          codePoint = string.charCodeAt(i);
+          if (codePoint > 55295 && codePoint < 57344) {
+            if (!leadSurrogate) {
+              if (codePoint > 56319) {
+                if ((units -= 3) > -1)
+                  bytes.push(239, 191, 189);
+                continue;
+              } else if (i + 1 === length) {
+                if ((units -= 3) > -1)
+                  bytes.push(239, 191, 189);
+                continue;
+              }
+              leadSurrogate = codePoint;
+              continue;
+            }
+            if (codePoint < 56320) {
+              if ((units -= 3) > -1)
+                bytes.push(239, 191, 189);
+              leadSurrogate = codePoint;
+              continue;
+            }
+            codePoint = (leadSurrogate - 55296 << 10 | codePoint - 56320) + 65536;
+          } else if (leadSurrogate) {
+            if ((units -= 3) > -1)
+              bytes.push(239, 191, 189);
+          }
+          leadSurrogate = null;
+          if (codePoint < 128) {
+            if ((units -= 1) < 0)
+              break;
+            bytes.push(codePoint);
+          } else if (codePoint < 2048) {
+            if ((units -= 2) < 0)
+              break;
+            bytes.push(codePoint >> 6 | 192, codePoint & 63 | 128);
+          } else if (codePoint < 65536) {
+            if ((units -= 3) < 0)
+              break;
+            bytes.push(codePoint >> 12 | 224, codePoint >> 6 & 63 | 128, codePoint & 63 | 128);
+          } else if (codePoint < 1114112) {
+            if ((units -= 4) < 0)
+              break;
+            bytes.push(codePoint >> 18 | 240, codePoint >> 12 & 63 | 128, codePoint >> 6 & 63 | 128, codePoint & 63 | 128);
+          } else {
+            throw new Error("Invalid code point");
+          }
+        }
+        return bytes;
+      }
+      function asciiToBytes(str) {
+        var byteArray = [];
+        for (var i = 0; i < str.length; ++i) {
+          byteArray.push(str.charCodeAt(i) & 255);
+        }
+        return byteArray;
+      }
+      function utf16leToBytes(str, units) {
+        var c, hi, lo;
+        var byteArray = [];
+        for (var i = 0; i < str.length; ++i) {
+          if ((units -= 2) < 0)
+            break;
+          c = str.charCodeAt(i);
+          hi = c >> 8;
+          lo = c % 256;
+          byteArray.push(lo);
+          byteArray.push(hi);
+        }
+        return byteArray;
+      }
+      function base64ToBytes(str) {
+        return base64.toByteArray(base64clean(str));
+      }
+      function blitBuffer(src, dst, offset, length) {
+        for (var i = 0; i < length; ++i) {
+          if (i + offset >= dst.length || i >= src.length)
+            break;
+          dst[i + offset] = src[i];
+        }
+        return i;
+      }
+      function isInstance(obj, type) {
+        return obj instanceof type || obj != null && obj.constructor != null && obj.constructor.name != null && obj.constructor.name === type.name;
+      }
+      function numberIsNaN(obj) {
+        return obj !== obj;
+      }
+      var hexSliceLookupTable = function() {
+        var alphabet = "0123456789abcdef";
+        var table = new Array(256);
+        for (var i = 0; i < 16; ++i) {
+          var i16 = i * 16;
+          for (var j = 0; j < 16; ++j) {
+            table[i16 + j] = alphabet[i] + alphabet[j];
+          }
+        }
+        return table;
+      }();
+    }
+  });
+
+  // ../../node_modules/core-assert/index.js
+  var require_core_assert = __commonJS({
+    "../../node_modules/core-assert/index.js"(exports, module) {
+      "use strict";
+      function isPrimitive(arg) {
+        return arg === null || typeof arg !== "object" && typeof arg !== "function";
+      }
+      var compare = require_buf_compare();
+      var isError = require_is_error();
+      var util = require_util2();
+      var Buffer2 = require_buffer().Buffer;
+      var pSlice = Array.prototype.slice;
+      var assert2 = module.exports = ok;
+      assert2.AssertionError = function AssertionError(options) {
+        this.name = "AssertionError";
+        this.actual = options.actual;
+        this.expected = options.expected;
+        this.operator = options.operator;
+        if (options.message) {
+          this.message = options.message;
+          this.generatedMessage = false;
+        } else {
+          this.message = getMessage(this);
+          this.generatedMessage = true;
+        }
+        var stackStartFunction = options.stackStartFunction || fail;
+        Error.captureStackTrace(this, stackStartFunction);
+      };
+      util.inherits(assert2.AssertionError, Error);
+      function truncate(s, n) {
+        if (typeof s === "string") {
+          return s.length < n ? s : s.slice(0, n);
+        } else {
+          return s;
+        }
+      }
+      function getMessage(self2) {
+        return truncate(util.inspect(self2.actual), 128) + " " + self2.operator + " " + truncate(util.inspect(self2.expected), 128);
+      }
+      function fail(actual, expected, message, operator, stackStartFunction) {
+        throw new assert2.AssertionError({
+          message,
+          actual,
+          expected,
+          operator,
+          stackStartFunction
+        });
+      }
+      assert2.fail = fail;
+      function ok(value, message) {
+        if (!value)
+          fail(value, true, message, "==", assert2.ok);
+      }
+      assert2.ok = ok;
+      assert2.equal = function equal(actual, expected, message) {
+        if (actual != expected)
+          fail(actual, expected, message, "==", assert2.equal);
+      };
+      assert2.notEqual = function notEqual(actual, expected, message) {
+        if (actual == expected) {
+          fail(actual, expected, message, "!=", assert2.notEqual);
+        }
+      };
+      assert2.deepEqual = function deepEqual(actual, expected, message) {
+        if (!_deepEqual(actual, expected, false)) {
+          fail(actual, expected, message, "deepEqual", assert2.deepEqual);
+        }
+      };
+      assert2.deepStrictEqual = function deepStrictEqual2(actual, expected, message) {
+        if (!_deepEqual(actual, expected, true)) {
+          fail(actual, expected, message, "deepStrictEqual", assert2.deepStrictEqual);
+        }
+      };
+      function _deepEqual(actual, expected, strict) {
+        if (actual === expected) {
+          return true;
+        } else if (actual instanceof Buffer2 && expected instanceof Buffer2) {
+          return compare(actual, expected) === 0;
+        } else if (util.isDate(actual) && util.isDate(expected)) {
+          return actual.getTime() === expected.getTime();
+        } else if (util.isRegExp(actual) && util.isRegExp(expected)) {
+          return actual.source === expected.source && actual.global === expected.global && actual.multiline === expected.multiline && actual.lastIndex === expected.lastIndex && actual.ignoreCase === expected.ignoreCase;
+        } else if ((actual === null || typeof actual !== "object") && (expected === null || typeof expected !== "object")) {
+          return strict ? actual === expected : actual == expected;
+        } else {
+          return objEquiv(actual, expected, strict);
+        }
+      }
+      function isArguments(object) {
+        return Object.prototype.toString.call(object) == "[object Arguments]";
+      }
+      function objEquiv(a, b, strict) {
+        if (a === null || a === void 0 || b === null || b === void 0)
+          return false;
+        if (isPrimitive(a) || isPrimitive(b))
+          return a === b;
+        if (strict && Object.getPrototypeOf(a) !== Object.getPrototypeOf(b))
+          return false;
+        var aIsArgs = isArguments(a), bIsArgs = isArguments(b);
+        if (aIsArgs && !bIsArgs || !aIsArgs && bIsArgs)
+          return false;
+        if (aIsArgs) {
+          a = pSlice.call(a);
+          b = pSlice.call(b);
+          return _deepEqual(a, b, strict);
+        }
+        var ka = Object.keys(a), kb = Object.keys(b), key, i;
+        if (ka.length !== kb.length)
+          return false;
+        ka.sort();
+        kb.sort();
+        for (i = ka.length - 1; i >= 0; i--) {
+          if (ka[i] !== kb[i])
+            return false;
+        }
+        for (i = ka.length - 1; i >= 0; i--) {
+          key = ka[i];
+          if (!_deepEqual(a[key], b[key], strict))
+            return false;
+        }
+        return true;
+      }
+      assert2.notDeepEqual = function notDeepEqual(actual, expected, message) {
+        if (_deepEqual(actual, expected, false)) {
+          fail(actual, expected, message, "notDeepEqual", assert2.notDeepEqual);
+        }
+      };
+      assert2.notDeepStrictEqual = notDeepStrictEqual;
+      function notDeepStrictEqual(actual, expected, message) {
+        if (_deepEqual(actual, expected, true)) {
+          fail(actual, expected, message, "notDeepStrictEqual", notDeepStrictEqual);
+        }
+      }
+      assert2.strictEqual = function strictEqual(actual, expected, message) {
+        if (actual !== expected) {
+          fail(actual, expected, message, "===", assert2.strictEqual);
+        }
+      };
+      assert2.notStrictEqual = function notStrictEqual(actual, expected, message) {
+        if (actual === expected) {
+          fail(actual, expected, message, "!==", assert2.notStrictEqual);
+        }
+      };
+      function expectedException(actual, expected) {
+        if (!actual || !expected) {
+          return false;
+        }
+        if (Object.prototype.toString.call(expected) == "[object RegExp]") {
+          return expected.test(actual);
+        }
+        try {
+          if (actual instanceof expected) {
+            return true;
+          }
+        } catch (e) {
+        }
+        if (Error.isPrototypeOf && Error.isPrototypeOf(expected)) {
+          return false;
+        }
+        return expected.call({}, actual) === true;
+      }
+      function _tryBlock(block) {
+        var error;
+        try {
+          block();
+        } catch (e) {
+          error = e;
+        }
+        return error;
+      }
+      function _throws(shouldThrow, block, expected, message) {
+        var actual;
+        if (typeof block !== "function") {
+          throw new TypeError('"block" argument must be a function');
+        }
+        if (typeof expected === "string") {
+          message = expected;
+          expected = null;
+        }
+        actual = _tryBlock(block);
+        message = (expected && expected.name ? " (" + expected.name + ")." : ".") + (message ? " " + message : ".");
+        if (shouldThrow && !actual) {
+          fail(actual, expected, "Missing expected exception" + message);
+        }
+        var userProvidedMessage = typeof message === "string";
+        var isUnwantedException = !shouldThrow && isError(actual);
+        var isUnexpectedException = !shouldThrow && actual && !expected;
+        if (isUnwantedException && userProvidedMessage && expectedException(actual, expected) || isUnexpectedException) {
+          fail(actual, expected, "Got unwanted exception" + message);
+        }
+        if (shouldThrow && actual && expected && !expectedException(actual, expected) || !shouldThrow && actual) {
+          throw actual;
+        }
+      }
+      assert2.throws = function(block, error, message) {
+        _throws(true, block, error, message);
+      };
+      assert2.doesNotThrow = function(block, error, message) {
+        _throws(false, block, error, message);
+      };
+      assert2.ifError = function(err) {
+        if (err)
+          throw err;
+      };
+      Object.defineProperty(assert2, "__deepEqual", { value: _deepEqual });
+    }
+  });
+
+  // ../../node_modules/deep-strict-equal/index.js
+  var require_deep_strict_equal = __commonJS({
+    "../../node_modules/deep-strict-equal/index.js"(exports, module) {
+      "use strict";
+      var __deepEqual = require_core_assert().__deepEqual;
+      module.exports = function(a, b) {
+        return __deepEqual(a, b, true);
+      };
+    }
+  });
+
+  // ../../node_modules/@turf/clone/main.es.js
+  function clone(geojson) {
+    if (!geojson)
+      throw new Error("geojson is required");
+    switch (geojson.type) {
+      case "Feature":
+        return cloneFeature(geojson);
+      case "FeatureCollection":
+        return cloneFeatureCollection(geojson);
+      case "Point":
+      case "LineString":
+      case "Polygon":
+      case "MultiPoint":
+      case "MultiLineString":
+      case "MultiPolygon":
+      case "GeometryCollection":
+        return cloneGeometry(geojson);
+      default:
+        throw new Error("unknown GeoJSON type");
+    }
+  }
+  function cloneFeature(geojson) {
+    var cloned = { type: "Feature" };
+    Object.keys(geojson).forEach(function(key) {
+      switch (key) {
+        case "type":
+        case "properties":
+        case "geometry":
+          return;
+        default:
+          cloned[key] = geojson[key];
+      }
+    });
+    cloned.properties = cloneProperties(geojson.properties);
+    cloned.geometry = cloneGeometry(geojson.geometry);
+    return cloned;
+  }
+  function cloneProperties(properties) {
+    var cloned = {};
+    if (!properties)
+      return cloned;
+    Object.keys(properties).forEach(function(key) {
+      var value = properties[key];
+      if (typeof value === "object") {
+        if (value === null) {
+          cloned[key] = null;
+        } else if (value.length) {
+          cloned[key] = value.map(function(item) {
+            return item;
+          });
+        } else {
+          cloned[key] = cloneProperties(value);
+        }
+      } else
+        cloned[key] = value;
+    });
+    return cloned;
+  }
+  function cloneFeatureCollection(geojson) {
+    var cloned = { type: "FeatureCollection" };
+    Object.keys(geojson).forEach(function(key) {
+      switch (key) {
+        case "type":
+        case "features":
+          return;
+        default:
+          cloned[key] = geojson[key];
+      }
+    });
+    cloned.features = geojson.features.map(function(feature2) {
+      return cloneFeature(feature2);
+    });
+    return cloned;
+  }
+  function cloneGeometry(geometry) {
+    var geom = { type: geometry.type };
+    if (geometry.bbox)
+      geom.bbox = geometry.bbox;
+    if (geometry.type === "GeometryCollection") {
+      geom.geometries = geometry.geometries.map(function(geom2) {
+        return cloneGeometry(geom2);
+      });
+      return geom;
+    }
+    geom.coordinates = deepSlice(geometry.coordinates);
+    return geom;
+  }
+  function deepSlice(coords) {
+    if (typeof coords[0] !== "object") {
+      return coords.slice();
+    }
+    return coords.map(function(coord) {
+      return deepSlice(coord);
+    });
+  }
+  var main_es_default;
+  var init_main_es = __esm({
+    "../../node_modules/@turf/clone/main.es.js"() {
+      main_es_default = clone;
+    }
+  });
+
+  // ../../node_modules/@turf/helpers/main.es.js
+  function featureCollection(features, options) {
+    options = options || {};
+    if (!isObject(options))
+      throw new Error("options is invalid");
+    var bbox = options.bbox;
+    var id = options.id;
+    if (!features)
+      throw new Error("No features passed");
+    if (!Array.isArray(features))
+      throw new Error("features must be an Array");
+    if (bbox)
+      validateBBox(bbox);
+    if (id)
+      validateId(id);
+    var fc = { type: "FeatureCollection" };
+    if (id)
+      fc.id = id;
+    if (bbox)
+      fc.bbox = bbox;
+    fc.features = features;
+    return fc;
+  }
+  function isNumber(num) {
+    return !isNaN(num) && num !== null && !Array.isArray(num);
+  }
+  function isObject(input) {
+    return !!input && input.constructor === Object;
+  }
+  function validateBBox(bbox) {
+    if (!bbox)
+      throw new Error("bbox is required");
+    if (!Array.isArray(bbox))
+      throw new Error("bbox must be an Array");
+    if (bbox.length !== 4 && bbox.length !== 6)
+      throw new Error("bbox must be an Array of 4 or 6 numbers");
+    bbox.forEach(function(num) {
+      if (!isNumber(num))
+        throw new Error("bbox must only contain numbers");
+    });
+  }
+  function validateId(id) {
+    if (!id)
+      throw new Error("id is required");
+    if (["string", "number"].indexOf(typeof id) === -1)
+      throw new Error("id must be a number or a string");
+  }
+  var earthRadius, factors, unitsFactors;
+  var init_main_es2 = __esm({
+    "../../node_modules/@turf/helpers/main.es.js"() {
+      earthRadius = 63710088e-1;
+      factors = {
+        meters: earthRadius,
+        metres: earthRadius,
+        millimeters: earthRadius * 1e3,
+        millimetres: earthRadius * 1e3,
+        centimeters: earthRadius * 100,
+        centimetres: earthRadius * 100,
+        kilometers: earthRadius / 1e3,
+        kilometres: earthRadius / 1e3,
+        miles: earthRadius / 1609.344,
+        nauticalmiles: earthRadius / 1852,
+        inches: earthRadius * 39.37,
+        yards: earthRadius / 1.0936,
+        feet: earthRadius * 3.28084,
+        radians: 1,
+        degrees: earthRadius / 111325
+      };
+      unitsFactors = {
+        meters: 1,
+        metres: 1,
+        millimeters: 1e3,
+        millimetres: 1e3,
+        centimeters: 100,
+        centimetres: 100,
+        kilometers: 1 / 1e3,
+        kilometres: 1 / 1e3,
+        miles: 1 / 1609.344,
+        nauticalmiles: 1 / 1852,
+        inches: 39.37,
+        yards: 1 / 1.0936,
+        feet: 3.28084,
+        radians: 1 / earthRadius,
+        degrees: 1 / 111325
+      };
+    }
+  });
+
+  // ../../node_modules/@turf/invariant/main.es.js
+  function getCoords(coords) {
+    if (!coords)
+      throw new Error("coords is required");
+    if (coords.type === "Feature" && coords.geometry !== null)
+      return coords.geometry.coordinates;
+    if (coords.coordinates)
+      return coords.coordinates;
+    if (Array.isArray(coords))
+      return coords;
+    throw new Error("coords must be GeoJSON Feature, Geometry Object or an Array");
+  }
+  var init_main_es3 = __esm({
+    "../../node_modules/@turf/invariant/main.es.js"() {
+      init_main_es2();
+    }
+  });
+
+  // ../../node_modules/@turf/boolean-clockwise/main.es.js
+  function booleanClockwise(line) {
+    if (!line)
+      throw new Error("line is required");
+    var type = line.geometry ? line.geometry.type : line.type;
+    if (!Array.isArray(line) && type !== "LineString")
+      throw new Error("geometry must be a LineString");
+    var ring = getCoords(line);
+    var sum = 0;
+    var i = 1;
+    var prev, cur;
+    while (i < ring.length) {
+      prev = cur || ring[0];
+      cur = ring[i];
+      sum += (cur[0] - prev[0]) * (cur[1] + prev[1]);
+      i++;
+    }
+    return sum > 0;
+  }
+  var main_es_default2;
+  var init_main_es4 = __esm({
+    "../../node_modules/@turf/boolean-clockwise/main.es.js"() {
+      init_main_es3();
+      main_es_default2 = booleanClockwise;
+    }
+  });
+
+  // ../../node_modules/@turf/meta/main.es.js
+  function featureEach(geojson, callback) {
+    if (geojson.type === "Feature") {
+      callback(geojson, 0);
+    } else if (geojson.type === "FeatureCollection") {
+      for (var i = 0; i < geojson.features.length; i++) {
+        if (callback(geojson.features[i], i) === false)
+          break;
+      }
+    }
+  }
+  function geomEach(geojson, callback) {
+    var i, j, g, geometry, stopG, geometryMaybeCollection, isGeometryCollection, featureProperties, featureBBox, featureId, featureIndex = 0, isFeatureCollection = geojson.type === "FeatureCollection", isFeature = geojson.type === "Feature", stop = isFeatureCollection ? geojson.features.length : 1;
+    for (i = 0; i < stop; i++) {
+      geometryMaybeCollection = isFeatureCollection ? geojson.features[i].geometry : isFeature ? geojson.geometry : geojson;
+      featureProperties = isFeatureCollection ? geojson.features[i].properties : isFeature ? geojson.properties : {};
+      featureBBox = isFeatureCollection ? geojson.features[i].bbox : isFeature ? geojson.bbox : void 0;
+      featureId = isFeatureCollection ? geojson.features[i].id : isFeature ? geojson.id : void 0;
+      isGeometryCollection = geometryMaybeCollection ? geometryMaybeCollection.type === "GeometryCollection" : false;
+      stopG = isGeometryCollection ? geometryMaybeCollection.geometries.length : 1;
+      for (g = 0; g < stopG; g++) {
+        geometry = isGeometryCollection ? geometryMaybeCollection.geometries[g] : geometryMaybeCollection;
+        if (geometry === null) {
+          if (callback(null, featureIndex, featureProperties, featureBBox, featureId) === false)
+            return false;
+          continue;
+        }
+        switch (geometry.type) {
+          case "Point":
+          case "LineString":
+          case "MultiPoint":
+          case "Polygon":
+          case "MultiLineString":
+          case "MultiPolygon": {
+            if (callback(geometry, featureIndex, featureProperties, featureBBox, featureId) === false)
+              return false;
+            break;
+          }
+          case "GeometryCollection": {
+            for (j = 0; j < geometry.geometries.length; j++) {
+              if (callback(geometry.geometries[j], featureIndex, featureProperties, featureBBox, featureId) === false)
+                return false;
+            }
+            break;
+          }
+          default:
+            throw new Error("Unknown Geometry Type");
+        }
+      }
+      featureIndex++;
+    }
+  }
+  var init_main_es5 = __esm({
+    "../../node_modules/@turf/meta/main.es.js"() {
+      init_main_es2();
+    }
+  });
+
+  // ../../node_modules/@turf/rewind/main.es.js
+  function rewind(geojson, options) {
+    options = options || {};
+    if (!isObject(options))
+      throw new Error("options is invalid");
+    var reverse = options.reverse || false;
+    var mutate = options.mutate || false;
+    if (!geojson)
+      throw new Error("<geojson> is required");
+    if (typeof reverse !== "boolean")
+      throw new Error("<reverse> must be a boolean");
+    if (typeof mutate !== "boolean")
+      throw new Error("<mutate> must be a boolean");
+    if (mutate === false)
+      geojson = main_es_default(geojson);
+    var results = [];
+    switch (geojson.type) {
+      case "GeometryCollection":
+        geomEach(geojson, function(geometry) {
+          rewindFeature(geometry, reverse);
+        });
+        return geojson;
+      case "FeatureCollection":
+        featureEach(geojson, function(feature2) {
+          featureEach(rewindFeature(feature2, reverse), function(result) {
+            results.push(result);
+          });
+        });
+        return featureCollection(results);
+    }
+    return rewindFeature(geojson, reverse);
+  }
+  function rewindFeature(geojson, reverse) {
+    var type = geojson.type === "Feature" ? geojson.geometry.type : geojson.type;
+    switch (type) {
+      case "GeometryCollection":
+        geomEach(geojson, function(geometry) {
+          rewindFeature(geometry, reverse);
+        });
+        return geojson;
+      case "LineString":
+        rewindLineString(getCoords(geojson), reverse);
+        return geojson;
+      case "Polygon":
+        rewindPolygon(getCoords(geojson), reverse);
+        return geojson;
+      case "MultiLineString":
+        getCoords(geojson).forEach(function(lineCoords) {
+          rewindLineString(lineCoords, reverse);
+        });
+        return geojson;
+      case "MultiPolygon":
+        getCoords(geojson).forEach(function(lineCoords) {
+          rewindPolygon(lineCoords, reverse);
+        });
+        return geojson;
+      case "Point":
+      case "MultiPoint":
+        return geojson;
+    }
+  }
+  function rewindLineString(coords, reverse) {
+    if (main_es_default2(coords) === reverse)
+      coords.reverse();
+  }
+  function rewindPolygon(coords, reverse) {
+    if (main_es_default2(coords[0]) !== reverse) {
+      coords[0].reverse();
+    }
+    for (var i = 1; i < coords.length; i++) {
+      if (main_es_default2(coords[i]) === reverse) {
+        coords[i].reverse();
+      }
+    }
+  }
+  var main_es_default3;
+  var init_main_es6 = __esm({
+    "../../node_modules/@turf/rewind/main.es.js"() {
+      init_main_es();
+      init_main_es4();
+      init_main_es5();
+      init_main_es3();
+      init_main_es2();
+      main_es_default3 = rewind;
+    }
+  });
+
+  // src/lib/gml/parse-gml.ts
+  function noTransform(...coords) {
+    return coords;
+  }
+  function parseGML(text, options) {
+    const parsedXML = XMLLoader.parseTextSync(text, options);
+    options = { transformCoords: noTransform, stride: 2, ...options };
+    const context = createChildContext(parsedXML, options, {});
+    return parseGMLToGeometry(parsedXML, options, context);
+  }
+  function parseGMLToGeometry(inputXML, options, context) {
+    const childContext = createChildContext(inputXML, options, context);
+    let geometry = null;
+    const [name, xml] = getFirstKeyValue(inputXML);
+    switch (name) {
+      case "gml:LineString":
+        geometry = {
+          type: "LineString",
+          coordinates: parseLinearRingOrLineString(xml, options, childContext)
+        };
+        break;
+      case "gml:Polygon":
+      case "gml:Rectangle":
+        geometry = {
+          type: "Polygon",
+          coordinates: parsePolygonOrRectangle(xml, options, childContext)
+        };
+        break;
+      case "gml:Surface":
+        geometry = {
+          type: "MultiPolygon",
+          coordinates: parseSurface(xml, options, childContext)
+        };
+        break;
+      case "gml:MultiSurface":
+        geometry = {
+          type: "MultiPolygon",
+          coordinates: parseMultiSurface(xml, options, childContext)
+        };
+        break;
+      default:
+        return null;
+    }
+    return main_es_default3(geometry, { mutate: true });
+  }
+  function parseCoords(s, options, context) {
+    const stride = context.srsDimension || options.stride || 2;
+    const coords = s.replace(/\s+/g, " ").trim().split(" ");
+    if (coords.length === 0 || coords.length % stride !== 0) {
+      throw new Error(`invalid coordinates list (stride ${stride})`);
+    }
+    const points = [];
+    for (let i = 0; i < coords.length - 1; i += stride) {
+      const point2 = coords.slice(i, i + stride).map(parseFloat);
+      points.push(options.transformCoords?.(...point2) || point2);
+    }
+    return points;
+  }
+  function parsePosList(xml, options, context) {
+    const childContext = createChildContext(xml, options, context);
+    const coords = textOf(xml);
+    if (!coords) {
+      throw new Error("invalid gml:posList element");
+    }
+    return parseCoords(coords, options, childContext);
+  }
+  function parsePos(xml, options, context) {
+    const childContext = createChildContext(xml, options, context);
+    const coords = textOf(xml);
+    if (!coords) {
+      throw new Error("invalid gml:pos element");
+    }
+    const points = parseCoords(coords, options, childContext);
+    if (points.length !== 1) {
+      throw new Error("gml:pos must have 1 point");
+    }
+    return points[0];
+  }
+  function parsePoint(xml, options, context) {
+    const childContext = createChildContext(xml, options, context);
+    const pos = findIn(xml, "gml:pos");
+    if (!pos) {
+      throw new Error("invalid gml:Point element, expected a gml:pos subelement");
+    }
+    return parsePos(pos, options, childContext);
+  }
+  function parseLinearRingOrLineString(xml, options, context) {
+    const childContext = createChildContext(xml, options, context);
+    let points = [];
+    const posList = findIn(xml, "gml:posList");
+    if (posList) {
+      points = parsePosList(posList, options, childContext);
+    } else {
+      for (const [childName, childXML] of Object.entries(xml)) {
+        switch (childName) {
+          case "gml:Point":
+            points.push(parsePoint(childXML, options, childContext));
+            break;
+          case "gml:pos":
+            points.push(parsePos(childXML, options, childContext));
+            break;
+          default:
+            continue;
+        }
+      }
+    }
+    if (points.length === 0) {
+      throw new Error(`${xml.name} must have > 0 points`);
+    }
+    return points;
+  }
+  function parseCurveSegments(xml, options, context) {
+    const points = [];
+    for (const [childName, childXML] of Object.entries(xml)) {
+      switch (childName) {
+        case "gml:LineStringSegment":
+          const points2 = parseLinearRingOrLineString(childXML, options, context);
+          const end = points[points.length - 1];
+          const start = points2[0];
+          if (end && start && (0, import_deep_strict_equal.default)(end, start)) {
+            points2.shift();
+          }
+          points.push(...points2);
+          break;
+        default:
+          continue;
+      }
+    }
+    if (points.length === 0) {
+      throw new Error("gml:Curve > gml:segments must have > 0 points");
+    }
+    return points;
+  }
+  function parseRing(xml, options, context) {
+    const childContext = createChildContext(xml, options, context);
+    const points = [];
+    for (const [childName, childXML] of Object.entries(xml)) {
+      switch (childName) {
+        case "gml:curveMember":
+          let points2;
+          const lineString2 = findIn(childXML, "gml:LineString");
+          if (lineString2) {
+            points2 = parseLinearRingOrLineString(lineString2, options, childContext);
+          } else {
+            const segments = findIn(childXML, "gml:Curve", "gml:segments");
+            if (!segments) {
+              throw new Error(`invalid ${childName} element`);
+            }
+            points2 = parseCurveSegments(segments, options, childContext);
+          }
+          const end = points[points.length - 1];
+          const start = points2[0];
+          if (end && start && (0, import_deep_strict_equal.default)(end, start)) {
+            points2.shift();
+          }
+          points.push(...points2);
+          break;
+      }
+    }
+    if (points.length < 4) {
+      throw new Error(`${xml.name} must have >= 4 points`);
+    }
+    return points;
+  }
+  function parseExteriorOrInterior(xml, options, context) {
+    const linearRing = findIn(xml, "gml:LinearRing");
+    if (linearRing) {
+      return parseLinearRingOrLineString(linearRing, options, context);
+    }
+    const ring = findIn(xml, "gml:Ring");
+    if (!ring) {
+      throw new Error(`invalid ${xml.name} element`);
+    }
+    return parseRing(ring, options, context);
+  }
+  function parsePolygonOrRectangle(xml, options, context) {
+    const childContext = createChildContext(xml, options, context);
+    const exterior = findIn(xml, "gml:exterior");
+    if (!exterior) {
+      throw new Error(`invalid ${xml.name} element`);
+    }
+    const pointLists = [parseExteriorOrInterior(exterior, options, childContext)];
+    for (const [childName, childXML] of Object.entries(xml)) {
+      switch (childName) {
+        case "gml:interior":
+          pointLists.push(parseExteriorOrInterior(childXML, options, childContext));
+          break;
+      }
+    }
+    return pointLists;
+  }
+  function parseSurface(xml, options, context) {
+    const childContext = createChildContext(xml, options, context);
+    const patches = findIn(xml, "gml:patches");
+    if (!patches) {
+      throw new Error(`invalid ${xml.name} element`);
+    }
+    const polygons = [];
+    for (const [childName, childXML] of Object.entries(xml)) {
+      switch (childName) {
+        case "gml:PolygonPatch":
+        case "gml:Rectangle":
+          polygons.push(parsePolygonOrRectangle(childXML, options, childContext));
+          break;
+        default:
+          continue;
+      }
+    }
+    if (polygons.length === 0) {
+      throw new Error(`${xml.name} must have > 0 polygons`);
+    }
+    return polygons;
+  }
+  function parseCompositeSurface(xml, options, context) {
+    const childContext = createChildContext(xml, options, context);
+    const polygons = [];
+    for (const [childName, childXML] of Object.entries(xml)) {
+      switch (childName) {
+        case "gml:surfaceMember":
+        case "gml:surfaceMembers":
+          const [c2Name, c2Xml] = getFirstKeyValue(childXML);
+          switch (c2Name) {
+            case "gml:Surface":
+              polygons.push(...parseSurface(c2Xml, options, childContext));
+              break;
+            case "gml:Polygon":
+              polygons.push(parsePolygonOrRectangle(c2Xml, options, childContext));
+              break;
+          }
+          break;
+      }
+    }
+    if (polygons.length === 0) {
+      throw new Error(`${xml.name} must have > 0 polygons`);
+    }
+    return polygons;
+  }
+  function parseMultiSurface(xml, options, context) {
+    let el = xml;
+    const surfaceMembers = findIn(xml, "gml:LinearRing");
+    if (surfaceMembers) {
+      el = surfaceMembers;
+    }
+    const polygons = [];
+    for (const [childName, childXML] of Object.entries(el)) {
+      switch (childName) {
+        case "gml:Surface":
+          const polygons2 = parseSurface(childXML, options, context);
+          polygons.push(...polygons2);
+          break;
+        case "gml:surfaceMember":
+          const polygons3 = parseSurfaceMember(childXML, options, context);
+          polygons.push(...polygons3);
+          break;
+        case "gml:surfaceMembers":
+          const polygonXML = findIn(childXML, "gml:Polygon");
+          for (const surfaceMemberXML of polygonXML) {
+            const polygons32 = parseSurfaceMember(surfaceMemberXML, options, context);
+            polygons.push(...polygons32);
+          }
+          break;
+      }
+    }
+    if (polygons.length === 0) {
+      throw new Error(`${xml.name} must have > 0 polygons`);
+    }
+    return polygons;
+  }
+  function parseSurfaceMember(xml, options, context) {
+    const [childName, childXml] = getFirstKeyValue(xml);
+    switch (childName) {
+      case "gml:CompositeSurface":
+        return parseCompositeSurface(childXml, options, context);
+      case "gml:Surface":
+        return parseSurface(childXml, options, context);
+      case "gml:Polygon":
+        return [parsePolygonOrRectangle(childXml, options, context)];
+    }
+    throw new Error(`${childName} must have polygons`);
+  }
+  function textOf(el) {
+    if (typeof el !== "string") {
+      throw new Error("expected string");
+    }
+    return el;
+  }
+  function findIn(root, ...tags) {
+    let el = root;
+    for (const tag of tags) {
+      const child = el[tag];
+      if (!child) {
+        return null;
+      }
+      el = child;
+    }
+    return el;
+  }
+  function getFirstKeyValue(object) {
+    if (object && typeof object === "object") {
+      for (const [key, value] of Object.entries(object)) {
+        return [key, value];
+      }
+    }
+    return ["", null];
+  }
+  function createChildContext(xml, options, context) {
+    const srsDimensionAttribute = xml.attributes && xml.attributes.srsDimension;
+    if (srsDimensionAttribute) {
+      const srsDimension = parseInt(srsDimensionAttribute);
+      if (Number.isNaN(srsDimension) || srsDimension <= 0) {
+        throw new Error(`invalid srsDimension attribute value "${srsDimensionAttribute}", expected a positive integer`);
+      }
+      const childContext = Object.create(context);
+      childContext.srsDimension = srsDimension;
+      return childContext;
+    }
+    return context;
+  }
+  var import_deep_strict_equal;
+  var init_parse_gml = __esm({
+    "src/lib/gml/parse-gml.ts"() {
+      init_src();
+      import_deep_strict_equal = __toModule(require_deep_strict_equal());
+      init_main_es6();
+    }
+  });
+
+  // src/gml-loader.ts
+  function testXMLFile6(text) {
+    return text.startsWith("<?xml");
+  }
+  var VERSION7, GMLLoader;
+  var init_gml_loader = __esm({
+    "src/gml-loader.ts"() {
+      init_parse_gml();
+      VERSION7 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      GMLLoader = {
+        name: "GML",
+        id: "gml",
+        module: "wms",
+        version: VERSION7,
+        worker: false,
+        extensions: ["xml"],
+        mimeTypes: ["application/vnd.ogc.gml_xml", "application/xml", "text/xml"],
+        testText: testXMLFile6,
+        options: {
+          gml: {}
+        },
+        parse: async (arrayBuffer, options) => parseGML(new TextDecoder().decode(arrayBuffer), options),
+        parseTextSync: (text, options) => parseGML(text, options)
       };
     }
   });
@@ -2251,17 +5690,25 @@
   // src/index.ts
   var src_exports = {};
   __export(src_exports, {
+    GMLLoader: () => GMLLoader,
+    WFSCapabilitiesLoader: () => WFSCapabilitiesLoader,
     WMSCapabilitiesLoader: () => WMSCapabilitiesLoader,
+    WMSErrorLoader: () => WMSErrorLoader,
     WMSFeatureInfoLoader: () => WMSFeatureInfoLoader,
     WMSLayerDescriptionLoader: () => WMSLayerDescriptionLoader,
-    _WMSDataSource: () => WMSDataSource
+    WMSService: () => WMSService,
+    WMTSCapabilitiesLoader: () => WMTSCapabilitiesLoader
   });
   var init_src4 = __esm({
     "src/index.ts"() {
+      init_wms_error_loader();
       init_wms_capabilities_loader();
       init_wms_feature_info_loader();
       init_wms_layer_description_loader();
-      init_wms_data_source();
+      init_wms_service();
+      init_wfs_capabilities_loader();
+      init_wmts_capabilities_loader();
+      init_gml_loader();
     }
   });
 
@@ -2275,3 +5722,10 @@
   });
   require_bundle();
 })();
+/*!
+ * The buffer module from node.js, for the browser.
+ *
+ * @author   Feross Aboukhadijeh <https://feross.org>
+ * @license  MIT
+ */
+/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */