(self.webpackChunkRemoteClient = self.webpackChunkRemoteClient || []).push([
  [4344],
  {
    78986: (e, t, n) => {
      'use strict';
      function r() {
        r = function (e, t) {
          return new n(e, void 0, t);
        };
        var e = RegExp.prototype,
          t = new WeakMap();
        function n(e, r, o) {
          var a = new RegExp(e, r);
          return t.set(a, o || t.get(e)), i(a, n.prototype);
        }
        function a(e, n) {
          var r = t.get(n);
          return Object.keys(r).reduce(function (t, n) {
            return (t[n] = e[r[n]]), t;
          }, Object.create(null));
        }
        return (
          o(n, RegExp),
          (n.prototype.exec = function (t) {
            var n = e.exec.call(this, t);
            return n && (n.groups = a(n, this)), n;
          }),
          (n.prototype[Symbol.replace] = function (n, r) {
            if ('string' == typeof r) {
              var o = t.get(this);
              return e[Symbol.replace].call(
                this,
                n,
                r.replace(/\$<([^>]+)>/g, function (e, t) {
                  return '$' + o[t];
                }),
              );
            }
            if ('function' == typeof r) {
              var i = this;
              return e[Symbol.replace].call(this, n, function () {
                var e = arguments;
                return (
                  'object' != typeof e[e.length - 1] && (e = [].slice.call(e)).push(a(e, i)),
                  r.apply(this, e)
                );
              });
            }
            return e[Symbol.replace].call(this, n, r);
          }),
          r.apply(this, arguments)
        );
      }
      function o(e, t) {
        if ('function' != typeof t && null !== t)
          throw new TypeError('Super expression must either be null or a function');
        (e.prototype = Object.create(t && t.prototype, {
          constructor: { value: e, writable: !0, configurable: !0 },
        })),
          t && i(e, t);
      }
      function i(e, t) {
        return (i =
          Object.setPrototypeOf ||
          function (e, t) {
            return (e.__proto__ = t), e;
          })(e, t);
      }
      n.d(t, { _: () => r });
    },
    54732: (e, t, n) => {
      'use strict';
      n.d(t, { k: () => r });
      const r = new (n(57251).J)({
        esriFieldTypeSmallInteger: 'small-integer',
        esriFieldTypeInteger: 'integer',
        esriFieldTypeSingle: 'single',
        esriFieldTypeDouble: 'double',
        esriFieldTypeLong: 'long',
        esriFieldTypeString: 'string',
        esriFieldTypeDate: 'date',
        esriFieldTypeOID: 'oid',
        esriFieldTypeGeometry: 'geometry',
        esriFieldTypeBlob: 'blob',
        esriFieldTypeRaster: 'raster',
        esriFieldTypeGUID: 'guid',
        esriFieldTypeGlobalID: 'global-id',
        esriFieldTypeXML: 'xml',
      });
    },
    90995: (e, t, n) => {
      'use strict';
      n.d(t, { c: () => F, g: () => a, i: () => T, v: () => w });
      var r = n(60991),
        o = n(85674);
      const i = {
        LineString: 'esriGeometryPolyline',
        MultiLineString: 'esriGeometryPolyline',
        MultiPoint: 'esriGeometryMultipoint',
        Point: 'esriGeometryPoint',
        Polygon: 'esriGeometryPolygon',
        MultiPolygon: 'esriGeometryPolygon',
      };
      function a(e) {
        return i[e];
      }
      function* s(e) {
        switch (e.type) {
          case 'Feature':
            yield e;
            break;
          case 'FeatureCollection':
            for (const t of e.features) t && (yield t);
        }
      }
      function* l(e) {
        if (!e) return null;
        switch (e.type) {
          case 'Point':
            yield e.coordinates;
            break;
          case 'LineString':
          case 'MultiPoint':
            yield* e.coordinates;
            break;
          case 'MultiLineString':
          case 'Polygon':
            for (const t of e.coordinates) yield* t;
            break;
          case 'MultiPolygon':
            for (const t of e.coordinates) for (const e of t) yield* e;
        }
      }
      function u(e) {
        for (const t of e) if (t.length > 2) return !0;
        return !1;
      }
      function c(e) {
        let t = 0;
        for (let n = 0; n < e.length; n++) {
          const r = e[n],
            o = e[(n + 1) % e.length];
          t += r[0] * o[1] - o[0] * r[1];
        }
        return t <= 0;
      }
      function p(e) {
        const t = e[0],
          n = e[e.length - 1];
        return (t[0] === n[0] && t[1] === n[1] && t[2] === n[2]) || e.push(t), e;
      }
      function y(e, t, n) {
        switch (t.type) {
          case 'LineString':
            return (function (e, t, n) {
              return m(e, t.coordinates, n), e;
            })(e, t, n);
          case 'MultiLineString':
            return (function (e, t, n) {
              for (const r of t.coordinates) m(e, r, n);
              return e;
            })(e, t, n);
          case 'MultiPoint':
            return (function (e, t, n) {
              return m(e, t.coordinates, n), e;
            })(e, t, n);
          case 'MultiPolygon':
            return (function (e, t, n) {
              for (const r of t.coordinates) {
                f(e, r[0], n);
                for (let t = 1; t < r.length; t++) d(e, r[t], n);
              }
              return e;
            })(e, t, n);
          case 'Point':
            return (function (e, t, n) {
              return h(e, t.coordinates, n), e;
            })(e, t, n);
          case 'Polygon':
            return (function (e, t, n) {
              const r = t.coordinates;
              f(e, r[0], n);
              for (let t = 1; t < r.length; t++) d(e, r[t], n);
              return e;
            })(e, t, n);
        }
      }
      function f(e, t, n) {
        const r = p(t);
        c(r) ? m(e, r, n) : g(e, r, n);
      }
      function d(e, t, n) {
        const r = p(t);
        c(r) ? g(e, r, n) : m(e, r, n);
      }
      function m(e, t, n) {
        for (const r of t) h(e, r, n);
        e.lengths.push(t.length);
      }
      function g(e, t, n) {
        for (let r = t.length - 1; r >= 0; r--) h(e, t[r], n);
        e.lengths.push(t.length);
      }
      function h(e, t, n) {
        const [r, o, i] = t;
        e.coords.push(r, o), n.hasZ && e.coords.push(i || 0);
      }
      function b(e) {
        switch (typeof e) {
          case 'string':
            return 'esriFieldTypeString';
          case 'number':
            return 'esriFieldTypeDouble';
          default:
            return 'unknown';
        }
      }
      function w(e) {
        if (!e) throw new r.Z('geojson-layer:empty', 'GeoJSON data is empty');
        if ('Feature' !== e.type && 'FeatureCollection' !== e.type)
          throw new r.Z(
            'geojson-layer:unsupported-geojson-object',
            'missing or not supported GeoJSON object type',
            { data: e },
          );
        const { crs: t } = e;
        if (!t) return;
        const n =
            'string' == typeof t
              ? t
              : 'name' === t.type
              ? t.properties.name
              : 'EPSG' === t.type
              ? t.properties.code
              : null,
          o = new RegExp('.*(CRS84H?|4326)$', 'i');
        if (!n || !o.test(n))
          throw new r.Z('geojson-layer:unsupported-crs', "unsupported GeoJSON 'crs' member", {
            crs: t,
          });
      }
      function T(e, t = {}) {
        const n = [],
          r = new Set(),
          o = new Set();
        let i,
          c = !1,
          p = Number.NEGATIVE_INFINITY,
          y = null,
          f = !1,
          { geometryType: d = null } = t,
          m = !1;
        for (const t of s(e)) {
          const { geometry: e, properties: s, id: g } = t;
          if (
            (!e || (d || (d = a(e.type)), a(e.type) === d)) &&
            (c || (c = u(l(e))),
            f ||
              ((f = null != g),
              f &&
                ((i = typeof g), 'number' === i && (y = Object.keys(s).filter((e) => s[e] === g)))),
            f &&
              'number' === i &&
              null != g &&
              ((p = Math.max(p, g)),
              y.length > 1
                ? (y = y.filter((e) => s[e] === g))
                : 1 === y.length && (y = s[y[0]] === g ? y : [])),
            !m && s)
          ) {
            let e = !0;
            for (const t in s) {
              if (r.has(t)) continue;
              const i = s[t];
              if (null == i) {
                (e = !1), o.add(t);
                continue;
              }
              const a = b(i);
              'unknown' !== a
                ? (o.delete(t), r.add(t), n.push({ name: t, alias: t, type: a }))
                : o.add(t);
            }
            m = e;
          }
        }
        const g = (y && 1 === y.length && y[0]) || null;
        if (g) for (const e of n) e.name === g && (e.type = 'esriFieldTypeOID');
        return {
          fields: n,
          geometryType: d,
          hasZ: c,
          maxObjectId: Math.max(0, p),
          objectIdFieldName: g,
          objectIdFieldType: i,
          unknownFields: Array.from(o),
        };
      }
      function F(e, t) {
        return Array.from(
          (function* (e, t = {}) {
            const { geometryType: n, objectIdField: r } = t;
            for (const s of e) {
              var i;
              const { geometry: e, properties: l, id: u } = s;
              if (e && a(e.type) !== n) continue;
              const c = l || {};
              let p = null != (i = c[r]) ? i : null;
              r && null != u && !c[r] && (c[r] = p = u);
              const f = new o.O(e ? y(new o.a(), e, t) : null, c, null, p);
              yield f;
            }
          })(s(e), t),
        );
      }
    },
    34344: (e, t, n) => {
      'use strict';
      n.d(t, { M8: () => w, ft: () => x, FU: () => T, Bm: () => G, be: () => C, eB: () => N });
      var r = n(78986),
        o = (n(74569), n(82058)),
        i = n(60991),
        a = n(76506),
        s = n(50406),
        l = n(32101),
        u = n(72334),
        c = n(60947),
        p = n(22781),
        y = n(90995),
        f = n(97546),
        d = n(21801);
      function m(e, t) {
        for (const n of e) if (null != n && t(n)) return n;
      }
      n(91306),
        n(92143),
        n(31450),
        n(71552),
        n(40642),
        n(73796),
        n(74673),
        n(21972),
        n(23639),
        n(34250),
        n(86656),
        n(22723),
        n(91055),
        n(17533),
        n(81172),
        n(27794),
        n(6906),
        n(26341),
        n(97714),
        n(2906),
        n(84069),
        n(91597),
        n(86787),
        n(35132),
        n(89623),
        n(44567),
        n(98380),
        n(92896),
        n(32422),
        n(57251),
        n(88762),
        n(82426),
        n(53785),
        n(95587),
        n(65775),
        n(12381),
        n(73173),
        n(92482),
        n(92624),
        n(59465),
        n(9801),
        n(53523),
        n(42911),
        n(46826),
        n(45433),
        n(54732);
      const g = (0, r._)(
        /^(?:(\x2D?[0-9]{4,})\x2D([0-9]{2})\x2D([0-9]{2}))(?:T([0-9]{2}):([0-9]{2}):([0-9]{2})(?:\.([0-9]+))?)?(?:(Z)|(?:(\+|\x2D)([0-9]{2}):([0-9]{2})))?$/,
        {
          year: 1,
          month: 2,
          day: 3,
          hours: 4,
          minutes: 5,
          seconds: 6,
          ms: 7,
          isUTC: 8,
          offsetSign: 9,
          offsetHours: 10,
          offsetMinutes: 11,
        },
      );
      function h(e, t) {
        for (const n of e.children)
          if (n.localName in t) {
            const e = t[n.localName];
            if ('function' == typeof e) {
              const t = e(n);
              t && h(n, t);
            } else h(n, e);
          }
      }
      function* b(e, t) {
        for (const n of e.children)
          if (n.localName in t) {
            const e = t[n.localName];
            'function' == typeof e ? yield e(n) : yield* b(n, e);
          }
      }
      const w = '__esri_wfs_id__';
      async function T(e, t) {
        const n = (function (e) {
          const t = _(e);
          !(function (e) {
            const t = e.firstElementChild.getAttribute('version');
            if (t && '2.0.0' !== t)
              throw new i.Z(
                'wfs-layer:unsupported-wfs-version',
                `Unsupported WFS version ${t}. Supported version: 2.0.0`,
              );
          })(t),
            D(t);
          const n = t.firstElementChild,
            r = new Map();
          return {
            operations: S(n),
            get featureTypes() {
              return Array.from(v(n, r));
            },
            readFeatureTypes: () => v(n, r),
          };
        })(
          (
            await (0, o.default)(e, {
              responseType: 'text',
              query: {
                SERVICE: 'WFS',
                REQUEST: 'GetCapabilities',
                VERSION: '2.0.0',
                ...(null == t ? void 0 : t.customParameters),
              },
              signal: null == t ? void 0 : t.signal,
            })
          ).data,
        );
        return (
          (function (e, t) {
            (0, l.$U)(e) &&
              ((0, l.D6)(e, t.operations.DescribeFeatureType.url, !0) &&
                (t.operations.DescribeFeatureType.url = (0, l.hO)(
                  t.operations.DescribeFeatureType.url,
                )),
              (0, l.D6)(e, t.operations.GetFeature.url, !0) &&
                (t.operations.GetFeature.url = (0, l.hO)(t.operations.GetFeature.url)));
          })(e, n),
          n
        );
      }
      const F = new Set([
        'json',
        'application/json',
        'geojson',
        'application/json; subtype=geojson',
      ]);
      function S(e) {
        let t = !1;
        const n = {
          GetCapabilities: { url: '' },
          DescribeFeatureType: { url: '' },
          GetFeature: { url: '', outputFormat: null, supportsPagination: !1 },
        };
        if (
          (h(e, {
            OperationsMetadata: {
              Operation: (e) => {
                switch (e.getAttribute('name')) {
                  case 'GetCapabilities':
                    return {
                      DCP: {
                        HTTP: {
                          Get: (e) => {
                            n.GetCapabilities.url = e.getAttribute('xlink:href');
                          },
                        },
                      },
                    };
                  case 'DescribeFeatureType':
                    return {
                      DCP: {
                        HTTP: {
                          Get: (e) => {
                            n.DescribeFeatureType.url = e.getAttribute('xlink:href');
                          },
                        },
                      },
                    };
                  case 'GetFeature':
                    return {
                      DCP: {
                        HTTP: {
                          Get: (e) => {
                            n.GetFeature.url = e.getAttribute('xlink:href');
                          },
                        },
                      },
                      Parameter: (e) => {
                        if ('outputFormat' === e.getAttribute('name'))
                          return {
                            AllowedValues: {
                              Value: (e) => {
                                const t = e.textContent;
                                F.has(t.toLowerCase()) && (n.GetFeature.outputFormat = t);
                              },
                            },
                          };
                      },
                    };
                }
              },
              Constraint: (e) => {
                switch (e.getAttribute('name')) {
                  case 'KVPEncoding':
                    return {
                      DefaultValue: (e) => {
                        t = 'true' === e.textContent.toLowerCase();
                      },
                    };
                  case 'ImplementsResultPaging':
                    return {
                      DefaultValue: (e) => {
                        n.GetFeature.supportsPagination = 'true' === e.textContent.toLowerCase();
                      },
                    };
                }
              },
            },
          }),
          !t)
        )
          throw new i.Z(
            'wfs-layer:kvp-encoding-not-supported',
            "WFS service doesn't support key/value pair (KVP) encoding",
          );
        if ((0, a.b)(n.GetFeature.outputFormat))
          throw new i.Z(
            'wfs-layer:geojson-not-supported',
            "WFS service doesn't support GeoJSON output format",
          );
        return n;
      }
      function v(e, t) {
        return b(e, {
          FeatureTypeList: {
            FeatureType: (e) => {
              if (t.has(e)) return t.get(e);
              const n = {
                  typeName: 'undefined:undefined',
                  name: '',
                  title: '',
                  description: '',
                  extent: null,
                  namespacePrefix: '',
                  namespaceUri: '',
                  supportedSpatialReferences: [],
                },
                o = new Set([4326]),
                i = (e) => {
                  var t, n;
                  const i = parseInt(
                    null == (t = e.textContent.match((0, r._)(/([0-9]+$)/i, { wkid: 1 }))) ||
                      null == (n = t.groups)
                      ? void 0
                      : n.wkid,
                    10,
                  );
                  Number.isNaN(i) || o.add(i);
                };
              return (
                h(e, {
                  Name: (e) => {
                    const { name: t, prefix: r } = j(e.textContent);
                    (n.typeName = `${r}:${t}`),
                      (n.name = t),
                      (n.namespacePrefix = r),
                      (n.namespaceUri = e.lookupNamespaceURI(r));
                  },
                  Abstract: (e) => {
                    n.description = e.textContent;
                  },
                  Title: (e) => {
                    n.title = e.textContent;
                  },
                  WGS84BoundingBox: (e) => {
                    n.extent = (function (e) {
                      let t, n, r, o;
                      for (const i of e.children)
                        switch (i.localName) {
                          case 'LowerCorner':
                            [t, n] = i.textContent.split(' ').map((e) => Number.parseFloat(e));
                            break;
                          case 'UpperCorner':
                            [r, o] = i.textContent.split(' ').map((e) => Number.parseFloat(e));
                        }
                      return { xmin: t, ymin: n, xmax: r, ymax: o, spatialReference: c.W };
                    })(e);
                  },
                  DefaultSRS: i,
                  DefaultCRS: i,
                  OtherSRS: i,
                  OtherCRS: i,
                }),
                n.title || (n.title = n.name),
                n.supportedSpatialReferences.push(...o),
                t.set(e, n),
                n
              );
            },
          },
        });
      }
      function x(e, t, n) {
        return m(e, (e) =>
          n ? e.name === t && e.namespaceUri === n : e.typeName === t || e.name === t,
        );
      }
      async function C(e, t, n, r = {}) {
        var o;
        const { featureType: l, extent: p } = await (async function (e, t, n, r = {}) {
            const { spatialReference: o = c.Z.WGS84 } = r,
              s = e.readFeatureTypes(),
              l = t ? x(s, t, n) : s.next().value;
            if ((0, a.b)(l))
              throw t
                ? new i.Z(
                    'wfs-layer:feature-type-not-found',
                    `The type '${t}' could not be found in the service`,
                  )
                : new i.Z('wfs-layer:empty-service', 'The service is empty');
            let p = new d.Z({ ...l.extent, spatialReference: o });
            if (!(0, c.e)(o, c.W))
              try {
                await (0, u.iQ)(c.W, o, void 0, r), (p = (0, u.iV)(p, c.W));
              } catch {
                throw new i.Z(
                  'wfs-layer:unsupported-spatial-reference',
                  'Projection not supported',
                );
              }
            return { extent: p, spatialReference: o, featureType: l };
          })(e, t, n, r),
          {
            fields: y,
            geometryType: f,
            swapXY: m,
            objectIdField: g,
            geometryField: h,
          } = await (async function (e, t, n = {}) {
            const [r, o] = await (0, s.as)([
              k(e.operations.DescribeFeatureType.url, t, n),
              P(e, t, n),
            ]);
            if (r.error || o.error)
              throw new i.Z(
                'wfs-layer:getWFSLayerTypeInfo-error',
                `An error occurred while getting info about the feature type '${t}'`,
                { error: r.error || o.error },
              );
            const { fields: l, errors: u } = r.value,
              c = r.value.geometryType || o.value.geometryType,
              p = o.value.swapXY;
            if ((0, a.b)(c))
              throw new i.Z(
                'wfs-layer:unknown-geometry-type',
                `The geometry type could not be determined for type '${t}`,
                { typeName: t, geometryType: c, fields: l, errors: u },
              );
            return { ...N(l), geometryType: c, swapXY: p };
          })(e, l.typeName, r);
        return {
          url: e.operations.GetCapabilities.url,
          name: l.name,
          namespaceUri: l.namespaceUri,
          fields: y,
          geometryField: h,
          geometryType: f,
          objectIdField: g,
          spatialReference: null != (o = r.spatialReference) ? o : c.Z.WGS84,
          extent: p,
          swapXY: m,
          wfsCapabilities: e,
          customParameters: r.customParameters,
        };
      }
      function N(e) {
        var t;
        const n = e.find((e) => 'geometry' === e.type);
        let r = e.find((e) => 'oid' === e.type);
        return (
          (e = e.filter((e) => 'geometry' !== e.type)),
          r ||
            ((r = new f.Z({ name: '__esri_wfs_id__', type: 'oid', alias: '__esri_wfs_id__' })),
            e.unshift(r)),
          {
            geometryField: null != (t = null == n ? void 0 : n.name) ? t : null,
            objectIdField: r.name,
            fields: e,
          }
        );
      }
      async function P(e, t, n = {}) {
        var r;
        let i,
          a = !1;
        const [s, l] = await Promise.all([
            G(e.operations.GetFeature.url, t, e.operations.GetFeature.outputFormat, {
              ...n,
              count: 1,
            }),
            (0, o.default)(e.operations.GetFeature.url, {
              responseType: 'text',
              query: O(t, void 0, { ...n, count: 1 }),
              signal: null == n ? void 0 : n.signal,
            }),
          ]),
          u = 'FeatureCollection' === s.type && (null == (r = s.features[0]) ? void 0 : r.geometry);
        if (u) {
          let e;
          switch (((i = p.f.fromJSON((0, y.g)(u.type))), u.type)) {
            case 'Point':
              e = u.coordinates;
              break;
            case 'LineString':
            case 'MultiPoint':
              e = u.coordinates[0];
              break;
            case 'MultiLineString':
            case 'Polygon':
              e = u.coordinates[0][0];
              break;
            case 'MultiPolygon':
              e = u.coordinates[0][0][0];
          }
          const t = /<[^>]*pos[^>]*> *(-?\d+(?:\.\d+)?) (-?\d+(?:\.\d+)?)/.exec(l.data);
          if (t) {
            const n = e[0].toFixed(3),
              r = e[1].toFixed(3),
              o = parseFloat(t[1]).toFixed(3);
            n === parseFloat(t[2]).toFixed(3) && r === o && (a = !0);
          }
        }
        return { geometryType: i, swapXY: a };
      }
      async function k(e, t, n) {
        return (function (e, t) {
          const { name: n } = j(e),
            r = _(t);
          D(r);
          const o = m(
            b(r.firstElementChild, {
              element: (e) => ({
                name: e.getAttribute('name'),
                typeName: j(e.getAttribute('type')).name,
              }),
            }),
            ({ name: e }) => e === n,
          );
          if ((0, a.i)(o)) {
            const e = m(
              b(r.firstElementChild, { complexType: (e) => e }),
              (e) => e.getAttribute('name') === o.typeName,
            );
            if ((0, a.i)(e))
              return (function (e) {
                var t, n;
                const r = [],
                  o = [];
                let a;
                const s = b(e, {
                  complexContent: { extension: { sequence: { element: (e) => e } } },
                });
                for (const l of s) {
                  const s = l.getAttribute('name');
                  if (!s) continue;
                  let u, c;
                  if (
                    (l.hasAttribute('type')
                      ? (u = j(l.getAttribute('type')).name)
                      : h(l, {
                          simpleType: {
                            restriction: (e) => (
                              (u = j(e.getAttribute('base')).name),
                              {
                                maxLength: (e) => {
                                  c = +e.getAttribute('value');
                                },
                              }
                            ),
                          },
                        }),
                    !u)
                  )
                    continue;
                  const p = 'true' === l.getAttribute('nillable');
                  let y = !1;
                  switch (u.toLowerCase()) {
                    case 'integer':
                    case 'nonpositiveinteger':
                    case 'negativeinteger':
                    case 'long':
                    case 'int':
                    case 'short':
                    case 'byte':
                    case 'nonnegativeinteger':
                    case 'unsignedlong':
                    case 'unsignedint':
                    case 'unsignedshort':
                    case 'unsignedbyte':
                    case 'positiveinteger':
                      o.push(new f.Z({ name: s, alias: s, type: 'integer', nullable: p }));
                      break;
                    case 'float':
                    case 'double':
                    case 'decimal':
                      o.push(new f.Z({ name: s, alias: s, type: 'double', nullable: p }));
                      break;
                    case 'boolean':
                    case 'string':
                    case 'gyearmonth':
                    case 'gyear':
                    case 'gmonthday':
                    case 'gday':
                    case 'gmonth':
                    case 'anyuri':
                    case 'qname':
                    case 'notation':
                    case 'normalizedstring':
                    case 'token':
                    case 'language':
                    case 'idrefs':
                    case 'entities':
                    case 'nmtoken':
                    case 'nmtokens':
                    case 'name':
                    case 'ncname':
                    case 'id':
                    case 'idref':
                    case 'entity':
                    case 'duration':
                    case 'time':
                      o.push(
                        new f.Z({
                          name: s,
                          alias: s,
                          type: 'string',
                          nullable: p,
                          length: null != (t = c) ? t : 255,
                        }),
                      );
                      break;
                    case 'datetime':
                    case 'date':
                      o.push(
                        new f.Z({
                          name: s,
                          alias: s,
                          type: 'date',
                          nullable: p,
                          length: null != (n = c) ? n : 36,
                        }),
                      );
                      break;
                    case 'pointpropertytype':
                      (a = 'point'), (y = !0);
                      break;
                    case 'multipointpropertytype':
                      (a = 'multipoint'), (y = !0);
                      break;
                    case 'curvepropertytype':
                    case 'multicurvepropertytype':
                    case 'multilinestringpropertytype':
                      (a = 'polyline'), (y = !0);
                      break;
                    case 'surfacepropertytype':
                    case 'multisurfacepropertytype':
                    case 'multipolygonpropertytype':
                      (a = 'polygon'), (y = !0);
                      break;
                    case 'geometrypropertytype':
                    case 'multigeometrypropertytype':
                      (y = !0),
                        r.push(
                          new i.Z(
                            'wfs-layer:unknown-geometry-type',
                            `geometry type '${u}' is not supported`,
                            { type: new XMLSerializer().serializeToString(e) },
                          ),
                        );
                      break;
                    default:
                      r.push(
                        new i.Z('wfs-layer:unknown-field-type', `Unknown field type '${u}'`, {
                          type: new XMLSerializer().serializeToString(e),
                        }),
                      );
                  }
                  y && o.push(new f.Z({ name: s, alias: s, type: 'geometry', nullable: p }));
                }
                for (const e of o)
                  if ('integer' === e.type && !e.nullable && E.has(e.name.toLowerCase())) {
                    e.type = 'oid';
                    break;
                  }
                return { geometryType: a, fields: o, errors: r };
              })(e);
          }
          throw new i.Z('wfs-layer:feature-type-not-found', `Type '${e}' not found in document`, {
            document: new XMLSerializer().serializeToString(r),
          });
        })(
          t,
          (
            await (0, o.default)(e, {
              responseType: 'text',
              query: {
                SERVICE: 'WFS',
                REQUEST: 'DescribeFeatureType',
                VERSION: '2.0.0',
                TYPENAME: t,
                ...(null == n ? void 0 : n.customParameters),
              },
              signal: null == n ? void 0 : n.signal,
            })
          ).data,
        );
      }
      const E = new Set(['objectid', 'fid']);
      async function G(e, t, n, r) {
        let { data: a } = await (0, o.default)(e, {
          responseType: 'text',
          query: O(t, n, r),
          signal: null == r ? void 0 : r.signal,
        });
        a = a.replace(/": +(-?\d+),(\d+)(,)?/g, '": $1.$2$3');
        try {
          var s;
          if (null != r && null != (s = r.dateFields) && s.length) {
            const e = new Set(r.dateFields);
            return JSON.parse(a, (t, n) =>
              e.has(t)
                ? (function (e) {
                    var t;
                    return null !=
                      (t = (function (e) {
                        var t, n, r, o;
                        const i = g.exec(e);
                        if (!i) return null;
                        const a = i.groups,
                          s = +a.year,
                          l = +a.month - 1,
                          u = +a.day,
                          c = +(null != (t = a.hours) ? t : '0'),
                          p = +(null != (n = a.minutes) ? n : '0'),
                          y = +(null != (r = a.seconds) ? r : '0');
                        if (c > 23) return null;
                        if (p > 59) return null;
                        if (y > 59) return null;
                        const f = null != (o = a.ms) ? o : '0',
                          d = f ? +f.padEnd(3, '0').substring(0, 3) : 0;
                        let m;
                        if (a.isUTC) m = Date.UTC(s, l, u, c, p, y, d);
                        else if (a.offsetSign) {
                          const e = +a.offsetHours,
                            t = +a.offsetMinutes;
                          m =
                            6e4 * ('+' === a.offsetSign ? -1 : 1) * (60 * e + t) +
                            Date.UTC(s, l, u, c, p, y, d);
                        } else m = new Date(s, l, u, c, p, y, d).getTime();
                        return Number.isNaN(m) ? null : m;
                      })(e))
                      ? t
                      : (function (e) {
                          const t = new Date(e).getTime();
                          return Number.isNaN(t) ? null : t;
                        })(e);
                  })(n)
                : n,
            );
          }
          return JSON.parse(a);
        } catch (e) {
          throw new i.Z('wfs-layer:malformed-json', 'Error while parsing the response', {
            response: a,
            error: e,
          });
        }
      }
      function O(e, t, n) {
        return {
          SERVICE: 'WFS',
          REQUEST: 'GetFeature',
          VERSION: '2.0.0',
          TYPENAMES: e,
          OUTPUTFORMAT: t,
          SRSNAME: 'EPSG:4326',
          STARTINDEX: null == n ? void 0 : n.startIndex,
          COUNT: null == n ? void 0 : n.count,
          ...(null == n ? void 0 : n.customParameters),
        };
      }
      function _(e) {
        return new DOMParser().parseFromString(e.trim(), 'text/xml');
      }
      function j(e) {
        const [t, n] = e.split(':');
        return { prefix: n ? t : '', name: null != n ? n : t };
      }
      function D(e) {
        let t, n;
        if (
          (h(e.firstElementChild, {
            Exception: (e) => (
              (t = e.getAttribute('exceptionCode')),
              {
                ExceptionText: (e) => {
                  n = e.textContent;
                },
              }
            ),
          }),
          t)
        )
          throw new i.Z(`wfs-layer:${t}`, n);
      }
    },
    97546: (e, t, n) => {
      'use strict';
      n.d(t, { Z: () => g });
      var r,
        o = n(29768),
        i = n(57251),
        a = n(74673),
        s = n(34250),
        l = (n(76506), n(91306)),
        u = (n(92143), n(59465)),
        c = n(97714),
        p = n(17533),
        y = n(9801),
        f = n(54732);
      n(71552),
        n(21972),
        n(23639),
        n(86656),
        n(22723),
        n(91055),
        n(27794),
        n(6906),
        n(50406),
        n(60991),
        n(81172),
        n(31450),
        n(40642),
        n(26341),
        n(53523),
        n(42911),
        n(46826),
        n(45433);
      const d = new i.J({
        binary: 'binary',
        coordinate: 'coordinate',
        countOrAmount: 'count-or-amount',
        dateAndTime: 'date-and-time',
        description: 'description',
        locationOrPlaceName: 'location-or-place-name',
        measurement: 'measurement',
        nameOrTitle: 'name-or-title',
        none: 'none',
        orderedOrRanked: 'ordered-or-ranked',
        percentageOrRatio: 'percentage-or-ratio',
        typeOrCategory: 'type-or-category',
        uniqueIdentifier: 'unique-identifier',
      });
      let m = (r = class extends a.a {
        constructor(e) {
          super(e),
            (this.alias = null),
            (this.defaultValue = void 0),
            (this.description = null),
            (this.domain = null),
            (this.editable = !0),
            (this.length = -1),
            (this.name = null),
            (this.nullable = !0),
            (this.type = null),
            (this.valueType = null);
        }
        readDescription(e, { description: t }) {
          let n;
          try {
            n = JSON.parse(t);
          } catch (e) {}
          return n ? n.value : null;
        }
        readValueType(e, { description: t }) {
          let n;
          try {
            n = JSON.parse(t);
          } catch (e) {}
          return n ? d.fromJSON(n.fieldValueType) : null;
        }
        clone() {
          return new r({
            alias: this.alias,
            defaultValue: this.defaultValue,
            description: this.description,
            domain: (this.domain && this.domain.clone()) || null,
            editable: this.editable,
            length: this.length,
            name: this.name,
            nullable: this.nullable,
            type: this.type,
            valueType: this.valueType,
          });
        }
      });
      (0, o._)([(0, s.Cb)({ type: String, json: { write: !0 } })], m.prototype, 'alias', void 0),
        (0, o._)(
          [(0, s.Cb)({ type: [String, Number], json: { write: { allowNull: !0 } } })],
          m.prototype,
          'defaultValue',
          void 0,
        ),
        (0, o._)([(0, s.Cb)()], m.prototype, 'description', void 0),
        (0, o._)([(0, c.r)('description')], m.prototype, 'readDescription', null),
        (0, o._)(
          [(0, s.Cb)({ types: y.t, json: { read: { reader: y.f }, write: !0 } })],
          m.prototype,
          'domain',
          void 0,
        ),
        (0, o._)(
          [(0, s.Cb)({ type: Boolean, json: { write: !0 } })],
          m.prototype,
          'editable',
          void 0,
        ),
        (0, o._)([(0, s.Cb)({ type: l.I, json: { write: !0 } })], m.prototype, 'length', void 0),
        (0, o._)([(0, s.Cb)({ type: String, json: { write: !0 } })], m.prototype, 'name', void 0),
        (0, o._)(
          [(0, s.Cb)({ type: Boolean, json: { write: !0 } })],
          m.prototype,
          'nullable',
          void 0,
        ),
        (0, o._)([(0, u.e)(f.k)], m.prototype, 'type', void 0),
        (0, o._)([(0, s.Cb)()], m.prototype, 'valueType', void 0),
        (0, o._)([(0, c.r)('valueType', ['description'])], m.prototype, 'readValueType', null),
        (m = r = (0, o._)([(0, p.j)('esri.layers.support.Field')], m));
      const g = m;
    },
  },
]);
