@nextgis/ngw-map 3.0.0-alpha.0 → 3.0.0-alpha.12

package/lib/ngw-map.esm-browser.js

@@ -1,4 +1,4 @@
-/** Bundle of @nextgis/ngw-map; version: 3.0.0-alpha.0; author: NextGIS */
+/** Bundle of @nextgis/ngw-map; version: 3.0.0-alpha.8; author: NextGIS */
 var domain;
 
 // This constructor is used to store event handlers. Instantiating this is
@@ -29,7 +29,7 @@ EventEmitter.init = function() {
   this.domain = null;
   if (EventEmitter.usingDomains) {
     // if there is an active domain, then attach to it.
-    if (domain.active ) ;
+    if (domain.active) ;
   }
 
   if (!this._events || this._events === Object.getPrototypeOf(this)._events) {
@@ -824,12 +824,12 @@ function fixUrlStr(url) {
   return url.replace(/([^:]\/)\/+/g, "$1");
 }
 
-var __defProp$K = Object.defineProperty;
-var __defNormalProp$K = (obj, key, value) => key in obj ? __defProp$K(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$v = (obj, key, value) => __defNormalProp$K(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$Q = Object.defineProperty;
+var __defNormalProp$Q = (obj, key, value) => key in obj ? __defProp$Q(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$z = (obj, key, value) => __defNormalProp$Q(obj, typeof key !== "symbol" ? key + "" : key, value);
 const _Cache = class _Cache {
   constructor(options = {}) {
-    __publicField$v(this, "cache", []);
+    __publicField$z(this, "cache", []);
     var _a;
     const namespace = (_a = options.namespace) != null ? _a : "default";
     if (_Cache.instance[namespace]) {
@@ -865,10 +865,23 @@ const _Cache = class _Cache {
    * });
    * ```
    */
-  addFull(key, valueToSet, props) {
-    return this.add(key, valueToSet, props, true);
-  }
-  add(key, valueToSet, props, onlyFull) {
+  addFull(key, valueToSet, propsOrOptions, expirationTime) {
+    if (typeof propsOrOptions === "object" && "valueToSet" in propsOrOptions) {
+      propsOrOptions.onlyFull = true;
+    }
+    return this.add(key, valueToSet, propsOrOptions, true, expirationTime);
+  }
+  add(key, valueToSet, propsOrOptions, onlyFull, expirationTime) {
+    let opt;
+    let props;
+    if (typeof propsOrOptions === "object" && "valueToSet" in propsOrOptions) {
+      opt = propsOrOptions;
+      onlyFull = opt.onlyFull;
+      expirationTime = opt.expirationTime;
+      props = opt.props;
+    } else {
+      props = propsOrOptions;
+    }
     const exist = this._find(key, props);
     if (!exist) {
       let value;
@@ -878,10 +891,12 @@ const _Cache = class _Cache {
         value = valueToSet;
       }
       const nonEmptyProps = props && JSON.parse(JSON.stringify(objectRemoveEmpty(props)));
+      expirationTime = expirationTime ? Date.now() + expirationTime : void 0;
       const cacheItem = {
         key,
         value,
-        props: nonEmptyProps
+        props: nonEmptyProps,
+        expirationTime
       };
       if (onlyFull && !full(value)) {
         return value;
@@ -908,9 +923,19 @@ const _Cache = class _Cache {
   }
   match(key, props) {
     const cacheRecord = this._find(key, props);
+    if (cacheRecord && cacheRecord.expirationTime && Date.now() > cacheRecord.expirationTime) {
+      this.delete(cacheRecord);
+      return void 0;
+    }
     return cacheRecord == null ? void 0 : cacheRecord.value;
   }
   matchAll(key, props) {
+    const now = Date.now();
+    this.cache.forEach((item) => {
+      if (item.expirationTime && now > item.expirationTime) {
+        this.delete(item);
+      }
+    });
     if (key) {
       return this.cache.filter((x) => this._filter(x, key, props)).map((x) => x.value);
     }
@@ -935,87 +960,305 @@ const _Cache = class _Cache {
     return objectDeepEqual(itemProps || {}, objectRemoveEmpty(props));
   }
 };
-__publicField$v(_Cache, "instance", {});
+__publicField$z(_Cache, "instance", {});
 let Cache = _Cache;
 
-var __defProp$J = Object.defineProperty;
-var __defNormalProp$J = (obj, key, value) => key in obj ? __defProp$J(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$u = (obj, key, value) => __defNormalProp$J(obj, typeof key !== "symbol" ? key + "" : key, value);
+var pkg = {
+	name: "@nextgis/ngw-connector",
+	version: "3.0.0-alpha.8",
+	_priority: 12,
+	description: "A lightweight HTTP client optimized for use with NextGIS Web API",
+	main: "index.js",
+	module: "lib/ngw-connector.esm-bundler.js",
+	unpkg: "lib/ngw-connector.global.prod.js",
+	jsdelivr: "lib/ngw-connector.global.prod.js",
+	types: "lib/index.d.ts",
+	dependencies: {
+		"@nextgis/cache": "^3.0.0-alpha.7",
+		"@nextgis/cancelable-promise": "^3.0.0-alpha.5",
+		"@nextgis/utils": "^3.0.0-alpha.5",
+		"@types/events": "^3.0.0",
+		events: "*",
+		"form-data": "^4.0.0"
+	},
+	devDependencies: {
+		"@nextgis/build-tools": "^3.0.0-alpha.5"
+	},
+	scripts: {
+		clean: "rimraf ./lib",
+		dev: "node ../build-tools/lib/build.js",
+		prod: "npm run dev -- --release",
+		lint: "eslint ./src/**/*.ts --fix --c ../../.eslintrc",
+		watch: "npm run dev -- --watch",
+		"gen:types": "node ./scripts/generator"
+	},
+	buildOptions: {
+		name: "NgwConnector",
+		formats: [
+			"esm-bundler",
+			"esm-browser",
+			"cjs",
+			"global"
+		]
+	},
+	keywords: [
+		"NextGIS",
+		"MAP"
+	],
+	author: "NextGIS",
+	files: [
+		"index.js",
+		"lib"
+	],
+	license: "MIT",
+	homepage: "https://github.com/nextgis/nextgis_frontend/tree/master/packages/ngw-connector#readme",
+	repository: {
+		type: "git",
+		url: "git://github.com/nextgis/nextgis_frontend.git"
+	},
+	engines: {
+		node: ">=18.20.4"
+	},
+	gitHead: "edc68033f914f6c95c4125b9738bba6d36e990b4"
+};
+
+const CONNECTORS = [];
+function addConnector(connector) {
+  CONNECTORS.push(connector);
+}
+function findConnector(options) {
+  return CONNECTORS.find((x) => {
+    if (x.options.baseUrl === options.baseUrl) {
+      if (options.auth) {
+        if (x.options.auth) {
+          return objectDeepEqual(x.options.auth, options.auth);
+        }
+      } else {
+        return true;
+      }
+    }
+  });
+}
+function removeConnector(connector) {
+  const index = CONNECTORS.indexOf(connector);
+  if (index !== -1) {
+    CONNECTORS.splice(index, 1);
+  }
+}
+
+class AbortError extends Error {
+  constructor(message = "AbortError") {
+    super(message);
+    this.name = "AbortError";
+  }
+}
+
+var __defProp$P = Object.defineProperty;
+var __defNormalProp$P = (obj, key, value) => key in obj ? __defProp$P(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$y = (obj, key, value) => __defNormalProp$P(obj, typeof key !== "symbol" ? key + "" : key, value);
 class NgwError extends Error {
   constructor(er) {
     super();
-    __publicField$u(this, "name", "NgwError");
-    __publicField$u(this, "title");
-    __publicField$u(this, "message");
-    __publicField$u(this, "detail");
-    __publicField$u(this, "exception");
-    __publicField$u(this, "status_code");
-    __publicField$u(this, "data");
-    __publicField$u(this, "guru_meditation");
+    __publicField$y(this, "name", "NgwError");
+    __publicField$y(this, "title");
+    __publicField$y(this, "message");
+    __publicField$y(this, "detail");
+    __publicField$y(this, "exception");
+    __publicField$y(this, "status_code");
+    __publicField$y(this, "data");
+    __publicField$y(this, "guru_meditation");
     Object.assign(this, er);
     Object.setPrototypeOf(this, NgwError.prototype);
   }
 }
 
-var __defProp$I = Object.defineProperty;
-var __defNormalProp$I = (obj, key, value) => key in obj ? __defProp$I(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$t = (obj, key, value) => __defNormalProp$I(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$O = Object.defineProperty;
+var __defNormalProp$O = (obj, key, value) => key in obj ? __defProp$O(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$x = (obj, key, value) => __defNormalProp$O(obj, typeof key !== "symbol" ? key + "" : key, value);
+class InsufficientPermissionsError extends NgwError {
+  constructor(obj) {
+    super(obj);
+    __publicField$x(this, "name", "InsufficientPermissionsError");
+    __publicField$x(this, "exception", "nextgisweb.core.exception.InsufficientPermissions");
+    Object.setPrototypeOf(this, InsufficientPermissionsError.prototype);
+  }
+}
+
+var __defProp$N = Object.defineProperty;
+var __defNormalProp$N = (obj, key, value) => key in obj ? __defProp$N(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$w = (obj, key, value) => __defNormalProp$N(obj, key + "" , value);
+class NetworkError extends Error {
+  constructor(url) {
+    super();
+    __publicField$w(this, "name", "NetworkError");
+    Object.setPrototypeOf(this, NetworkError.prototype);
+    this.message = `Unable to request ${url}.
+    Possibly invalid NGW URL entered or CORS not configured to get request from ${location.origin}`;
+  }
+}
+
+var __defProp$M = Object.defineProperty;
+var __defNormalProp$M = (obj, key, value) => key in obj ? __defProp$M(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$v = (obj, key, value) => __defNormalProp$M(obj, typeof key !== "symbol" ? key + "" : key, value);
+let NetworksResponseError$1 = class NetworksResponseError extends NgwError {
+  constructor(obj) {
+    super(obj);
+    __publicField$v(this, "message", "There is no response from the server or problem connecting to server.");
+    __publicField$v(this, "title", "Network error");
+    __publicField$v(this, "detail", "Check network connectivity and try again later.");
+    Object.setPrototypeOf(this, NetworksResponseError.prototype);
+  }
+};
+
+var __defProp$L = Object.defineProperty;
+var __defNormalProp$L = (obj, key, value) => key in obj ? __defProp$L(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$u = (obj, key, value) => __defNormalProp$L(obj, typeof key !== "symbol" ? key + "" : key, value);
 class ResourceNotFoundError extends NgwError {
   constructor(obj) {
     super(obj);
-    __publicField$t(this, "name", "ResourceNotFoundError");
-    __publicField$t(this, "exception", "nextgisweb.resource.exception.ResourceNotFound");
+    __publicField$u(this, "name", "ResourceNotFoundError");
+    __publicField$u(this, "exception", "nextgisweb.resource.exception.ResourceNotFound");
     Object.setPrototypeOf(this, ResourceNotFoundError.prototype);
   }
 }
 
-function isObject(val) {
-  return Object.prototype.toString.call(val) === "[object Object]";
+function isError(error) {
+  if (isObject$1(error)) {
+    return error.status_code && error.exception && error.title;
+  }
+  return false;
 }
 
-function resourceCompare(res1, res2) {
-  return objectDeepEqual(res1, res2);
+function extractError(error) {
+  if (isObject$1(error)) {
+    if (error.name && error.message && error.title) {
+      return {
+        title: error.title,
+        message: error.message,
+        detail: error.detail || null,
+        data: error.data && error.data.data ? error.data.data : null
+      };
+    } else if (error.exception) {
+      if (error.status === void 0 || error.status === 0 || error.data === void 0) {
+        return new NetworksResponseError$1({
+          title: error.title,
+          status_code: error.status_code,
+          exception: error.exception
+        });
+      }
+    }
+    return {
+      title: typeof error.title === "string" ? error.title : "Unexpected error",
+      message: typeof error.message === "string" ? error.message : "Something went wrong."
+    };
+  }
 }
 
-const exclude = ["description"];
-function resourceToQuery(resource, prefix = "") {
-  prefix = prefix ? prefix + "__" : "";
-  const query = {};
-  for (const [key, value] of Object.entries(resource)) {
-    if (exclude.indexOf(key) === -1) {
-      if (isObject(value)) {
-        if (key === "owner_user") {
-          const children = resourceToQuery(value, key);
-          Object.assign(query, children);
-        } else if (key === "parent" && "id" in value) {
-          query.parent_id = value.id;
-        }
-      } else if (defined(value)) {
-        query[prefix + key] = value;
-      }
+var errors = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  AbortError: AbortError,
+  InsufficientPermissionsError: InsufficientPermissionsError,
+  NetworkError: NetworkError,
+  NetworksResponseError: NetworksResponseError$1,
+  NgwError: NgwError,
+  ResourceNotFoundError: ResourceNotFoundError,
+  extractError: extractError,
+  isError: isError
+});
+
+var __defProp$K = Object.defineProperty;
+var __defNormalProp$K = (obj, key, value) => key in obj ? __defProp$K(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$t = (obj, key, value) => __defNormalProp$K(obj, typeof key !== "symbol" ? key + "" : key, value);
+class BaseAPIError extends Error {
+  constructor(message) {
+    super(message || "Something went wrong.");
+    __publicField$t(this, "title");
+    this.name = "BaseAPIError";
+    this.title = "Unknown API error";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, BaseAPIError);
     }
   }
-  return query;
+}
+class NetworksResponseError extends BaseAPIError {
+  // prettier-ignore
+  constructor(message) {
+    super(message || "There is no response from the server or problem connecting to server.");
+    __publicField$t(this, "detail");
+    this.title = "Network error";
+    this.detail = "Check network connectivity and try again later.";
+  }
+}
+class InvalidResponseError extends BaseAPIError {
+  constructor(message) {
+    super(message || "Something went wrong.");
+    this.title = "Unexpected server response";
+  }
+}
+class ServerResponseError extends BaseAPIError {
+  constructor(data) {
+    super(data.message);
+    __publicField$t(this, "detail");
+    __publicField$t(this, "data");
+    this.title = data.title || this.title;
+    this.detail = data.detail || null;
+    this.data = data;
+  }
+}
+class LunkwillError extends Error {
+  // prettier-ignore
+  constructor(message, data = {}) {
+    super(message || "Unexpected error while processing long-running request.");
+    __publicField$t(this, "title");
+    __publicField$t(this, "data");
+    this.name = "LunkwillError";
+    this.title = "Long-running request error";
+    this.data = data;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, LunkwillError);
+    }
+  }
+}
+class LunkwillRequestCancelled extends LunkwillError {
+  constructor(data) {
+    super("Long-running request was cancelled.", data);
+  }
+}
+class LunkwillRequestFailed extends LunkwillError {
+  constructor(data) {
+    super(void 0, data);
+  }
 }
 
-var __defProp$H = Object.defineProperty;
-var __getOwnPropSymbols$w = Object.getOwnPropertySymbols;
-var __hasOwnProp$w = Object.prototype.hasOwnProperty;
-var __propIsEnum$w = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$H = (obj, key, value) => key in obj ? __defProp$H(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$v = (a, b) => {
+var __defProp$J = Object.defineProperty;
+var __getOwnPropSymbols$y = Object.getOwnPropertySymbols;
+var __hasOwnProp$y = Object.prototype.hasOwnProperty;
+var __propIsEnum$y = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$J = (obj, key, value) => key in obj ? __defProp$J(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$x = (a, b) => {
   for (var prop in b || (b = {}))
-    if (__hasOwnProp$w.call(b, prop))
-      __defNormalProp$H(a, prop, b[prop]);
-  if (__getOwnPropSymbols$w)
-    for (var prop of __getOwnPropSymbols$w(b)) {
-      if (__propIsEnum$w.call(b, prop))
-        __defNormalProp$H(a, prop, b[prop]);
+    if (__hasOwnProp$y.call(b, prop))
+      __defNormalProp$J(a, prop, b[prop]);
+  if (__getOwnPropSymbols$y)
+    for (var prop of __getOwnPropSymbols$y(b)) {
+      if (__propIsEnum$y.call(b, prop))
+        __defNormalProp$J(a, prop, b[prop]);
     }
   return a;
 };
-var __publicField$s = (obj, key, value) => __defNormalProp$H(obj, typeof key !== "symbol" ? key + "" : key, value);
-var __async$s = (__this, __arguments, generator) => {
+var __objRest$5 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$y.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$y)
+    for (var prop of __getOwnPropSymbols$y(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$y.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __async$v = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
       try {
@@ -1035,123 +1278,967 @@ var __async$s = (__this, __arguments, generator) => {
     step((generator = generator.apply(__this, __arguments)).next());
   });
 };
-class ResourcesControl {
-  constructor({
-    connector,
-    cacheId
-  }) {
-    __publicField$s(this, "cache");
-    __publicField$s(this, "connector");
-    this.connector = connector;
-    this.cache = new Cache({ namespace: cacheId });
-  }
-  // -------------------------------------------------------------------------
-  // Resource Methods
-  // -------------------------------------------------------------------------
-  /**
-   * Receive resource from NGW by id, keyname or search-object parameter.
-   * @param resource - Resource id, keyname or search-object
-   *
-   * @remarks
-   * Fetching resource would be cached to speed up next call
-   */
-  getOne(resource, requestOptions) {
-    const opt = __spreadValues$v({}, requestOptions);
-    if (typeof resource === "string") ; else if (typeof resource === "number") ; else if (isObject(resource)) {
-      if (resource.id !== void 0) {
-        resource.id;
-      } else {
-        if (resource.keyname) {
-          resource.keyname;
-        }
-        if (resource.display_name) {
-          resource.display_name;
-        }
+function lunkwillCheckResponse(lwResp) {
+  const ct = lwResp.headers.get("content-type");
+  return ct !== void 0 && ct !== null && ct.includes("application/vnd.lunkwill.request-summary+json");
+}
+function responseJson(response) {
+  return __async$v(this, null, function* () {
+    try {
+      return response.json();
+    } catch (e) {
+      throw new Error();
+    }
+  });
+}
+function lunkwillResponseUrl(lwResp) {
+  return __async$v(this, null, function* () {
+    const lwData = yield responseJson(lwResp);
+    let delay = lwData.delay_ms;
+    const retry = lwData.retry_ms !== void 0 ? lwData.retry_ms : 2e3;
+    const sum = `/api/lunkwill/${lwData.id}/summary`;
+    const res = `/api/lunkwill/${lwData.id}/response`;
+    const sleep = (msec) => new Promise((resolve) => setTimeout(resolve, msec));
+    let failed = false;
+    let ready = false;
+    while (!ready) {
+      yield sleep(failed ? retry : delay);
+      failed = false;
+      let lwResp2;
+      let lwData2;
+      try {
+        lwResp2 = yield fetch(sum, { credentials: "same-origin" });
+        lwData2 = yield lwResp2.json();
+      } catch (e) {
+        failed = true;
+        continue;
+      }
+      switch (lwData2.status) {
+        case void 0:
+          throw new LunkwillError(void 0, lwData2);
+        case "ready":
+          ready = true;
+          break;
+        case "cancelled":
+          throw new LunkwillRequestCancelled(lwData2);
+        case "failed":
+          throw new LunkwillRequestFailed(lwData2);
+        case "spooled":
+        case "processing":
+        case "buffering":
+          delay = lwData2.delay_ms;
+          break;
+        default:
+          throw new LunkwillError(void 0, lwData2);
       }
     }
-    if (typeof resource === "string") {
-      return this._fetchResourceBy({ keyname: resource }, opt);
-    } else if (typeof resource === "number") {
-      return this._fetchResourceById(resource, opt);
-    } else if (isObject(resource)) {
-      return this._fetchResourceBy(resource, opt);
+    return res;
+  });
+}
+function lunkwillFetch(lwRespUrl) {
+  return __async$v(this, null, function* () {
+    try {
+      return yield window.fetch(lwRespUrl, { credentials: "same-origin" });
+    } catch (e) {
+      throw new NetworksResponseError();
     }
-    return Promise.resolve(void 0);
-  }
-  getOneOrFail(resource, requestOptions) {
-    return this.getOne(resource, requestOptions).then((res) => {
-      if (res) {
-        return res;
-      }
-      throw new ResourceNotFoundError();
-    });
-  }
-  /**
-   * A fast way to retrieve resource ID for any resource definition.
-   * @param resource - Any available resource definition
-   *
-   * @remarks
-   * There are situations when exactly the resource id is needed
-   * (for example, to compose the correct request to the api)
-   * then this method will come in handy to facilitate the extraction of the identifier
-   * if the resource is specified through a keyname or other parameters.
-   */
-  getId(resource, requestOptions) {
-    if (typeof resource === "number") {
-      return Promise.resolve(resource);
-    } else if (typeof resource === "string" || isObject(resource)) {
-      return this.getOne(resource, requestOptions).then((res) => {
-        if (res) {
-          return res.resource.id;
+  });
+}
+const mediaContentTypes = [
+  "application/pdf",
+  "image/png",
+  "image/jpeg",
+  "image/tiff",
+  "text/csv"
+];
+const mediaContentTypesRegex = new RegExp(mediaContentTypes.join("|"));
+function isMediaContentType(contentType) {
+  return mediaContentTypesRegex.test(contentType);
+}
+function encodeQueryParams(value) {
+  const result = [];
+  for (const [k, v] of Object.entries(value)) {
+    if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
+      result.push(`${k}=${encodeURIComponent(v)}`);
+    } else if (Array.isArray(v)) {
+      result.push(`${k}=${v.map(encodeURIComponent).join(",")}`);
+    } else {
+      for (const [sk, sv] of Object.entries(v)) {
+        const ske = `${k}[${encodeURIComponent(sk)}]`;
+        if (typeof sv === "string" || typeof sv === "number" || typeof sv === "boolean") {
+          result.push(`${ske}=${encodeURIComponent(sv)}`);
+        } else if (Array.isArray(sv)) {
+          const sve = sv.map(encodeURIComponent);
+          result.push(`${ske}=${sve.join(",")}`);
         }
-      });
+      }
     }
-    return Promise.resolve(void 0);
   }
-  /**
-   * A fast way to retrieve resource ID for any resource definition.
-   * @param resource - Any available resource definition
-   *
-   * @remarks
-   * Similar with {@link NgwConnector.getResourceId | getResourceId} but rise error if resource is not exist.
-   * To not make one more checks if the resource is definitely exists
-   */
-  getIdOrFail(resource, requestOptions) {
-    return this.getId(resource, requestOptions).then((resp) => {
-      if (resp === void 0) {
-        throw new Error();
-      }
-      return resp;
-    });
+  return result.join("&");
+}
+function generateUrl(path, query) {
+  let urlParams = "";
+  if (query !== void 0) {
+    urlParams = "?" + encodeQueryParams(query);
   }
-  getMany(resource, requestOptions) {
-    return this._resourceCacheFilter(resource).then((items) => {
-      if (!items.length) {
-        const query = {};
-        if (resource.keyname) {
-          query.keyname = resource.keyname;
-        } else {
-          Object.assign(query, resourceToQuery(resource));
+  return path + urlParams;
+}
+function request(path, options, cacheEngine) {
+  return __async$v(this, null, function* () {
+    var _b;
+    const defaults = {
+      method: "GET",
+      credentials: "same-origin",
+      headers: {}
+    };
+    const _a = __spreadValues$x(__spreadValues$x({}, defaults), options), {
+      withCredentials,
+      responseType,
+      cacheProps,
+      cacheName,
+      lunkwill,
+      cache,
+      query,
+      json
+    } = _a, opt = __objRest$5(_a, [
+      "withCredentials",
+      "responseType",
+      "cacheProps",
+      "cacheName",
+      "lunkwill",
+      "cache",
+      "query",
+      "json"
+    ]);
+    if (withCredentials) {
+      opt.credentials = "include";
+    }
+    let useLunkwill = false;
+    if (lunkwill !== void 0) {
+      lunkwill.toHeaders(opt.headers || {});
+      useLunkwill = true;
+    }
+    const lunkwillReturnUrl = !!opt.lunkwillReturnUrl;
+    delete opt.lunkwillReturnUrl;
+    if (json !== void 0) {
+      opt.body = JSON.stringify(json);
+      const headers = opt.headers || {};
+      headers["Content-Type"] = "application/json";
+      opt.headers = headers;
+    }
+    const url = generateUrl(path, query);
+    const makeRequest = () => __async$v(this, null, function* () {
+      let response;
+      try {
+        response = yield fetch(url, opt);
+      } catch (e) {
+        if (opt.signal && opt.signal.aborted) {
+          throw e;
         }
-        return this.connector.get("resource.search", requestOptions, __spreadValues$v({
-          serialization: "full"
-        }, query)).then((resources) => {
-          if ((requestOptions == null ? void 0 : requestOptions.cache) && resources) {
-            for (const x of resources) {
-              this.cache.add("resource.item", Promise.resolve(x), {
-                id: x.resource.id
-              });
-            }
-          }
-          return resources;
-        });
+        throw new NetworksResponseError();
+      }
+      if (useLunkwill && lunkwillCheckResponse(response)) {
+        const lwRespUrl = yield lunkwillResponseUrl(response);
+        if (lunkwillReturnUrl) {
+          return lwRespUrl;
+        }
+        response = yield lunkwillFetch(lwRespUrl);
+      }
+      const respCType = response.headers.get("content-type");
+      const respJSON = respCType && (respCType.includes("application/json") || respCType.includes("application/vnd.lunkwill.request-summary+json"));
+      let body;
+      try {
+        const respMedia = respCType && isMediaContentType(respCType);
+        if (responseType === "blob" || respMedia) {
+          body = yield response.blob();
+        } else if (respJSON) {
+          body = yield response.json();
+        } else {
+          throw new InvalidResponseError();
+        }
+      } catch (e) {
+        if (e.name === "AbortError" || e instanceof InvalidResponseError) {
+          throw e;
+        }
+        throw new InvalidResponseError();
+      }
+      if (400 <= response.status && response.status <= 599) {
+        throw new ServerResponseError(body);
+      }
+      return body;
+    });
+    if (cacheEngine && ((_b = opt.method) == null ? void 0 : _b.toUpperCase()) === "GET") {
+      const props = cacheProps ? cacheProps : __spreadValues$x({}, objectRemoveEmpty({
+        withCredentials,
+        responseType
+      }));
+      return cacheEngine.add(cacheName || url, makeRequest, {
+        props,
+        expirationTime: cache ? void 0 : 500
+      });
+    }
+    return makeRequest();
+  });
+}
+
+var __defProp$I = Object.defineProperty;
+var __defProps$i = Object.defineProperties;
+var __getOwnPropDescs$i = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$x = Object.getOwnPropertySymbols;
+var __hasOwnProp$x = Object.prototype.hasOwnProperty;
+var __propIsEnum$x = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$I = (obj, key, value) => key in obj ? __defProp$I(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$w = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$x.call(b, prop))
+      __defNormalProp$I(a, prop, b[prop]);
+  if (__getOwnPropSymbols$x)
+    for (var prop of __getOwnPropSymbols$x(b)) {
+      if (__propIsEnum$x.call(b, prop))
+        __defNormalProp$I(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$i = (a, b) => __defProps$i(a, __getOwnPropDescs$i(b));
+var __objRest$4 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$x.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$x)
+    for (var prop of __getOwnPropSymbols$x(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$x.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __async$u = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+function routeURL(name, baseUrl, routeData, ...rest) {
+  const [template, ...params] = routeData[name];
+  const first = rest[0];
+  let sub;
+  if (first === void 0) {
+    sub = [];
+  } else if (typeof first === "object" && first !== null) {
+    if (rest.length > 1) {
+      throw new Error("Too many arguments for route(name, object)!");
+    }
+    sub = [];
+    for (const [p, v] of Object.entries(first)) {
+      sub[params.indexOf(p)] = String(v);
+    }
+  } else {
+    sub = rest.map((v) => String(v));
+  }
+  return fixUrlStr(
+    baseUrl + template.replace(/\{(\w+)\}/g, function(m, a) {
+      const idx = parseInt(a);
+      const value = sub[idx];
+      if (value === void 0) {
+        const msg = `Undefined parameter ${idx} in "${template}".`;
+        throw new Error(msg);
+      }
+      return String(value);
+    })
+  );
+}
+function route(name, connector, ...rest) {
+  const result = {
+    url: (opt) => __async$u(this, null, function* () {
+      var _a;
+      const routeData = yield connector.connect();
+      const template = routeURL(
+        name,
+        (_a = connector.options.baseUrl) != null ? _a : "",
+        routeData,
+        ...rest
+      );
+      return generateUrl(template, opt == null ? void 0 : opt.query);
+    })
+  };
+  const methods = ["get", "post", "put", "delete", "patch"];
+  for (const method of methods) {
+    const methodResp = (requestOptions) => __async$u(this, null, function* () {
+      var _b;
+      const _a = requestOptions || {}, { headers: optHeaders } = _a, restOpt = __objRest$4(_a, ["headers"]);
+      const routeData = yield connector.connect();
+      const template = routeURL(
+        name,
+        (_b = connector.options.baseUrl) != null ? _b : "",
+        routeData,
+        ...rest
+      );
+      const headers = objectRemoveEmpty(__spreadValues$w(__spreadValues$w({}, connector.getAuthorizationHeaders()), optHeaders != null ? optHeaders : {}));
+      return request(
+        template,
+        __spreadProps$i(__spreadValues$w({
+          headers
+        }, restOpt), {
+          method
+        }),
+        connector.cache
+      );
+    });
+    result[method] = methodResp;
+  }
+  return result;
+}
+
+function isObject(val) {
+  return Object.prototype.toString.call(val) === "[object Object]";
+}
+
+let loadData;
+{
+  loadData = (url, callback, options = {}, error, onCancel) => {
+    options.method = options.method || "GET";
+    const xhr = new XMLHttpRequest();
+    xhr.open(options.method || "GET", url, true);
+    if (options.responseType === "blob") {
+      xhr.responseType = options.responseType;
+    }
+    const getResponseText = () => {
+      try {
+        return JSON.parse(xhr.responseText);
+      } catch (er) {
+        return xhr.responseText;
+      }
+    };
+    const processingResponse = (forError = false) => {
+      const cb = forError ? error : callback;
+      if (options.responseType === "blob") {
+        cb(xhr.response);
+      } else {
+        if (xhr.responseText) {
+          cb(getResponseText());
+        } else {
+          error({ message: "" });
+        }
+      }
+    };
+    xhr.onload = () => {
+      if ([401, 403, 404, 422, 500].indexOf(xhr.status) !== -1) {
+        error(new NgwError(getResponseText()));
+      }
+      processingResponse();
+    };
+    xhr.onerror = (er) => {
+      if (xhr.status === 0) {
+        error(new NetworkError(url));
+      } else {
+        error(er);
+      }
+    };
+    xhr.upload.onprogress = function(e) {
+      if (e.lengthComputable) {
+        const percentComplete = e.loaded / e.total * 100;
+        if (options.onProgress) {
+          options.onProgress(percentComplete, e);
+        }
+      }
+    };
+    const headers = options.headers;
+    if (headers) {
+      for (const h in headers) {
+        const header = headers[h];
+        if (typeof header === "string") {
+          xhr.setRequestHeader(h, header);
+        }
+      }
+    }
+    if (options.withCredentials !== void 0) {
+      xhr.withCredentials = options.withCredentials;
+    }
+    let data;
+    if (options.file) {
+      data = new FormData();
+      data.append("file", options.file);
+      if (options.data) {
+        for (const d in options.data) {
+          data.append(d, data[d]);
+        }
+      }
+    } else {
+      data = options.data ? typeof options.data === "string" ? options.data : JSON.stringify(options.data) : null;
+    }
+    if (onCancel) {
+      onCancel(() => {
+        xhr.abort();
+      });
+    }
+    xhr.send(data);
+  };
+}
+
+const templateRe = /\{ *([\w_-]+) *\}/g;
+function template(str, data) {
+  return str.replace(templateRe, (s, key) => {
+    let value = data[key];
+    if (value === void 0) {
+      throw new Error("No value provided for letiable " + s);
+    } else if (typeof value === "function") {
+      value = value(data);
+    }
+    return value;
+  });
+}
+
+var __defProp$H = Object.defineProperty;
+var __defProps$h = Object.defineProperties;
+var __getOwnPropDescs$h = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$w = Object.getOwnPropertySymbols;
+var __hasOwnProp$w = Object.prototype.hasOwnProperty;
+var __propIsEnum$w = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$H = (obj, key, value) => key in obj ? __defProp$H(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$v = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$w.call(b, prop))
+      __defNormalProp$H(a, prop, b[prop]);
+  if (__getOwnPropSymbols$w)
+    for (var prop of __getOwnPropSymbols$w(b)) {
+      if (__propIsEnum$w.call(b, prop))
+        __defNormalProp$H(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$h = (a, b) => __defProps$h(a, __getOwnPropDescs$h(b));
+var __objRest$3 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$w.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$w)
+    for (var prop of __getOwnPropSymbols$w(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$w.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __publicField$s = (obj, key, value) => __defNormalProp$H(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __async$t = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+let ID$2 = 0;
+let REQUEST_ID = 0;
+class NgwConnector {
+  constructor(options) {
+    this.options = options;
+    __publicField$s(this, "id", ID$2++);
+    __publicField$s(this, "emitter", new EventEmitter());
+    __publicField$s(this, "user");
+    __publicField$s(this, "cache");
+    __publicField$s(this, "withCredentials");
+    __publicField$s(this, "client", `NextGIS-NGW-Connector/${pkg.version}`);
+    __publicField$s(this, "routeStr", "/api/component/pyramid/route");
+    __publicField$s(this, "activeRequests", {});
+    __publicField$s(this, "requestTransform");
+    const exist = findConnector(options);
+    this.cache = new Cache({ namespace: options.cacheId });
+    if (exist) {
+      return exist;
+    } else {
+      const { route: route2, requestTransform, withCredentials } = this.options;
+      if (route2) {
+        this.routeStr = route2;
+      }
+      if (requestTransform) {
+        this.requestTransform = requestTransform;
+      }
+      if (withCredentials !== void 0) {
+        this.withCredentials = withCredentials;
+      }
+      addConnector(this);
+    }
+  }
+  /**
+   * Clear the cache.
+   */
+  clearCache() {
+    this.cache.clean();
+  }
+  setRequestTransform(requestTransform) {
+    this.requestTransform = requestTransform;
+  }
+  /**
+   * Fast way to specify the connection address to NextGIS Web.
+   * The current connection will be severed.
+   * @param baseUrl - NGW url
+   */
+  setNgw(baseUrl) {
+    this.logout();
+    this.options.baseUrl = baseUrl;
+    addConnector(this);
+  }
+  /**
+   * Establishing a connection with NextGIS Web to fulfill all other requests.
+   * @remarks
+   * This method need not be called manually as it is used when forming a request in {@link apiRequest | apiRequest}.
+   * Can be used to check connection.
+   * @example
+   * ```javascript
+   * const connector = new NgwConnector({ baseUrl: 'https://demo.nextgis.com' });
+   * connector.connect()
+   *   .then(() => console.log('Ok'))
+   *   .catch((er) => console.log('Connection problem', er));
+   * ```
+   */
+  connect() {
+    return __async$t(this, null, function* () {
+      const auth = this.options.auth;
+      if (auth) {
+        const { login, password } = auth;
+        if (login && password) {
+          yield this._login({ login, password });
+        }
+      }
+      const routeUrl = `${this.routeStr}?client=${this.client}`;
+      return yield this.makeQuery(
+        routeUrl,
+        {},
+        {
+          cacheName: "route",
+          cache: true,
+          cacheProps: {
+            id: this.id,
+            auth,
+            baseUrl: this.options.baseUrl
+          }
+        }
+      );
+    });
+  }
+  /**
+   * Quick way to change NextGIS Web user.
+   * @param credentials - New user credentials
+   */
+  login(credentials, options) {
+    this.logout();
+    addConnector(this);
+    return this._login(credentials, options);
+  }
+  /**
+   * Disconnecting a user. Aborting all current requests
+   */
+  logout() {
+    this.abort();
+    removeConnector(this);
+    this.options.auth = void 0;
+    this.user = void 0;
+    this.clearCache();
+    this.emitter.emit("logout");
+  }
+  getUserInfo(credentials, options) {
+    return __async$t(this, null, function* () {
+      if (this.user && this.user.id) {
+        return this.user;
+      }
+      if (credentials) {
+        this.options.auth = credentials;
+      }
+      const options_ = __spreadValues$v({
+        headers: this.getAuthorizationHeaders(credentials),
+        cache: true
+      }, options);
+      return this.makeQuery(
+        "/api/component/auth/current_user",
+        {},
+        options_
+      );
+    });
+  }
+  /**
+   * Obtaining the required Headers for authentication of requests in the NGW.
+   */
+  getAuthorizationHeaders(credentials) {
+    const client = this.makeClientId(credentials);
+    if (client) {
+      return {
+        Authorization: `Basic ${client}`
+      };
+    }
+    return {};
+  }
+  makeClientId(credentials) {
+    credentials = credentials || this.options.auth;
+    if (credentials) {
+      const { login, password } = credentials;
+      const encodedStr = [login, password].map(encodeURIComponent).join(":");
+      {
+        return window.btoa(encodedStr);
+      }
+    }
+  }
+  /** Stop all api requests */
+  abort() {
+    for (const abortController of Object.values(this.activeRequests)) {
+      abortController.abort();
+    }
+    this.activeRequests = {};
+  }
+  getActiveApiRequests() {
+    return __spreadValues$v({}, this.activeRequests);
+  }
+  route(name, ...rest) {
+    return route(name, this, ...rest);
+  }
+  /**
+   * Send request to NGW.
+   * @param url - URL address to NGW
+   * @param params - Query params
+   * @param options - Request options
+   */
+  makeQuery(_0, _1) {
+    return __async$t(this, arguments, function* (url, params, options = {}) {
+      var _b;
+      url = (this.options.baseUrl ? this.options.baseUrl : "") + url;
+      if (!url) {
+        throw new Error("Empty `url` not allowed");
+      }
+      if (params) {
+        const _a = params, restParams = __objRest$3(_a, ["paramList"]);
+        url = template(url, restParams);
+      }
+      url = encodeURI(fixUrlStr(url));
+      options = __spreadValues$v({ withCredentials: this.withCredentials }, options);
+      const {
+        cache,
+        signal: externalSignal,
+        method = "GET",
+        headers,
+        cacheName,
+        cacheProps,
+        responseType,
+        withCredentials
+      } = options;
+      const internalAbortController = new AbortController();
+      const internalSignal = internalAbortController.signal;
+      if (externalSignal) {
+        if (externalSignal.aborted) {
+          throw new AbortError();
+        }
+        externalSignal.addEventListener("abort", () => {
+          internalAbortController.abort();
+        });
+      }
+      options.signal = internalSignal;
+      const createPromise = () => __async$t(this, null, function* () {
+        const id = REQUEST_ID++;
+        this.activeRequests[id] = internalAbortController;
+        try {
+          return this._loadData(url, options);
+        } finally {
+          this._cleanActiveRequest(id);
+        }
+      });
+      if (method === "GET") {
+        const cacheOptions = cacheProps ? cacheProps : __spreadProps$h(__spreadValues$v({}, objectRemoveEmpty({
+          headers,
+          withCredentials,
+          responseType,
+          baseUrl: this.options.baseUrl,
+          userId: (_b = this.user) == null ? void 0 : _b.id
+        })), {
+          params
+        });
+        return this.cache.add(cacheName || url, createPromise, {
+          props: cacheOptions,
+          expirationTime: cache ? void 0 : 500
+        });
+      }
+      return createPromise();
+    });
+  }
+  _loadData(url, options) {
+    options.responseType = options.responseType || "json";
+    return new Promise((resolve, reject) => {
+      var _a;
+      if (this.user) {
+        options = options || {};
+        options.headers = __spreadValues$v(__spreadValues$v({}, this.getAuthorizationHeaders()), options.headers);
+      }
+      if (this.requestTransform) {
+        const [transUrl, transOptions] = this.requestTransform(url, options);
+        url = transUrl;
+        options = transOptions;
+      }
+      let runOnAbort = void 0;
+      loadData(url, resolve, options, reject, (handler) => {
+        runOnAbort = handler;
+      });
+      (_a = options.signal) == null ? void 0 : _a.addEventListener("abort", () => {
+        if (runOnAbort !== void 0) {
+          runOnAbort();
+        }
+        reject(new AbortError());
+      });
+    }).catch((httpError) => {
+      if (httpError.name !== "AbortError") {
+        {
+          console.warn("DEV WARN", httpError);
+        }
+        const er = this._handleHttpError(httpError);
+        if (er) {
+          throw er;
+        }
+      }
+      throw httpError;
+    });
+  }
+  _login(credentials, options) {
+    return __async$t(this, null, function* () {
+      try {
+        const data = yield this.getUserInfo(credentials, options);
+        this.user = data;
+        this.emitter.emit("login", data);
+        return data;
+      } catch (er) {
+        this.emitter.emit("login:error", er);
+        throw er;
+      }
+    });
+  }
+  _cleanActiveRequest(requestId) {
+    delete this.activeRequests[requestId];
+  }
+  _handleHttpError(er) {
+    if (er) {
+      if (er instanceof NgwError) {
+        if (er.exception === "nextgisweb.resource.exception.ResourceNotFound") {
+          throw new ResourceNotFoundError(er);
+        } else if (er.exception === "nextgisweb.core.exception.InsufficientPermissions") {
+          throw new InsufficientPermissionsError(er);
+        }
+      }
+    }
+    return er;
+  }
+}
+__publicField$s(NgwConnector, "errors", errors);
+
+function resourceCompare(res1, res2) {
+  return objectDeepEqual(res1, res2);
+}
+
+const exclude = ["description"];
+function resourceToQuery(resource, prefix = "") {
+  prefix = prefix ? prefix + "__" : "";
+  const query = {};
+  for (const [key, value] of Object.entries(resource)) {
+    if (exclude.indexOf(key) === -1) {
+      if (isObject(value)) {
+        if (key === "owner_user") {
+          const children = resourceToQuery(
+            value,
+            key
+          );
+          Object.assign(query, children);
+        } else if (key === "parent" && "id" in value) {
+          query.parent_id = value.id;
+        }
+      } else if (defined(value)) {
+        query[prefix + key] = value;
+      }
+    }
+  }
+  return query;
+}
+
+var __defProp$G = Object.defineProperty;
+var __defProps$g = Object.defineProperties;
+var __getOwnPropDescs$g = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$v = Object.getOwnPropertySymbols;
+var __hasOwnProp$v = Object.prototype.hasOwnProperty;
+var __propIsEnum$v = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$G = (obj, key, value) => key in obj ? __defProp$G(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$u = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$v.call(b, prop))
+      __defNormalProp$G(a, prop, b[prop]);
+  if (__getOwnPropSymbols$v)
+    for (var prop of __getOwnPropSymbols$v(b)) {
+      if (__propIsEnum$v.call(b, prop))
+        __defNormalProp$G(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$g = (a, b) => __defProps$g(a, __getOwnPropDescs$g(b));
+var __publicField$r = (obj, key, value) => __defNormalProp$G(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __async$s = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+class ResourcesControl {
+  constructor({
+    connector,
+    cacheId
+  }) {
+    __publicField$r(this, "cache");
+    __publicField$r(this, "connector");
+    this.connector = connector;
+    this.cache = new Cache({ namespace: cacheId });
+  }
+  // -------------------------------------------------------------------------
+  // Resource Methods
+  // -------------------------------------------------------------------------
+  /**
+   * Receive resource from NGW by id, keyname or search-object parameter.
+   * @param resource - Resource id, keyname or search-object
+   *
+   * @remarks
+   * Fetching resource would be cached to speed up next call
+   */
+  getOne(resource, requestOptions) {
+    const opt = __spreadValues$u({}, requestOptions);
+    if (typeof resource === "string") ; else if (typeof resource === "number") ; else if (isObject(resource)) {
+      if (resource.id !== void 0) {
+        resource.id;
+      } else {
+        if (resource.keyname) {
+          resource.keyname;
+        }
+        if (resource.display_name) {
+          resource.display_name;
+        }
+      }
+    }
+    if (typeof resource === "string") {
+      return this._fetchResourceBy({ keyname: resource }, opt);
+    } else if (typeof resource === "number") {
+      return this._fetchResourceById(resource, opt);
+    } else if (isObject(resource)) {
+      return this._fetchResourceBy(resource, opt);
+    }
+    return Promise.resolve(void 0);
+  }
+  getOneOrFail(resource, requestOptions) {
+    return this.getOne(resource, requestOptions).then((res) => {
+      if (res) {
+        return res;
+      }
+      throw new ResourceNotFoundError();
+    });
+  }
+  /**
+   * A fast way to retrieve resource ID for any resource definition.
+   * @param resource - Any available resource definition
+   *
+   * @remarks
+   * There are situations when exactly the resource id is needed
+   * (for example, to compose the correct request to the api)
+   * then this method will come in handy to facilitate the extraction of the identifier
+   * if the resource is specified through a keyname or other parameters.
+   */
+  getId(resource, requestOptions) {
+    if (typeof resource === "number") {
+      return Promise.resolve(resource);
+    } else if (typeof resource === "string" || isObject(resource)) {
+      return this.getOne(resource, requestOptions).then((res) => {
+        if (res) {
+          return res.resource.id;
+        }
+      });
+    }
+    return Promise.resolve(void 0);
+  }
+  /**
+   * A fast way to retrieve resource ID for any resource definition.
+   * @param resource - Any available resource definition
+   *
+   * @remarks
+   * Similar with {@link NgwConnector.getResourceId | getResourceId} but rise error if resource is not exist.
+   * To not make one more checks if the resource is definitely exists
+   */
+  getIdOrFail(resource, requestOptions) {
+    return this.getId(resource, requestOptions).then((resp) => {
+      if (resp === void 0) {
+        throw new Error();
+      }
+      return resp;
+    });
+  }
+  getMany(resource, requestOptions) {
+    return this._resourceCacheFilter(resource).then((items) => {
+      if (!items.length) {
+        const query = {};
+        if (resource.keyname) {
+          query.keyname = resource.keyname;
+        } else {
+          Object.assign(query, resourceToQuery(resource));
+        }
+        return this.connector.route("resource.search").get(__spreadProps$g(__spreadValues$u({}, requestOptions), {
+          query: __spreadValues$u({
+            serialization: "full"
+          }, query)
+        })).then((resources) => {
+          if ((requestOptions == null ? void 0 : requestOptions.cache) && resources) {
+            for (const x of resources) {
+              this.cache.add("resource.item", Promise.resolve(x), {
+                id: x.resource.id
+              });
+            }
+          }
+          return resources;
+        });
       }
       return items;
     });
   }
   getParent(resource, requestOptions) {
     return this.getOne(resource, requestOptions).then((child) => {
-      if (child) {
+      var _a, _b;
+      if ((_b = (_a = child == null ? void 0 : child.resource) == null ? void 0 : _a.parent) == null ? void 0 : _b.id) {
         return this.getOne(child.resource.parent.id, requestOptions);
       }
       return Promise.resolve(void 0);
@@ -1183,10 +2270,21 @@ class ResourcesControl {
       }
     });
   }
-  _getChildrenOf(parent, requestOptions, _items = []) {
-    return this.connector.get("resource.collection", requestOptions, {
-      parent
-    }).then((items) => {
+  _getChildrenOf(_0, _1) {
+    return __async$s(this, arguments, function* (parentDef, requestOptions, _items = []) {
+      let parent = void 0;
+      if (typeof parentDef === "string") {
+        parent = yield this.getId(parentDef, requestOptions);
+      } else if (typeof parentDef === "object") {
+        parent = parentDef.id;
+      } else {
+        parent = parentDef;
+      }
+      const items = yield this.connector.route("resource.collection").get(__spreadProps$g(__spreadValues$u({}, requestOptions), {
+        query: {
+          parent
+        }
+      }));
       const recursivePromises = [];
       for (const item of items) {
         if (requestOptions == null ? void 0 : requestOptions.cache) {
@@ -1235,7 +2333,7 @@ class ResourcesControl {
     });
   }
   _fetchResourceById(id, requestOptions) {
-    return this.connector.get("resource.item", requestOptions, { id });
+    return this.connector.route("resource.item", { id }).get(requestOptions);
   }
   _fetchResourceBy(resource, requestOptions) {
     return this.getMany(resource, requestOptions).then((resources) => {
@@ -1259,78 +2357,22 @@ class ResourcesControl {
         });
         return items;
       }
-    );
-  }
-}
-
-const CONNECTORS = [];
-function addConnector(connector) {
-  CONNECTORS.push(connector);
-}
-function findConnector(options) {
-  return CONNECTORS.find((x) => {
-    if (x.options.baseUrl === options.baseUrl) {
-      if (options.auth) {
-        if (x.options.auth) {
-          return objectDeepEqual(x.options.auth, options.auth);
-        }
-      } else {
-        return true;
-      }
-    }
-  });
-}
-function removeConnector(connector) {
-  const index = CONNECTORS.indexOf(connector);
-  if (index !== -1) {
-    CONNECTORS.splice(index, 1);
-  }
-}
-
-class AbortError extends Error {
-  constructor(message = "AbortError") {
-    super(message);
-    this.name = "AbortError";
-  }
-}
-
-var __defProp$G = Object.defineProperty;
-var __defNormalProp$G = (obj, key, value) => key in obj ? __defProp$G(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$r = (obj, key, value) => __defNormalProp$G(obj, typeof key !== "symbol" ? key + "" : key, value);
-class InsufficientPermissionsError extends NgwError {
-  constructor(obj) {
-    super(obj);
-    __publicField$r(this, "name", "InsufficientPermissionsError");
-    __publicField$r(this, "exception", "nextgisweb.core.exception.InsufficientPermissions");
-    Object.setPrototypeOf(this, InsufficientPermissionsError.prototype);
-  }
-}
-
-const templateRe = /\{ *([\w_-]+) *\}/g;
-function template(str, data) {
-  return str.replace(templateRe, (s, key) => {
-    let value = data[key];
-    if (value === void 0) {
-      throw new Error("No value provided for letiable " + s);
-    } else if (typeof value === "function") {
-      value = value(data);
-    }
-    return value;
-  });
+    );
+  }
 }
 
 var __defProp$F = Object.defineProperty;
-var __getOwnPropSymbols$v = Object.getOwnPropertySymbols;
-var __hasOwnProp$v = Object.prototype.hasOwnProperty;
-var __propIsEnum$v = Object.prototype.propertyIsEnumerable;
+var __getOwnPropSymbols$u = Object.getOwnPropertySymbols;
+var __hasOwnProp$u = Object.prototype.hasOwnProperty;
+var __propIsEnum$u = Object.prototype.propertyIsEnumerable;
 var __defNormalProp$F = (obj, key, value) => key in obj ? __defProp$F(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$u = (a, b) => {
+var __spreadValues$t = (a, b) => {
   for (var prop in b || (b = {}))
-    if (__hasOwnProp$v.call(b, prop))
+    if (__hasOwnProp$u.call(b, prop))
       __defNormalProp$F(a, prop, b[prop]);
-  if (__getOwnPropSymbols$v)
-    for (var prop of __getOwnPropSymbols$v(b)) {
-      if (__propIsEnum$v.call(b, prop))
+  if (__getOwnPropSymbols$u)
+    for (var prop of __getOwnPropSymbols$u(b)) {
+      if (__propIsEnum$u.call(b, prop))
         __defNormalProp$F(a, prop, b[prop]);
     }
   return a;
@@ -1376,343 +2418,57 @@ function apiRequest(opt) {
           url = template(url, replaceParams);
         }
       }
-      if (params) {
-        const paramArray = [];
-        const paramList = params.paramList;
-        if (Array.isArray(paramList)) {
-          paramList.forEach(([key, value]) => {
-            paramArray.push(`${key}=${value}`);
-          });
-        }
-        for (const p in params) {
-          if (apiItem.indexOf(p) === -1) {
-            paramArray.push(`${p}=${params[p]}`);
-          }
-        }
-        if (paramArray.length) {
-          url = `${url}?${paramArray.join("&")}`;
-        }
-      }
-      if (url) {
-        return connector.makeQuery(url, params, __spreadValues$u({
-          cacheName: name
-        }, requestOptions));
-      } else {
-        throw new Error("Request URL is not set");
-      }
-    } else {
-      return void 0;
-    }
-  });
-}
-
-var __defProp$E = Object.defineProperty;
-var __defNormalProp$E = (obj, key, value) => key in obj ? __defProp$E(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$q = (obj, key, value) => __defNormalProp$E(obj, key + "" , value);
-class NetworkError extends Error {
-  constructor(url) {
-    super();
-    __publicField$q(this, "name", "NetworkError");
-    Object.setPrototypeOf(this, NetworkError.prototype);
-    this.message = `Unable to request ${url}.
-    Possibly invalid NGW URL entered or CORS not configured to get request from ${location.origin}`;
-  }
-}
-
-let loadData;
-{
-  loadData = (url, callback, options = {}, error, onCancel) => {
-    options.method = options.method || "GET";
-    const xhr = new XMLHttpRequest();
-    xhr.open(options.method || "GET", url, true);
-    if (options.responseType === "blob") {
-      xhr.responseType = options.responseType;
-    }
-    const getResponseText = () => {
-      try {
-        return JSON.parse(xhr.responseText);
-      } catch (er) {
-        return xhr.responseText;
-      }
-    };
-    const processingResponse = (forError = false) => {
-      const cb = forError ? error : callback;
-      if (options.responseType === "blob") {
-        cb(xhr.response);
-      } else {
-        if (xhr.responseText) {
-          cb(getResponseText());
-        } else {
-          error({ message: "" });
-        }
-      }
-    };
-    xhr.onload = () => {
-      if ([401, 403, 404, 422, 500].indexOf(xhr.status) !== -1) {
-        error(new NgwError(getResponseText()));
-      }
-      processingResponse();
-    };
-    xhr.onerror = (er) => {
-      if (xhr.status === 0) {
-        error(new NetworkError(url));
-      } else {
-        error(er);
-      }
-    };
-    xhr.upload.onprogress = function(e) {
-      if (e.lengthComputable) {
-        const percentComplete = e.loaded / e.total * 100;
-        if (options.onProgress) {
-          options.onProgress(percentComplete, e);
-        }
-      }
-    };
-    const headers = options.headers;
-    if (headers) {
-      for (const h in headers) {
-        const header = headers[h];
-        if (typeof header === "string") {
-          xhr.setRequestHeader(h, header);
-        }
-      }
-    }
-    if (options.withCredentials !== void 0) {
-      xhr.withCredentials = options.withCredentials;
-    }
-    let data;
-    if (options.file) {
-      data = new FormData();
-      data.append("file", options.file);
-      if (options.data) {
-        for (const d in options.data) {
-          data.append(d, data[d]);
-        }
-      }
-    } else {
-      data = options.data ? typeof options.data === "string" ? options.data : JSON.stringify(options.data) : null;
-    }
-    if (onCancel) {
-      onCancel(() => {
-        xhr.abort();
-      });
-    }
-    xhr.send(data);
-  };
-}
-
-var __defProp$D = Object.defineProperty;
-var __defProps$d = Object.defineProperties;
-var __getOwnPropDescs$d = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$u = Object.getOwnPropertySymbols;
-var __hasOwnProp$u = Object.prototype.hasOwnProperty;
-var __propIsEnum$u = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$D = (obj, key, value) => key in obj ? __defProp$D(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$t = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp$u.call(b, prop))
-      __defNormalProp$D(a, prop, b[prop]);
-  if (__getOwnPropSymbols$u)
-    for (var prop of __getOwnPropSymbols$u(b)) {
-      if (__propIsEnum$u.call(b, prop))
-        __defNormalProp$D(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps$d = (a, b) => __defProps$d(a, __getOwnPropDescs$d(b));
-var __objRest$2 = (source, exclude) => {
-  var target = {};
-  for (var prop in source)
-    if (__hasOwnProp$u.call(source, prop) && exclude.indexOf(prop) < 0)
-      target[prop] = source[prop];
-  if (source != null && __getOwnPropSymbols$u)
-    for (var prop of __getOwnPropSymbols$u(source)) {
-      if (exclude.indexOf(prop) < 0 && __propIsEnum$u.call(source, prop))
-        target[prop] = source[prop];
-    }
-  return target;
-};
-var __publicField$p = (obj, key, value) => __defNormalProp$D(obj, typeof key !== "symbol" ? key + "" : key, value);
-var __async$q = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
-let ID$2 = 0;
-let REQUEST_ID = 0;
-class NgwConnector {
-  constructor(options) {
-    this.options = options;
-    __publicField$p(this, "id", ID$2++);
-    __publicField$p(this, "emitter", new EventEmitter());
-    __publicField$p(this, "user");
-    __publicField$p(this, "resources");
-    __publicField$p(this, "cache");
-    __publicField$p(this, "routeStr", "/api/component/pyramid/route");
-    __publicField$p(this, "activeRequests", {});
-    __publicField$p(this, "requestTransform");
-    const exist = findConnector(options);
-    this.cache = new Cache({ namespace: options.cacheId });
-    if (exist) {
-      return exist;
-    } else {
-      if (this.options.route) {
-        this.routeStr = this.options.route;
-      }
-      if (this.options.requestTransform) {
-        this.requestTransform = this.options.requestTransform;
-      }
-      this.resources = new ResourcesControl({
-        connector: this,
-        cacheId: options.cacheId
-      });
-      addConnector(this);
-    }
-  }
-  static create(options) {
-    return new this(options);
-  }
-  /**
-   * Clear the cache.
-   */
-  clearCache() {
-    this.cache.clean();
-    this.resources.cache.clean();
-  }
-  setRequestTransform(requestTransform) {
-    this.requestTransform = requestTransform;
-  }
-  /**
-   * Fast way to specify the connection address to NextGIS Web.
-   * The current connection will be severed.
-   * @param baseUrl - NGW url
-   */
-  setNgw(baseUrl) {
-    this.logout();
-    this.options.baseUrl = baseUrl;
-    addConnector(this);
-  }
-  /**
-   * Establishing a connection with NextGIS Web to fulfill all other requests.
-   * @remarks
-   * This method need not be called manually as it is used when forming a request in {@link apiRequest | apiRequest}.
-   * Can be used to check connection.
-   * @example
-   * ```javascript
-   * const connector = new NgwConnector({baseUrl: 'https://demo.nextgis.com'});
-   * connector.connect()
-   *   .then(() => console.log('Ok'))
-   *   .catch((er) => console.log('Connection problem', er));
-   * ```
-   */
-  connect() {
-    return __async$q(this, null, function* () {
-      const auth = this.options.auth;
-      if (auth) {
-        const { login, password } = auth;
-        if (login && password) {
-          yield this._login({ login, password });
-        }
-      }
-      return yield this.makeQuery(
-        this.routeStr,
-        {},
-        {
-          cacheName: "route",
-          cache: true,
-          cacheProps: {
-            id: this.id,
-            auth,
-            baseUrl: this.options.baseUrl
+      if (params) {
+        const paramArray = [];
+        const paramList = params.paramList;
+        if (Array.isArray(paramList)) {
+          paramList.forEach(([key, value]) => {
+            paramArray.push(`${key}=${value}`);
+          });
+        }
+        for (const p in params) {
+          if (apiItem.indexOf(p) === -1) {
+            paramArray.push(`${p}=${params[p]}`);
           }
         }
-      );
-    });
-  }
-  /**
-   * Quick way to change NextGIS Web user.
-   * @param credentials - New user credentials
-   */
-  login(credentials, options) {
-    this.logout();
-    addConnector(this);
-    return this._login(credentials, options);
-  }
-  /**
-   * Disconnecting a user. Aborting all current requests
-   */
-  logout() {
-    this.abort();
-    removeConnector(this);
-    this.options.auth = void 0;
-    this.user = void 0;
-    this.clearCache();
-    this.emitter.emit("logout");
-  }
-  getUserInfo(credentials, options) {
-    return __async$q(this, null, function* () {
-      if (this.user && this.user.id) {
-        return this.user;
+        if (paramArray.length) {
+          url = `${url}?${paramArray.join("&")}`;
+        }
       }
-      if (credentials) {
-        this.options.auth = credentials;
+      if (url) {
+        return connector.makeQuery(url, params, __spreadValues$t({
+          cacheName: name
+        }, requestOptions));
+      } else {
+        throw new Error("Request URL is not set");
       }
-      const options_ = __spreadValues$t({
-        headers: this.getAuthorizationHeaders(credentials)
-      }, options);
-      return this.makeQuery(
-        "/api/component/auth/current_user",
-        {},
-        options_
-      );
+    } else {
+      return void 0;
+    }
+  });
+}
+
+var __defProp$E = Object.defineProperty;
+var __defNormalProp$E = (obj, key, value) => key in obj ? __defProp$E(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$q = (obj, key, value) => __defNormalProp$E(obj, key + "" , value);
+class NgwConnectorExtended extends NgwConnector {
+  constructor(options) {
+    super(options);
+    __publicField$q(this, "resources");
+    this.resources = new ResourcesControl({
+      connector: this,
+      cacheId: options.cacheId
     });
   }
+  static create(options) {
+    return new this(options);
+  }
   /**
-   * Obtaining the required Headers for authentication of requests in the NGW.
+   * Clear the cache.
    */
-  getAuthorizationHeaders(credentials) {
-    const client = this.makeClientId(credentials);
-    if (client) {
-      return {
-        Authorization: `Basic ${client}`
-      };
-    }
-  }
-  makeClientId(credentials) {
-    credentials = credentials || this.options.auth;
-    if (credentials) {
-      const { login, password } = credentials;
-      const str = `${login}:${password}`;
-      const encodedStr = encodeURIComponent(str);
-      {
-        return window.btoa(encodedStr);
-      }
-    }
-  }
-  /** Stop all api requests */
-  abort() {
-    for (const abortController of Object.values(this.activeRequests)) {
-      abortController.abort();
-    }
-    this.activeRequests = {};
-  }
-  getActiveApiRequests() {
-    return __spreadValues$t({}, this.activeRequests);
+  clearCache() {
+    super.clearCache();
+    this.resources.cache.clean();
   }
   /**
    * Send request to NGW api router.
@@ -1831,74 +2587,6 @@ class NgwConnector {
       options
     );
   }
-  /**
-   * Send request to NGW.
-   * @param url - URL address to NGW
-   * @param params - Query params
-   * @param options - Request options
-   */
-  makeQuery(_0, _1) {
-    return __async$q(this, arguments, function* (url, params, options = {}) {
-      var _b;
-      url = (this.options.baseUrl ? this.options.baseUrl : "") + url;
-      if (!url) {
-        throw new Error("Empty `url` not allowed");
-      }
-      if (params) {
-        const _a = params, restParams = __objRest$2(_a, ["paramList"]);
-        url = template(url, restParams);
-      }
-      url = encodeURI(fixUrlStr(url));
-      const {
-        cache,
-        signal: externalSignal,
-        method = "GET",
-        headers,
-        cacheName,
-        cacheProps,
-        responseType,
-        withCredentials
-      } = options;
-      const internalAbortController = new AbortController();
-      const internalSignal = internalAbortController.signal;
-      if (externalSignal) {
-        if (externalSignal.aborted) {
-          throw new AbortError();
-        }
-        externalSignal.addEventListener("abort", () => {
-          internalAbortController.abort();
-        });
-      }
-      options.signal = internalSignal;
-      const createPromise = () => __async$q(this, null, function* () {
-        const id = REQUEST_ID++;
-        this.activeRequests[id] = internalAbortController;
-        try {
-          return this._loadData(url, options);
-        } finally {
-          this._cleanActiveRequest(id);
-        }
-      });
-      if (cache && method === "GET") {
-        const cacheOptions = cacheProps ? cacheProps : __spreadProps$d(__spreadValues$t({}, objectRemoveEmpty({
-          headers,
-          withCredentials,
-          responseType,
-          baseUrl: this.options.baseUrl,
-          userId: (_b = this.user) == null ? void 0 : _b.id
-        })), {
-          params
-        });
-        return this.cache.add(
-          cacheName || url,
-          createPromise,
-          cacheOptions,
-          false
-        );
-      }
-      return createPromise();
-    });
-  }
   // -------------------------------------------------------------------------
   // Resource Methods
   // -------------------------------------------------------------------------
@@ -1974,92 +2662,21 @@ class NgwConnector {
   deleteResource(resource) {
     return this.resources.delete(resource);
   }
-  /**
-   * @internal
-   */
-  _loadData(url, options) {
-    options.responseType = options.responseType || "json";
-    return new Promise((resolve, reject) => {
-      var _a;
-      if (this.user) {
-        options = options || {};
-        options.headers = __spreadValues$t(__spreadValues$t({}, this.getAuthorizationHeaders()), options.headers);
-      }
-      if (this.requestTransform) {
-        const [transUrl, transOptions] = this.requestTransform(url, options);
-        url = transUrl;
-        options = transOptions;
-      }
-      let runOnAbort = void 0;
-      loadData(url, resolve, options, reject, (handler) => {
-        runOnAbort = handler;
-      });
-      (_a = options.signal) == null ? void 0 : _a.addEventListener("abort", () => {
-        if (runOnAbort !== void 0) {
-          runOnAbort();
-        }
-        reject(new AbortError());
-      });
-    }).catch((httpError) => {
-      if (httpError.name !== "AbortError") {
-        {
-          console.warn("DEV WARN", httpError);
-        }
-        const er = this._handleHttpError(httpError);
-        if (er) {
-          throw er;
-        }
-      }
-      throw httpError;
-    });
-  }
-  _login(credentials, options) {
-    return __async$q(this, null, function* () {
-      try {
-        const data = yield this.getUserInfo(credentials, options);
-        this.user = data;
-        this.emitter.emit("login", data);
-        return data;
-      } catch (er) {
-        this.emitter.emit("login:error", er);
-        throw er;
-      }
-    });
-  }
-  _cleanActiveRequest(requestId) {
-    delete this.activeRequests[requestId];
-  }
-  _handleHttpError(er) {
-    if (er) {
-      if (er instanceof NgwError) {
-        if (er.exception === "nextgisweb.resource.exception.ResourceNotFound") {
-          throw new ResourceNotFoundError(er);
-        } else if (er.exception === "nextgisweb.core.exception.InsufficientPermissions") {
-          throw new InsufficientPermissionsError(er);
-        }
-      }
-    }
-    return er;
-  }
 }
-__publicField$p(NgwConnector, "errors", {
-  NgwError,
-  ResourceNotFoundError
-});
 
-var __defProp$C = Object.defineProperty;
+var __defProp$D = Object.defineProperty;
 var __getOwnPropSymbols$t = Object.getOwnPropertySymbols;
 var __hasOwnProp$t = Object.prototype.hasOwnProperty;
 var __propIsEnum$t = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$C = (obj, key, value) => key in obj ? __defProp$C(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __defNormalProp$D = (obj, key, value) => key in obj ? __defProp$D(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __spreadValues$s = (a, b) => {
   for (var prop in b || (b = {}))
     if (__hasOwnProp$t.call(b, prop))
-      __defNormalProp$C(a, prop, b[prop]);
+      __defNormalProp$D(a, prop, b[prop]);
   if (__getOwnPropSymbols$t)
     for (var prop of __getOwnPropSymbols$t(b)) {
       if (__propIsEnum$t.call(b, prop))
-        __defNormalProp$C(a, prop, b[prop]);
+        __defNormalProp$D(a, prop, b[prop]);
     }
   return a;
 };
@@ -2141,26 +2758,30 @@ function propertiesFilter(properties, filters) {
   return logic === "any" ? filters_.some(filterFunction) : filters_.every(filterFunction);
 }
 
-var __defProp$B = Object.defineProperty;
-var __defProps$c = Object.defineProperties;
-var __getOwnPropDescs$c = Object.getOwnPropertyDescriptors;
+const config = {
+  defaultRequestLimit: 7e3
+};
+
+var __defProp$C = Object.defineProperty;
+var __defProps$f = Object.defineProperties;
+var __getOwnPropDescs$f = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols$s = Object.getOwnPropertySymbols;
 var __hasOwnProp$s = Object.prototype.hasOwnProperty;
 var __propIsEnum$s = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$B = (obj, key, value) => key in obj ? __defProp$B(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __defNormalProp$C = (obj, key, value) => key in obj ? __defProp$C(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __spreadValues$r = (a, b) => {
   for (var prop in b || (b = {}))
     if (__hasOwnProp$s.call(b, prop))
-      __defNormalProp$B(a, prop, b[prop]);
+      __defNormalProp$C(a, prop, b[prop]);
   if (__getOwnPropSymbols$s)
     for (var prop of __getOwnPropSymbols$s(b)) {
       if (__propIsEnum$s.call(b, prop))
-        __defNormalProp$B(a, prop, b[prop]);
+        __defNormalProp$C(a, prop, b[prop]);
     }
   return a;
 };
-var __spreadProps$c = (a, b) => __defProps$c(a, __getOwnPropDescs$c(b));
-var __async$p = (__this, __arguments, generator) => {
+var __spreadProps$f = (a, b) => __defProps$f(a, __getOwnPropDescs$f(b));
+var __async$q = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
       try {
@@ -2196,15 +2817,12 @@ function createGeoJsonFeature(item) {
 }
 function updateItemRequestParam(params, options) {
   const { extensions, geom, fields, srs, ilike, like } = options;
-  const extensionsStr = extensions ? extensions.join(",") : "";
-  if (extensionsStr !== "*") {
-    params.extensions = extensionsStr;
-  }
-  if (fields !== void 0) {
-    params.fields = Array.isArray(fields) ? fields.join(",") : "";
+  params.extensions = extensions ? extensions : [];
+  if (fields) {
+    params.fields = fields;
   }
   if (geom !== void 0) {
-    params.geom = geom ? "yes" : "no";
+    params.geom = geom;
     if (!geom) {
       delete params.srs;
       delete params.geom_format;
@@ -2219,8 +2837,17 @@ function updateItemRequestParam(params, options) {
     params.srs = srs;
   }
 }
+function paramListToQuery(paramList) {
+  return paramList.reduce(
+    (acc, [key, value]) => {
+      acc[key] = value;
+      return acc;
+    },
+    {}
+  );
+}
 function createFeatureFieldFilterQueries(opt) {
-  return __async$p(this, null, function* () {
+  return __async$q(this, null, function* () {
     const queries = getQueries(opt);
     const itemsParts = yield Promise.all(queries);
     const ids = [];
@@ -2264,13 +2891,13 @@ function getQueries(opt, _queries = [], _parentAllParams = []) {
     for (const f of filters_) {
       if (isPropertyFilter(f)) {
         _queries.push(
-          fetchNgwLayerItemsRequest(__spreadProps$c(__spreadValues$r({}, opt), {
+          fetchNgwLayerItemsRequest(__spreadProps$f(__spreadValues$r({}, opt), {
             paramList: [..._parentAllParams, ...paramList, createParam(f)]
           }))
         );
       } else {
         getQueries(
-          __spreadProps$c(__spreadValues$r({}, opt), {
+          __spreadProps$f(__spreadValues$r({}, opt), {
             filters: f
           }),
           _queries,
@@ -2291,7 +2918,7 @@ function getQueries(opt, _queries = [], _parentAllParams = []) {
     if (propertiesFilterList.length) {
       for (const x of propertiesFilterList) {
         getQueries(
-          __spreadProps$c(__spreadValues$r({}, opt), {
+          __spreadProps$f(__spreadValues$r({}, opt), {
             filters: x
           }),
           _queries,
@@ -2300,7 +2927,7 @@ function getQueries(opt, _queries = [], _parentAllParams = []) {
       }
     } else {
       _queries.push(
-        fetchNgwLayerItemsRequest(__spreadProps$c(__spreadValues$r({}, opt), {
+        fetchNgwLayerItemsRequest(__spreadProps$f(__spreadValues$r({}, opt), {
           paramList: [..._parentAllParams, ...paramList, ...filters2]
         }))
       );
@@ -2319,6 +2946,7 @@ function fetchNgwLayerItemsRequest(options) {
   const params = __spreadValues$r({}, FEATURE_REQUEST_PARAMS);
   const {
     limit,
+    query,
     cache,
     signal,
     offset,
@@ -2329,12 +2957,10 @@ function fetchNgwLayerItemsRequest(options) {
     intersects,
     resourceId
   } = options;
-  if (limit) {
-    if (limit !== Number.POSITIVE_INFINITY) {
-      params.limit = limit;
-    }
+  if (limit && limit !== Number.POSITIVE_INFINITY) {
+    params.limit = limit;
   } else {
-    params.limit = 7e3;
+    params.limit = config.defaultRequestLimit;
   }
   if (offset) {
     params.offset = offset;
@@ -2353,38 +2979,31 @@ function fetchNgwLayerItemsRequest(options) {
     params.intersects = intersects;
   }
   if (paramList) {
-    params.paramList = paramList;
+    Object.assign(params, paramListToQuery(paramList));
   }
-  const reqParams = __spreadValues$r({
-    id: resourceId
-  }, params);
-  return connector.get(
-    "feature_layer.feature.collection",
-    { cache, signal },
-    reqParams
-  );
+  return connector.route("feature_layer.feature.collection", { id: Number(resourceId) }).get({ query: __spreadValues$r(__spreadValues$r({}, params), query), cache, signal });
 }
 
-var __defProp$A = Object.defineProperty;
-var __defProps$b = Object.defineProperties;
-var __getOwnPropDescs$b = Object.getOwnPropertyDescriptors;
+var __defProp$B = Object.defineProperty;
+var __defProps$e = Object.defineProperties;
+var __getOwnPropDescs$e = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols$r = Object.getOwnPropertySymbols;
 var __hasOwnProp$r = Object.prototype.hasOwnProperty;
 var __propIsEnum$r = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$A = (obj, key, value) => key in obj ? __defProp$A(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __defNormalProp$B = (obj, key, value) => key in obj ? __defProp$B(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __spreadValues$q = (a, b) => {
   for (var prop in b || (b = {}))
     if (__hasOwnProp$r.call(b, prop))
-      __defNormalProp$A(a, prop, b[prop]);
+      __defNormalProp$B(a, prop, b[prop]);
   if (__getOwnPropSymbols$r)
     for (var prop of __getOwnPropSymbols$r(b)) {
       if (__propIsEnum$r.call(b, prop))
-        __defNormalProp$A(a, prop, b[prop]);
+        __defNormalProp$B(a, prop, b[prop]);
     }
   return a;
 };
-var __spreadProps$b = (a, b) => __defProps$b(a, __getOwnPropDescs$b(b));
-var __async$o = (__this, __arguments, generator) => {
+var __spreadProps$e = (a, b) => __defProps$e(a, __getOwnPropDescs$e(b));
+var __async$p = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
       try {
@@ -2405,61 +3024,56 @@ var __async$o = (__this, __arguments, generator) => {
   });
 };
 function fetchNgwLayerItem(options) {
-  return __async$o(this, null, function* () {
+  return __async$p(this, null, function* () {
     const params = __spreadValues$q({}, FEATURE_REQUEST_PARAMS);
     updateItemRequestParam(params, options);
-    const queryParams = __spreadValues$q({
-      id: options.resourceId,
+    const resp = yield options.connector.route("feature_layer.feature.item", {
+      id: Number(options.resourceId),
       fid: options.featureId
-    }, params);
-    const resp = yield options.connector.get(
-      "feature_layer.feature.item",
-      options,
-      queryParams
-    );
-    const toGeojson = () => __async$o(this, null, function* () {
+    }).get(__spreadProps$e(__spreadValues$q({}, options), { query: params }));
+    const toGeojson = () => __async$p(this, null, function* () {
       if (resp.geom) {
         return createGeoJsonFeature(resp);
       } else {
-        const onlyGeomItem = yield fetchNgwLayerItem(__spreadProps$b(__spreadValues$q({}, options), {
+        const onlyGeomItem = yield fetchNgwLayerItem(__spreadProps$e(__spreadValues$q({}, options), {
           geom: true,
           fields: null,
           extensions: null
         }));
         const geom = onlyGeomItem.geom;
-        return createGeoJsonFeature(__spreadProps$b(__spreadValues$q({}, resp), { geom }));
+        return createGeoJsonFeature(__spreadProps$e(__spreadValues$q({}, resp), { geom }));
       }
     });
-    return __spreadProps$b(__spreadValues$q({}, resp), {
+    return __spreadProps$e(__spreadValues$q({}, resp), {
       toGeojson
     });
   });
 }
 
-var __defProp$z = Object.defineProperty;
+var __defProp$A = Object.defineProperty;
 var __getOwnPropSymbols$q = Object.getOwnPropertySymbols;
 var __hasOwnProp$q = Object.prototype.hasOwnProperty;
 var __propIsEnum$q = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$z = (obj, key, value) => key in obj ? __defProp$z(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __defNormalProp$A = (obj, key, value) => key in obj ? __defProp$A(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __spreadValues$p = (a, b) => {
   for (var prop in b || (b = {}))
     if (__hasOwnProp$q.call(b, prop))
-      __defNormalProp$z(a, prop, b[prop]);
+      __defNormalProp$A(a, prop, b[prop]);
   if (__getOwnPropSymbols$q)
     for (var prop of __getOwnPropSymbols$q(b)) {
       if (__propIsEnum$q.call(b, prop))
-        __defNormalProp$z(a, prop, b[prop]);
+        __defNormalProp$A(a, prop, b[prop]);
     }
   return a;
 };
-var __publicField$o = (obj, key, value) => __defNormalProp$z(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __publicField$p = (obj, key, value) => __defNormalProp$A(obj, typeof key !== "symbol" ? key + "" : key, value);
 class BookmarkItem {
   constructor(options) {
     this.options = options;
-    __publicField$o(this, "name");
-    __publicField$o(this, "resourceId");
-    __publicField$o(this, "item");
-    __publicField$o(this, "_extent");
+    __publicField$p(this, "name");
+    __publicField$p(this, "resourceId");
+    __publicField$p(this, "item");
+    __publicField$p(this, "_extent");
     this.resourceId = options.resourceId;
     const item = options.item;
     this.item = item;
@@ -2473,10 +3087,10 @@ class BookmarkItem {
     if (this._extent) {
       return Promise.resolve(this._extent);
     }
-    return this.options.connector.get("feature_layer.feature.item_extent", opt, {
+    return this.options.connector.route("feature_layer.feature.item_extent", {
       id: this.resourceId,
       fid: this.item.id
-    }).then((resp) => {
+    }).get(opt).then((resp) => {
       const { minLat, minLon, maxLat, maxLon } = resp.extent;
       const lonLat = [minLon, minLat, maxLon, maxLat];
       this._extent = lonLat;
@@ -2605,14 +3219,14 @@ function treeEvery_(item, filterFunc = (x) => !!x, relation, _filtered = []) {
   return true;
 }
 
-var __defProp$y = Object.defineProperty;
-var __defNormalProp$y = (obj, key, value) => key in obj ? __defProp$y(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$n = (obj, key, value) => __defNormalProp$y(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$z = Object.defineProperty;
+var __defNormalProp$z = (obj, key, value) => key in obj ? __defProp$z(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$o = (obj, key, value) => __defNormalProp$z(obj, typeof key !== "symbol" ? key + "" : key, value);
 class TreeHelper {
   constructor(item) {
-    __publicField$n(this, "item");
-    __publicField$n(this, "_children", []);
-    __publicField$n(this, "_parent");
+    __publicField$o(this, "item");
+    __publicField$o(this, "_children", []);
+    __publicField$o(this, "_parent");
     this.item = item;
   }
   setParent(parent) {
@@ -2675,19 +3289,19 @@ class TreeHelper {
   }
 }
 
-var __defProp$x = Object.defineProperty;
-var __defNormalProp$x = (obj, key, value) => key in obj ? __defProp$x(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$m = (obj, key, value) => __defNormalProp$x(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$y = Object.defineProperty;
+var __defNormalProp$y = (obj, key, value) => key in obj ? __defProp$y(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$n = (obj, key, value) => __defNormalProp$y(obj, typeof key !== "symbol" ? key + "" : key, value);
 class BaseProperty {
   constructor(name, item, options) {
-    __publicField$m(this, "options");
-    __publicField$m(this, "emitter", new EventEmitter());
-    __publicField$m(this, "name");
-    __publicField$m(this, "item");
-    __publicField$m(this, "_blocked", false);
-    __publicField$m(this, "_container");
-    __publicField$m(this, "_value");
-    __publicField$m(this, "_removeEventsListener");
+    __publicField$n(this, "options");
+    __publicField$n(this, "emitter", new EventEmitter());
+    __publicField$n(this, "name");
+    __publicField$n(this, "item");
+    __publicField$n(this, "_blocked", false);
+    __publicField$n(this, "_container");
+    __publicField$n(this, "_value");
+    __publicField$n(this, "_removeEventsListener");
     this.item = item;
     this.options = Object.assign({}, options);
     this.name = name;
@@ -2784,23 +3398,23 @@ class BaseProperty {
   }
 }
 
-var __defProp$w = Object.defineProperty;
+var __defProp$x = Object.defineProperty;
 var __getOwnPropSymbols$p = Object.getOwnPropertySymbols;
 var __hasOwnProp$p = Object.prototype.hasOwnProperty;
 var __propIsEnum$p = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$w = (obj, key, value) => key in obj ? __defProp$w(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __defNormalProp$x = (obj, key, value) => key in obj ? __defProp$x(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __spreadValues$o = (a, b) => {
   for (var prop in b || (b = {}))
     if (__hasOwnProp$p.call(b, prop))
-      __defNormalProp$w(a, prop, b[prop]);
+      __defNormalProp$x(a, prop, b[prop]);
   if (__getOwnPropSymbols$p)
     for (var prop of __getOwnPropSymbols$p(b)) {
       if (__propIsEnum$p.call(b, prop))
-        __defNormalProp$w(a, prop, b[prop]);
+        __defNormalProp$x(a, prop, b[prop]);
     }
   return a;
 };
-var __publicField$l = (obj, key, value) => __defNormalProp$w(obj, key + "" , value);
+var __publicField$m = (obj, key, value) => __defNormalProp$x(obj, key + "" , value);
 const _CheckProperty = class _CheckProperty extends BaseProperty {
   constructor(name, item, options) {
     super(name, item, __spreadValues$o(__spreadValues$o({}, _CheckProperty.options), options));
@@ -2908,7 +3522,7 @@ const _CheckProperty = class _CheckProperty extends BaseProperty {
     }
   }
 };
-__publicField$l(_CheckProperty, "options", {
+__publicField$m(_CheckProperty, "options", {
   hierarchy: true,
   bubble: false,
   propagation: false,
@@ -2917,31 +3531,31 @@ __publicField$l(_CheckProperty, "options", {
 });
 let CheckProperty = _CheckProperty;
 
-var __defProp$v = Object.defineProperty;
+var __defProp$w = Object.defineProperty;
 var __getOwnPropSymbols$o = Object.getOwnPropertySymbols;
 var __hasOwnProp$o = Object.prototype.hasOwnProperty;
 var __propIsEnum$o = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$v = (obj, key, value) => key in obj ? __defProp$v(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __defNormalProp$w = (obj, key, value) => key in obj ? __defProp$w(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __spreadValues$n = (a, b) => {
   for (var prop in b || (b = {}))
     if (__hasOwnProp$o.call(b, prop))
-      __defNormalProp$v(a, prop, b[prop]);
+      __defNormalProp$w(a, prop, b[prop]);
   if (__getOwnPropSymbols$o)
     for (var prop of __getOwnPropSymbols$o(b)) {
       if (__propIsEnum$o.call(b, prop))
-        __defNormalProp$v(a, prop, b[prop]);
+        __defNormalProp$w(a, prop, b[prop]);
     }
   return a;
 };
-var __publicField$k = (obj, key, value) => __defNormalProp$v(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __publicField$l = (obj, key, value) => __defNormalProp$w(obj, typeof key !== "symbol" ? key + "" : key, value);
 const BOOLEAN_TYPE = "boolean";
 const STRING_TYPE = "string";
 const _ItemProperties = class _ItemProperties {
   constructor(item, propertiesList) {
     this.item = item;
-    __publicField$k(this, "options", {});
-    __publicField$k(this, "_properties", {});
-    __publicField$k(this, "_propertiesList", []);
+    __publicField$l(this, "options", {});
+    __publicField$l(this, "_properties", {});
+    __publicField$l(this, "_propertiesList", []);
     if (propertiesList) {
       propertiesList.forEach(this._setPropertyHandler.bind(this));
     }
@@ -3004,35 +3618,35 @@ const _ItemProperties = class _ItemProperties {
     return Handler;
   }
 };
-__publicField$k(_ItemProperties, "handlers", {
+__publicField$l(_ItemProperties, "handlers", {
   CheckProperty
 });
 let ItemProperties = _ItemProperties;
 
-var __defProp$u = Object.defineProperty;
+var __defProp$v = Object.defineProperty;
 var __getOwnPropSymbols$n = Object.getOwnPropertySymbols;
 var __hasOwnProp$n = Object.prototype.hasOwnProperty;
 var __propIsEnum$n = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$u = (obj, key, value) => key in obj ? __defProp$u(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __defNormalProp$v = (obj, key, value) => key in obj ? __defProp$v(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __spreadValues$m = (a, b) => {
   for (var prop in b || (b = {}))
     if (__hasOwnProp$n.call(b, prop))
-      __defNormalProp$u(a, prop, b[prop]);
+      __defNormalProp$v(a, prop, b[prop]);
   if (__getOwnPropSymbols$n)
     for (var prop of __getOwnPropSymbols$n(b)) {
       if (__propIsEnum$n.call(b, prop))
-        __defNormalProp$u(a, prop, b[prop]);
+        __defNormalProp$v(a, prop, b[prop]);
     }
   return a;
 };
-var __publicField$j = (obj, key, value) => __defNormalProp$u(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __publicField$k = (obj, key, value) => __defNormalProp$v(obj, typeof key !== "symbol" ? key + "" : key, value);
 let ID$1 = 0;
 class Item {
   constructor(options) {
-    __publicField$j(this, "options", {});
-    __publicField$j(this, "properties");
-    __publicField$j(this, "tree");
-    __publicField$j(this, "id", ID$1);
+    __publicField$k(this, "options", {});
+    __publicField$k(this, "properties");
+    __publicField$k(this, "tree");
+    __publicField$k(this, "id", ID$1);
     ID$1 += 1;
     this.options = __spreadValues$m({}, options);
     this.tree = new TreeHelper(this);
@@ -3046,7 +3660,7 @@ class WebmapLayerOpacityPropertyHandler extends BaseProperty {
   getProperty() {
     const layer = this.item.layer;
     if (layer) {
-      return layer && layer.options && layer.options.opacity !== void 0 ? layer.options.opacity : 1;
+      return layer && layer.options && layer.options.opacity !== void 0 && layer.options.opacity !== null ? layer.options.opacity : 1;
     }
     return 1;
   }
@@ -3086,25 +3700,25 @@ class WebmapLayerOpacityPropertyHandler extends BaseProperty {
   }
 }
 
-var __defProp$t = Object.defineProperty;
-var __defProps$a = Object.defineProperties;
-var __getOwnPropDescs$a = Object.getOwnPropertyDescriptors;
+var __defProp$u = Object.defineProperty;
+var __defProps$d = Object.defineProperties;
+var __getOwnPropDescs$d = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols$m = Object.getOwnPropertySymbols;
 var __hasOwnProp$m = Object.prototype.hasOwnProperty;
 var __propIsEnum$m = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$t = (obj, key, value) => key in obj ? __defProp$t(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __defNormalProp$u = (obj, key, value) => key in obj ? __defProp$u(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __spreadValues$l = (a, b) => {
   for (var prop in b || (b = {}))
     if (__hasOwnProp$m.call(b, prop))
-      __defNormalProp$t(a, prop, b[prop]);
+      __defNormalProp$u(a, prop, b[prop]);
   if (__getOwnPropSymbols$m)
     for (var prop of __getOwnPropSymbols$m(b)) {
       if (__propIsEnum$m.call(b, prop))
-        __defNormalProp$t(a, prop, b[prop]);
+        __defNormalProp$u(a, prop, b[prop]);
     }
   return a;
 };
-var __spreadProps$a = (a, b) => __defProps$a(a, __getOwnPropDescs$a(b));
+var __spreadProps$d = (a, b) => __defProps$d(a, __getOwnPropDescs$d(b));
 function getNgwWebmapExtent(webmap) {
   const bottom = webmap["extent_bottom"];
   const left = webmap["extent_left"];
@@ -3127,7 +3741,7 @@ function fetchNgwLayerExtent({
   cache = true,
   signal
 }) {
-  return connector.get("layer.extent", { cache, signal }, { id: resourceId }).then((resp) => {
+  return connector.route("layer.extent", { id: Number(resourceId) }).get({ cache, signal }).then((resp) => {
     if (resp) {
       const { maxLat, maxLon, minLat, minLon } = resp.extent;
       const extentArray = [minLon, minLat, maxLon, maxLat];
@@ -3142,11 +3756,10 @@ function fetchNgwLayerItemExtent({
   cache = true,
   signal
 }) {
-  return connector.get(
-    "feature_layer.feature.item_extent",
-    { cache, signal },
-    { id: resourceId, fid: featureId }
-  ).then((resp) => {
+  return connector.route("feature_layer.feature.item_extent", {
+    id: Number(resourceId),
+    fid: featureId
+  }).get({ cache, signal }).then((resp) => {
     if (resp) {
       const { maxLat, maxLon, minLat, minLon } = resp.extent;
       const extentArray = [minLon, minLat, maxLon, maxLat];
@@ -3169,17 +3782,17 @@ function fetchNgwResourceExtent(item, connector, options) {
     return Promise.resolve(getNgwWebmapExtent(item.webmap));
   } else {
     const resource = item.resource;
-    if (resource.cls && resource.cls.indexOf("style") !== -1) {
+    if (resource.cls && resource.parent && resource.cls.indexOf("style") !== -1) {
       return connector.getResource(resource.parent.id, options).then((res) => {
         if (res) {
-          return fetchNgwLayerExtent(__spreadProps$a(__spreadValues$l({}, options), {
+          return fetchNgwLayerExtent(__spreadProps$d(__spreadValues$l({}, options), {
             resourceId: res.resource.id,
             connector
           }));
         }
       });
     } else {
-      return fetchNgwLayerExtent(__spreadProps$a(__spreadValues$l({}, options), {
+      return fetchNgwLayerExtent(__spreadProps$d(__spreadValues$l({}, options), {
         resourceId: resource.id,
         connector
       }));
@@ -3187,10 +3800,10 @@ function fetchNgwResourceExtent(item, connector, options) {
   }
 }
 
-var __defProp$s = Object.defineProperty;
-var __defNormalProp$s = (obj, key, value) => key in obj ? __defProp$s(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$i = (obj, key, value) => __defNormalProp$s(obj, typeof key !== "symbol" ? key + "" : key, value);
-var __async$n = (__this, __arguments, generator) => {
+var __defProp$t = Object.defineProperty;
+var __defNormalProp$t = (obj, key, value) => key in obj ? __defProp$t(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$j = (obj, key, value) => __defNormalProp$t(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __async$o = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
       try {
@@ -3212,18 +3825,18 @@ var __async$n = (__this, __arguments, generator) => {
 };
 class NgwResource {
   constructor() {
-    __publicField$i(this, "item");
-    __publicField$i(this, "connector");
-    __publicField$i(this, "_extent");
+    __publicField$j(this, "item");
+    __publicField$j(this, "connector");
+    __publicField$j(this, "_extent");
   }
   /** @deprecated use {@link NgwResource.getBounds} instead */
   getExtent() {
-    return __async$n(this, null, function* () {
+    return __async$o(this, null, function* () {
       return this.getBounds();
     });
   }
   getBounds(options) {
-    return __async$n(this, null, function* () {
+    return __async$o(this, null, function* () {
       if (this._extent) {
         return this._extent;
       }
@@ -3239,7 +3852,7 @@ class NgwResource {
   }
 }
 
-var __async$m = (__this, __arguments, generator) => {
+var __async$n = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
       try {
@@ -3260,7 +3873,7 @@ var __async$m = (__this, __arguments, generator) => {
   });
 };
 function resourceIdFromLayerOptions(options, connector) {
-  return __async$m(this, null, function* () {
+  return __async$n(this, null, function* () {
     const resource = options.resource;
     const item = resource;
     let { keyname, resourceId } = options;
@@ -3333,23 +3946,23 @@ function updateQmsOptions(qms) {
   };
 }
 
-var __defProp$r = Object.defineProperty;
+var __defProp$s = Object.defineProperty;
 var __getOwnPropSymbols$l = Object.getOwnPropertySymbols;
 var __hasOwnProp$l = Object.prototype.hasOwnProperty;
 var __propIsEnum$l = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$r = (obj, key, value) => key in obj ? __defProp$r(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __defNormalProp$s = (obj, key, value) => key in obj ? __defProp$s(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __spreadValues$k = (a, b) => {
   for (var prop in b || (b = {}))
     if (__hasOwnProp$l.call(b, prop))
-      __defNormalProp$r(a, prop, b[prop]);
+      __defNormalProp$s(a, prop, b[prop]);
   if (__getOwnPropSymbols$l)
     for (var prop of __getOwnPropSymbols$l(b)) {
       if (__propIsEnum$l.call(b, prop))
-        __defNormalProp$r(a, prop, b[prop]);
+        __defNormalProp$s(a, prop, b[prop]);
     }
   return a;
 };
-var __objRest$1 = (source, exclude) => {
+var __objRest$2 = (source, exclude) => {
   var target = {};
   for (var prop in source)
     if (__hasOwnProp$l.call(source, prop) && exclude.indexOf(prop) < 0)
@@ -3361,8 +3974,8 @@ var __objRest$1 = (source, exclude) => {
     }
   return target;
 };
-var __publicField$h = (obj, key, value) => __defNormalProp$r(obj, typeof key !== "symbol" ? key + "" : key, value);
-var __async$l = (__this, __arguments, generator) => {
+var __publicField$i = (obj, key, value) => __defNormalProp$s(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __async$m = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
       try {
@@ -3386,7 +3999,7 @@ const URL = "https://qms.nextgis.com";
 function createQmsAdapter(webMapOrOptions, url = URL, createOpt = {}) {
   let webMap;
   if ("webMap" in webMapOrOptions) {
-    const _a = webMapOrOptions, { webMap: webMap_, url: url_ } = _a, adapterOptions = __objRest$1(_a, ["webMap", "url"]);
+    const _a = webMapOrOptions, { webMap: webMap_, url: url_ } = _a, adapterOptions = __objRest$2(_a, ["webMap", "url"]);
     webMap = webMap_;
     if (url_) {
       url = url_;
@@ -3402,9 +4015,9 @@ function createQmsAdapter(webMapOrOptions, url = URL, createOpt = {}) {
   }
   class QmsAdapter {
     constructor(map, options) {
-      __publicField$h(this, "qms");
-      __publicField$h(this, "options");
-      __publicField$h(this, "map");
+      __publicField$i(this, "qms");
+      __publicField$i(this, "options");
+      __publicField$i(this, "map");
       this.map = map;
       const opt = __spreadValues$k(__spreadValues$k({}, createOpt), options);
       this.options = opt;
@@ -3414,7 +4027,7 @@ function createQmsAdapter(webMapOrOptions, url = URL, createOpt = {}) {
       }
     }
     addLayer(options) {
-      return __async$l(this, null, function* () {
+      return __async$m(this, null, function* () {
         if (!this.qms && options.qmsId) {
           try {
             this.qms = yield loadJson(
@@ -3458,29 +4071,29 @@ function createQmsAdapter(webMapOrOptions, url = URL, createOpt = {}) {
   return QmsAdapter;
 }
 
-var __defProp$q = Object.defineProperty;
+var __defProp$r = Object.defineProperty;
 var __getOwnPropSymbols$k = Object.getOwnPropertySymbols;
 var __hasOwnProp$k = Object.prototype.hasOwnProperty;
 var __propIsEnum$k = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$q = (obj, key, value) => key in obj ? __defProp$q(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __defNormalProp$r = (obj, key, value) => key in obj ? __defProp$r(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __spreadValues$j = (a, b) => {
   for (var prop in b || (b = {}))
     if (__hasOwnProp$k.call(b, prop))
-      __defNormalProp$q(a, prop, b[prop]);
+      __defNormalProp$r(a, prop, b[prop]);
   if (__getOwnPropSymbols$k)
     for (var prop of __getOwnPropSymbols$k(b)) {
       if (__propIsEnum$k.call(b, prop))
-        __defNormalProp$q(a, prop, b[prop]);
+        __defNormalProp$r(a, prop, b[prop]);
     }
   return a;
 };
-var __publicField$g = (obj, key, value) => __defNormalProp$q(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __publicField$h = (obj, key, value) => __defNormalProp$r(obj, typeof key !== "symbol" ? key + "" : key, value);
 class QmsKit {
   constructor(options) {
-    __publicField$g(this, "options", {
+    __publicField$h(this, "options", {
       url: "https://qms.nextgis.com"
     });
-    __publicField$g(this, "url");
+    __publicField$h(this, "url");
     this.options = __spreadValues$j(__spreadValues$j({}, this.options), options);
     this.url = this.options.url;
   }
@@ -3496,33 +4109,33 @@ class QmsKit {
     return createQmsAdapter({ webMap, url: this.url });
   }
 }
-__publicField$g(QmsKit, "utils", {
+__publicField$h(QmsKit, "utils", {
   createQmsAdapter
 });
 
-var __defProp$p = Object.defineProperty;
-var __defProps$9 = Object.defineProperties;
-var __getOwnPropDescs$9 = Object.getOwnPropertyDescriptors;
+var __defProp$q = Object.defineProperty;
+var __defProps$c = Object.defineProperties;
+var __getOwnPropDescs$c = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols$j = Object.getOwnPropertySymbols;
 var __getProtoOf$2 = Object.getPrototypeOf;
 var __hasOwnProp$j = Object.prototype.hasOwnProperty;
 var __propIsEnum$j = Object.prototype.propertyIsEnumerable;
 var __reflectGet$2 = Reflect.get;
-var __defNormalProp$p = (obj, key, value) => key in obj ? __defProp$p(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __defNormalProp$q = (obj, key, value) => key in obj ? __defProp$q(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __spreadValues$i = (a, b) => {
   for (var prop in b || (b = {}))
     if (__hasOwnProp$j.call(b, prop))
-      __defNormalProp$p(a, prop, b[prop]);
+      __defNormalProp$q(a, prop, b[prop]);
   if (__getOwnPropSymbols$j)
     for (var prop of __getOwnPropSymbols$j(b)) {
       if (__propIsEnum$j.call(b, prop))
-        __defNormalProp$p(a, prop, b[prop]);
+        __defNormalProp$q(a, prop, b[prop]);
     }
   return a;
 };
-var __spreadProps$9 = (a, b) => __defProps$9(a, __getOwnPropDescs$9(b));
+var __spreadProps$c = (a, b) => __defProps$c(a, __getOwnPropDescs$c(b));
 var __superGet$2 = (cls, obj, key) => __reflectGet$2(__getProtoOf$2(cls), key, obj);
-var __async$k = (__this, __arguments, generator) => {
+var __async$l = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
       try {
@@ -3543,7 +4156,7 @@ var __async$k = (__this, __arguments, generator) => {
   });
 };
 function createBasemapLayerAdapter(_0) {
-  return __async$k(this, arguments, function* ({
+  return __async$l(this, arguments, function* ({
     webMap,
     item
   }) {
@@ -3564,8 +4177,10 @@ function createBasemapLayerAdapter(_0) {
         if (TileAdapter) {
           class BasemapTileAdapter extends TileAdapter {
             addLayer(opt) {
-              return __async$k(this, null, function* () {
-                return __superGet$2(BasemapTileAdapter.prototype, this, "addLayer").call(this, __spreadProps$9(__spreadValues$i({}, opt), { url }));
+              return __async$l(this, null, function* () {
+                if (url) {
+                  return __superGet$2(BasemapTileAdapter.prototype, this, "addLayer").call(this, __spreadProps$c(__spreadValues$i({}, opt), { url }));
+                }
               });
             }
           }
@@ -3607,13 +4222,9 @@ function fetchNgwLayerCount({
   cache = true,
   signal
 }) {
-  return connector.get(
-    "feature_layer.feature.count",
-    { cache, signal },
-    {
-      id: resourceId
-    }
-  ).then((resp) => {
+  return connector.route("feature_layer.feature.count", {
+    id: resourceId
+  }).get({ cache, signal }).then((resp) => {
     return resp.total_count;
   });
 }
@@ -3644,26 +4255,26 @@ function prepareNgwFieldsToPropertiesFilter(fields) {
   return fields;
 }
 
-var __defProp$o = Object.defineProperty;
-var __defProps$8 = Object.defineProperties;
-var __getOwnPropDescs$8 = Object.getOwnPropertyDescriptors;
+var __defProp$p = Object.defineProperty;
+var __defProps$b = Object.defineProperties;
+var __getOwnPropDescs$b = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols$i = Object.getOwnPropertySymbols;
 var __hasOwnProp$i = Object.prototype.hasOwnProperty;
 var __propIsEnum$i = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$o = (obj, key, value) => key in obj ? __defProp$o(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __defNormalProp$p = (obj, key, value) => key in obj ? __defProp$p(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __spreadValues$h = (a, b) => {
   for (var prop in b || (b = {}))
     if (__hasOwnProp$i.call(b, prop))
-      __defNormalProp$o(a, prop, b[prop]);
+      __defNormalProp$p(a, prop, b[prop]);
   if (__getOwnPropSymbols$i)
     for (var prop of __getOwnPropSymbols$i(b)) {
       if (__propIsEnum$i.call(b, prop))
-        __defNormalProp$o(a, prop, b[prop]);
+        __defNormalProp$p(a, prop, b[prop]);
     }
   return a;
 };
-var __spreadProps$8 = (a, b) => __defProps$8(a, __getOwnPropDescs$8(b));
-var __async$j = (__this, __arguments, generator) => {
+var __spreadProps$b = (a, b) => __defProps$b(a, __getOwnPropDescs$b(b));
+var __async$k = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
       try {
@@ -3684,17 +4295,17 @@ var __async$j = (__this, __arguments, generator) => {
   });
 };
 function fetchNgwLayerItems(options) {
-  return __async$j(this, null, function* () {
+  return __async$k(this, null, function* () {
     var _a;
     const filters = options.filters;
     if (filters) {
-      let data = yield createFeatureFieldFilterQueries(__spreadProps$8(__spreadValues$h({}, options), {
+      let data = yield createFeatureFieldFilterQueries(__spreadProps$b(__spreadValues$h({}, options), {
         filters
       }));
       const clientFilterValidate = (_a = options.clientFilterValidate) != null ? _a : isFilterWithAnyCase(filters);
       if (clientFilterValidate) {
         data = data.filter((y) => {
-          const fields = prepareNgwFieldsToPropertiesFilter(__spreadProps$8(__spreadValues$h({}, y.fields), {
+          const fields = prepareNgwFieldsToPropertiesFilter(__spreadProps$b(__spreadValues$h({}, y.fields), {
             id: y.id
           }));
           const result = propertiesFilter(fields, filters);
@@ -3723,7 +4334,7 @@ function isFilterWithAnyCase(filters) {
   return false;
 }
 
-var __async$i = (__this, __arguments, generator) => {
+var __async$j = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
       try {
@@ -3744,7 +4355,7 @@ var __async$i = (__this, __arguments, generator) => {
   });
 };
 function fetchNgwLayerFeatures(options) {
-  return __async$i(this, null, function* () {
+  return __async$j(this, null, function* () {
     const x = yield fetchNgwLayerItems(options);
     const features = [];
     x.forEach((y) => {
@@ -3782,30 +4393,30 @@ function getLayerFilterOptions(options) {
   return filterOptions;
 }
 
-var __defProp$n = Object.defineProperty;
-var __defProps$7 = Object.defineProperties;
-var __getOwnPropDescs$7 = Object.getOwnPropertyDescriptors;
+var __defProp$o = Object.defineProperty;
+var __defProps$a = Object.defineProperties;
+var __getOwnPropDescs$a = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols$h = Object.getOwnPropertySymbols;
 var __getProtoOf$1 = Object.getPrototypeOf;
 var __hasOwnProp$h = Object.prototype.hasOwnProperty;
 var __propIsEnum$h = Object.prototype.propertyIsEnumerable;
 var __reflectGet$1 = Reflect.get;
-var __defNormalProp$n = (obj, key, value) => key in obj ? __defProp$n(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __defNormalProp$o = (obj, key, value) => key in obj ? __defProp$o(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __spreadValues$g = (a, b) => {
   for (var prop in b || (b = {}))
     if (__hasOwnProp$h.call(b, prop))
-      __defNormalProp$n(a, prop, b[prop]);
+      __defNormalProp$o(a, prop, b[prop]);
   if (__getOwnPropSymbols$h)
     for (var prop of __getOwnPropSymbols$h(b)) {
       if (__propIsEnum$h.call(b, prop))
-        __defNormalProp$n(a, prop, b[prop]);
+        __defNormalProp$o(a, prop, b[prop]);
     }
   return a;
 };
-var __spreadProps$7 = (a, b) => __defProps$7(a, __getOwnPropDescs$7(b));
-var __publicField$f = (obj, key, value) => __defNormalProp$n(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __spreadProps$a = (a, b) => __defProps$a(a, __getOwnPropDescs$a(b));
+var __publicField$g = (obj, key, value) => __defNormalProp$o(obj, typeof key !== "symbol" ? key + "" : key, value);
 var __superGet$1 = (cls, obj, key) => __reflectGet$1(__getProtoOf$1(cls), key, obj);
-var __async$h = (__this, __arguments, generator) => {
+var __async$i = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
       try {
@@ -3826,7 +4437,7 @@ var __async$h = (__this, __arguments, generator) => {
   });
 };
 function createGeoJsonAdapter(props) {
-  return __async$h(this, null, function* () {
+  return __async$i(this, null, function* () {
     var _a, _b;
     const {
       item,
@@ -3849,7 +4460,7 @@ function createGeoJsonAdapter(props) {
         return feature && createPopupContent(feature, item);
       };
     }
-    const getData = (filters, filterOpt) => __async$h(this, null, function* () {
+    const getData = (filters, filterOpt) => __async$i(this, null, function* () {
       abort();
       internalAbortController = new AbortController();
       const internalSignal = internalAbortController.signal;
@@ -3876,14 +4487,14 @@ function createGeoJsonAdapter(props) {
     class NgwGeoJsonAdapter extends GeoJsonAdapter {
       constructor() {
         super(...arguments);
-        __publicField$f(this, "emitter", new EventEmitter());
-        __publicField$f(this, "__onMapMove");
-        __publicField$f(this, "__onMapMoveStart");
-        __publicField$f(this, "__enableMapMoveListener");
-        __publicField$f(this, "__disableMapMoveListener");
+        __publicField$g(this, "emitter", new EventEmitter());
+        __publicField$g(this, "__onMapMove");
+        __publicField$g(this, "__onMapMoveStart");
+        __publicField$g(this, "__enableMapMoveListener");
+        __publicField$g(this, "__disableMapMoveListener");
       }
       addLayer(opt) {
-        return __async$h(this, null, function* () {
+        return __async$i(this, null, function* () {
           let needUpdate = !opt.data;
           const waitFullLoad = opt.waitFullLoad !== void 0 ? opt.waitFullLoad : true;
           if (options.id !== void 0) {
@@ -3928,7 +4539,7 @@ function createGeoJsonAdapter(props) {
         return this.getBounds();
       }
       getBounds() {
-        return __async$h(this, null, function* () {
+        return __async$i(this, null, function* () {
           const hasData = this.getLayers && this.getLayers().length;
           const strategy = this.options.strategy;
           if ((strategy == null ? void 0 : strategy.startsWith("BBOX")) || hasData) {
@@ -3953,10 +4564,10 @@ function createGeoJsonAdapter(props) {
       getCount() {
         return fetchNgwLayerCount({ connector, resourceId, cache: true });
       }
-      updateLayer(filterArgs) {
-        return __async$h(this, null, function* () {
+      updateLayer(opt) {
+        return __async$i(this, null, function* () {
           var _a2;
-          filterArgs = filterArgs || _lastFilterArgs || {};
+          const filterArgs = opt || _lastFilterArgs || {};
           if ((_a2 = this.options.strategy) == null ? void 0 : _a2.startsWith("BBOX")) {
             yield webMap.onLoad("create");
             filterArgs.options = filterArgs.options || {};
@@ -3981,7 +4592,7 @@ function createGeoJsonAdapter(props) {
           try {
             this.emitter.emit("preupdate", filterArgs);
             webMap._emitLayerEvent("layer:preupdate", options.id || "", filterArgs);
-            const data = yield getData(filterArgs.filters, __spreadProps$7(__spreadValues$g({}, filterArgs.options), {
+            const data = yield getData(filterArgs.filters, __spreadProps$a(__spreadValues$g({}, filterArgs.options), {
               srs: this.options.srs
             }));
             let newData = data;
@@ -4010,7 +4621,7 @@ function createGeoJsonAdapter(props) {
               isFull: _fullDataLoad
             });
           } catch (er) {
-            if (er instanceof Error && er.name !== "CancelError") {
+            if (er instanceof Error && er.name !== "AbortError") {
               throw er;
             }
           }
@@ -4020,7 +4631,7 @@ function createGeoJsonAdapter(props) {
         });
       }
       propertiesFilter(filters, opt) {
-        return __async$h(this, null, function* () {
+        return __async$i(this, null, function* () {
           abort();
           if (this.filter && _fullDataLoad) {
             this.filter((e) => {
@@ -4034,7 +4645,7 @@ function createGeoJsonAdapter(props) {
             if (this.clearLayer) {
               this.clearLayer();
             }
-            const data = yield getData(filters, __spreadProps$7(__spreadValues$g({}, opt), {
+            const data = yield getData(filters, __spreadProps$a(__spreadValues$g({}, opt), {
               srs: this.options.srs
             }));
             this.setData(data);
@@ -4094,7 +4705,7 @@ function createGeoJsonAdapter(props) {
   });
 }
 
-var __async$g = (__this, __arguments, generator) => {
+var __async$h = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
       try {
@@ -4115,7 +4726,7 @@ var __async$g = (__this, __arguments, generator) => {
   });
 };
 function createWebMapAdapter(_0) {
-  return __async$g(this, arguments, function* ({
+  return __async$h(this, arguments, function* ({
     layerOptions: options,
     webMap,
     connector
@@ -4223,27 +4834,27 @@ function ngwApiToAdapterOptions({
   }
 }
 
-var __defProp$m = Object.defineProperty;
-var __defProps$6 = Object.defineProperties;
-var __getOwnPropDescs$6 = Object.getOwnPropertyDescriptors;
+var __defProp$n = Object.defineProperty;
+var __defProps$9 = Object.defineProperties;
+var __getOwnPropDescs$9 = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols$g = Object.getOwnPropertySymbols;
 var __hasOwnProp$g = Object.prototype.hasOwnProperty;
 var __propIsEnum$g = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$m = (obj, key, value) => key in obj ? __defProp$m(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __defNormalProp$n = (obj, key, value) => key in obj ? __defProp$n(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __spreadValues$f = (a, b) => {
   for (var prop in b || (b = {}))
     if (__hasOwnProp$g.call(b, prop))
-      __defNormalProp$m(a, prop, b[prop]);
+      __defNormalProp$n(a, prop, b[prop]);
   if (__getOwnPropSymbols$g)
     for (var prop of __getOwnPropSymbols$g(b)) {
       if (__propIsEnum$g.call(b, prop))
-        __defNormalProp$m(a, prop, b[prop]);
+        __defNormalProp$n(a, prop, b[prop]);
     }
   return a;
 };
-var __spreadProps$6 = (a, b) => __defProps$6(a, __getOwnPropDescs$6(b));
-var __publicField$e = (obj, key, value) => __defNormalProp$m(obj, typeof key !== "symbol" ? key + "" : key, value);
-var __async$f = (__this, __arguments, generator) => {
+var __spreadProps$9 = (a, b) => __defProps$9(a, __getOwnPropDescs$9(b));
+var __publicField$f = (obj, key, value) => __defNormalProp$n(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __async$g = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
       try {
@@ -4263,11 +4874,47 @@ var __async$f = (__this, __arguments, generator) => {
     step((generator = generator.apply(__this, __arguments)).next());
   });
 };
+class Legend {
+  constructor({
+    layerId,
+    legend,
+    onSymbolRenderChange
+  }) {
+    __publicField$f(this, "layerId");
+    __publicField$f(this, "legend");
+    __publicField$f(this, "onSymbolRenderChange");
+    this.layerId = layerId;
+    this.legend = this.createLegend(legend);
+    this.onSymbolRenderChange = onSymbolRenderChange;
+  }
+  createLegend(items) {
+    return items.map((params) => __spreadProps$9(__spreadValues$f({}, params), {
+      /** @deprecated use display_name instead */
+      name: params.display_name,
+      /** @deprecated use icon instead */
+      symbol: params.icon
+    }));
+  }
+  setSymbolRender(symbolIndex, status) {
+    const legendItem = this.legend.find((l) => l.index === symbolIndex);
+    if (legendItem) {
+      const render = legendItem.render;
+      if (render !== status) {
+        legendItem.render = status;
+        if (this.onSymbolRenderChange) {
+          this.onSymbolRenderChange(
+            this.legend.filter((l) => l.render).map((l) => l.index)
+          );
+        }
+      }
+    }
+  }
+}
 function createRasterAdapter(_0) {
-  return __async$f(this, arguments, function* ({
+  return __async$g(this, arguments, function* ({
     layerOptions,
-    webMap,
     connector,
+    webMap,
     item
   }) {
     const resourceCls = item.resource.cls;
@@ -4296,16 +4943,17 @@ function createRasterAdapter(_0) {
         constructor(map, _options) {
           super(map, _options);
           this.map = map;
-          // options = {};
-          __publicField$e(this, "item", item);
-          __publicField$e(this, "resourceId", resourceId);
+          __publicField$f(this, "item", item);
+          __publicField$f(this, "resourceId", resourceId);
+          __publicField$f(this, "_blocked", false);
+          __publicField$f(this, "_layerVisibility");
           const opt = ngwApiToAdapterOptions({
             options: layerOptions,
             webMap,
             baseUrl: connector.options.baseUrl || ""
           });
           if (opt) {
-            const layerAdapterOptions = __spreadProps$6(__spreadValues$f(__spreadValues$f({}, opt), layerOptions.adapterOptions), {
+            const layerAdapterOptions = __spreadProps$9(__spreadValues$f(__spreadValues$f({}, opt), layerOptions.adapterOptions), {
               params: { resource: resourceId },
               layers: opt.layers || String(resourceId),
               resourceId
@@ -4319,42 +4967,98 @@ function createRasterAdapter(_0) {
         addLayer(addOptions) {
           return super.addLayer(__spreadValues$f(__spreadValues$f({}, this.options), addOptions));
         }
-        getLegend(options) {
-          return __async$f(this, null, function* () {
-            const ngwLegend = yield connector.get("render.legend_symbols", __spreadValues$f({
-              params: { id: resourceId },
-              cache: true
-            }, options));
-            const id = this.options.id;
-            if (id !== void 0) {
-              const legend = {
-                layerId: id,
-                legend: ngwLegend.map(({ display_name, icon }) => ({
-                  name: display_name,
-                  symbol: icon
-                }))
-              };
-              return [legend];
+        showLayer() {
+          this._layerVisibility = true;
+          if (this.layer) {
+            if (!this._blocked) {
+              webMap.mapAdapter.showLayer(this.layer);
             }
-            return [];
-          });
+          }
+        }
+        hideLayer() {
+          this._layerVisibility = false;
+          if (this.layer) {
+            webMap.mapAdapter.hideLayer(this.layer);
+          }
         }
         getIdentificationIds() {
-          return __async$f(this, null, function* () {
+          return __async$g(this, null, function* () {
             if (this.item) {
               if (adapter === "MVT") {
                 return [this.item.resource.id];
               }
-              const id = this.item.resource.parent.id;
-              if (defined(id)) {
-                return [id];
+              if (this.item.resource.parent) {
+                const id = this.item.resource.parent.id;
+                if (defined(id)) {
+                  return [id];
+                }
               }
             }
             return [];
           });
         }
-        // beforeRemove() {
-        // }
+        getLegend(options) {
+          return __async$g(this, null, function* () {
+            const id = this.options.id;
+            if (id !== void 0) {
+              const ngwLegend = yield connector.route("render.legend_symbols", { id: resourceId }).get(__spreadValues$f({
+                cache: true
+              }, options));
+              const legend = new Legend({
+                layerId: id,
+                legend: ngwLegend,
+                onSymbolRenderChange: this._setLegendSymbol.bind(this)
+              });
+              return [legend];
+            }
+            return [];
+          });
+        }
+        _hideLayer() {
+          if (this.options.id) {
+            webMap.mapAdapter.hideLayer(this.layer);
+          }
+        }
+        _showLayer() {
+          if (this.options.id) {
+            if (this._layerVisibility) {
+              webMap.showLayer(this.options.id, { silent: true });
+            }
+          }
+        }
+        _setLegendSymbol(renderIndexes) {
+          const intervals = this._consolidateIntervals(renderIndexes);
+          if (!intervals.length) {
+            this._hideLayer();
+            this._blocked = true;
+          } else {
+            this._blocked = false;
+            this._showLayer();
+          }
+          if (this.updateLayer) {
+            this.updateLayer({
+              params: {
+                [`symbols[${resourceId}]`]: intervals.join(",") || void 0
+              }
+            });
+          }
+        }
+        _consolidateIntervals(symbols) {
+          const sortedSymbols = symbols.slice().sort((a, b) => a - b);
+          const intervals = [];
+          let start = sortedSymbols[0];
+          let end = start;
+          for (let i = 1; i <= sortedSymbols.length; i++) {
+            if (sortedSymbols[i] === end + 1) {
+              end = sortedSymbols[i];
+            } else {
+              intervals.push(start === end ? `${start}` : `${start}-${end}`);
+              start = sortedSymbols[i];
+              end = start;
+            }
+          }
+          return intervals;
+        }
       };
     } else {
       throw new Error(adapter + " not supported yet. Only TILE");
@@ -4362,26 +5066,26 @@ function createRasterAdapter(_0) {
   });
 }
 
-var __defProp$l = Object.defineProperty;
-var __defProps$5 = Object.defineProperties;
-var __getOwnPropDescs$5 = Object.getOwnPropertyDescriptors;
+var __defProp$m = Object.defineProperty;
+var __defProps$8 = Object.defineProperties;
+var __getOwnPropDescs$8 = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols$f = Object.getOwnPropertySymbols;
 var __hasOwnProp$f = Object.prototype.hasOwnProperty;
 var __propIsEnum$f = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$l = (obj, key, value) => key in obj ? __defProp$l(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __defNormalProp$m = (obj, key, value) => key in obj ? __defProp$m(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __spreadValues$e = (a, b) => {
   for (var prop in b || (b = {}))
     if (__hasOwnProp$f.call(b, prop))
-      __defNormalProp$l(a, prop, b[prop]);
+      __defNormalProp$m(a, prop, b[prop]);
   if (__getOwnPropSymbols$f)
     for (var prop of __getOwnPropSymbols$f(b)) {
       if (__propIsEnum$f.call(b, prop))
-        __defNormalProp$l(a, prop, b[prop]);
+        __defNormalProp$m(a, prop, b[prop]);
     }
   return a;
 };
-var __spreadProps$5 = (a, b) => __defProps$5(a, __getOwnPropDescs$5(b));
-var __async$e = (__this, __arguments, generator) => {
+var __spreadProps$8 = (a, b) => __defProps$8(a, __getOwnPropDescs$8(b));
+var __async$f = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
       try {
@@ -4417,7 +5121,7 @@ const supportCls = [
   "tmsclient_layer"
 ];
 function createAdapterFromFirstStyle(_0) {
-  return __async$e(this, arguments, function* ({
+  return __async$f(this, arguments, function* ({
     layerOptions,
     webMap,
     connector,
@@ -4428,7 +5132,7 @@ function createAdapterFromFirstStyle(_0) {
     const firstStyle = childrenStyles && childrenStyles[0];
     if (firstStyle) {
       return createAsyncAdapter(
-        __spreadProps$5(__spreadValues$e({}, layerOptions), { resource: firstStyle.resource.id }),
+        __spreadProps$8(__spreadValues$e({}, layerOptions), { resource: firstStyle.resource.id }),
         webMap,
         connector
       );
@@ -4436,7 +5140,7 @@ function createAdapterFromFirstStyle(_0) {
   });
 }
 function createAsyncAdapter(options, webMap, connector) {
-  return __async$e(this, null, function* () {
+  return __async$f(this, null, function* () {
     let adapter;
     let item;
     const adapterType = options.adapter;
@@ -4451,13 +5155,13 @@ function createAsyncAdapter(options, webMap, connector) {
       }
       if (item) {
         const cls = item.resource.cls;
-        const layerOptions = __spreadProps$5(__spreadValues$e({}, options), {
+        const layerOptions = __spreadProps$8(__spreadValues$e({}, options), {
           resource: resourceId
         });
         const adapterOptions = {
           layerOptions,
-          webMap,
           connector,
+          webMap,
           item
         };
         if (supportCls.indexOf(cls) !== -1) {
@@ -4483,15 +5187,15 @@ function createAsyncAdapter(options, webMap, connector) {
           } else if (cls === "basemap_layer") {
             adapter = createBasemapLayerAdapter(adapterOptions);
           } else {
-            if (adapterType === "GEOJSON") {
+            if (adapterType === "GEOJSON" && item.resource.parent) {
               const parentItem = yield connector.getResource(
                 item.resource.parent.id
               );
               if (parentItem) {
-                const parentOptions = __spreadProps$5(__spreadValues$e({}, options), {
+                const parentOptions = __spreadProps$8(__spreadValues$e({}, options), {
                   resource: item.resource.parent.id
                 });
-                adapter = createGeoJsonAdapter(__spreadProps$5(__spreadValues$e({}, adapterOptions), {
+                adapter = createGeoJsonAdapter(__spreadProps$8(__spreadValues$e({}, adapterOptions), {
                   item: parentItem,
                   layerOptions: parentOptions
                 }));
@@ -4535,31 +5239,46 @@ function createAsyncAdapter(options, webMap, connector) {
   });
 }
 
-var __defProp$k = Object.defineProperty;
+var __defProp$l = Object.defineProperty;
+var __defProps$7 = Object.defineProperties;
+var __getOwnPropDescs$7 = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols$e = Object.getOwnPropertySymbols;
 var __hasOwnProp$e = Object.prototype.hasOwnProperty;
 var __propIsEnum$e = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$k = (obj, key, value) => key in obj ? __defProp$k(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __defNormalProp$l = (obj, key, value) => key in obj ? __defProp$l(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __spreadValues$d = (a, b) => {
   for (var prop in b || (b = {}))
     if (__hasOwnProp$e.call(b, prop))
-      __defNormalProp$k(a, prop, b[prop]);
+      __defNormalProp$l(a, prop, b[prop]);
   if (__getOwnPropSymbols$e)
     for (var prop of __getOwnPropSymbols$e(b)) {
       if (__propIsEnum$e.call(b, prop))
-        __defNormalProp$k(a, prop, b[prop]);
+        __defNormalProp$l(a, prop, b[prop]);
     }
   return a;
 };
+var __spreadProps$7 = (a, b) => __defProps$7(a, __getOwnPropDescs$7(b));
+var __objRest$1 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$e.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$e)
+    for (var prop of __getOwnPropSymbols$e(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$e.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
 function updateImageParams(params, resourceId) {
-  const { bbox, width, height, nd } = params;
-  return {
+  const _a = params, { bbox, width, height, nd } = _a, rest = __objRest$1(_a, ["bbox", "width", "height", "nd"]);
+  return __spreadProps$7(__spreadValues$d({}, rest), {
     resource: Array.isArray(resourceId) ? resourceId.join(",") : resourceId,
     extent: bbox,
     size: width + "," + height,
     timestamp: Date.now(),
     nd: nd != null ? nd : 200
-  };
+  });
 }
 const vectorLayerGeomToPaintTypeAlias = {
   POINT: "point",
@@ -4580,6 +5299,9 @@ function createNgwLayerAdapter(options, webMap, connector) {
   if (headers) {
     options.headers = headers;
   }
+  if (connector.withCredentials !== void 0) {
+    options.withCredentials = connector.withCredentials;
+  }
   return createAsyncAdapter(options, webMap, connector);
 }
 function extendNgwWebmapLayerAdapter(opt) {
@@ -4616,24 +5338,27 @@ function setScaleRatio(scale, lat = 0) {
   return zoom;
 }
 
-var __defProp$j = Object.defineProperty;
+var __defProp$k = Object.defineProperty;
+var __defProps$6 = Object.defineProperties;
+var __getOwnPropDescs$6 = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols$d = Object.getOwnPropertySymbols;
 var __hasOwnProp$d = Object.prototype.hasOwnProperty;
 var __propIsEnum$d = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$j = (obj, key, value) => key in obj ? __defProp$j(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __defNormalProp$k = (obj, key, value) => key in obj ? __defProp$k(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __spreadValues$c = (a, b) => {
   for (var prop in b || (b = {}))
     if (__hasOwnProp$d.call(b, prop))
-      __defNormalProp$j(a, prop, b[prop]);
+      __defNormalProp$k(a, prop, b[prop]);
   if (__getOwnPropSymbols$d)
     for (var prop of __getOwnPropSymbols$d(b)) {
       if (__propIsEnum$d.call(b, prop))
-        __defNormalProp$j(a, prop, b[prop]);
+        __defNormalProp$k(a, prop, b[prop]);
     }
   return a;
 };
-var __publicField$d = (obj, key, value) => __defNormalProp$j(obj, typeof key !== "symbol" ? key + "" : key, value);
-var __async$d = (__this, __arguments, generator) => {
+var __spreadProps$6 = (a, b) => __defProps$6(a, __getOwnPropDescs$6(b));
+var __publicField$e = (obj, key, value) => __defNormalProp$k(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __async$e = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
       try {
@@ -4657,11 +5382,11 @@ const _NgwWebmapItem = class _NgwWebmapItem extends Item {
   constructor(webMap, item, options, connector, parent, noInit) {
     super(__spreadValues$c(__spreadValues$c({}, _NgwWebmapItem.options), options));
     this.webMap = webMap;
-    __publicField$d(this, "item");
-    __publicField$d(this, "connector");
-    __publicField$d(this, "layer");
-    __publicField$d(this, "emitter", new EventEmitter());
-    __publicField$d(this, "_rootDescendantsCount", 0);
+    __publicField$e(this, "item");
+    __publicField$e(this, "connector");
+    __publicField$e(this, "layer");
+    __publicField$e(this, "emitter", new EventEmitter());
+    __publicField$e(this, "_rootDescendantsCount", 0);
     if (connector) {
       this.connector = connector;
     }
@@ -4683,7 +5408,7 @@ const _NgwWebmapItem = class _NgwWebmapItem extends Item {
     }
   }
   static create(webMap, item, options, connector, parent) {
-    return __async$d(this, null, function* () {
+    return __async$e(this, null, function* () {
       const ngwWebmapItem = new _NgwWebmapItem(
         webMap,
         item,
@@ -4712,21 +5437,21 @@ const _NgwWebmapItem = class _NgwWebmapItem extends Item {
     return this.layer;
   }
   getLegend(options) {
-    return __async$d(this, null, function* () {
+    return __async$e(this, null, function* () {
       var _a;
       const id = (_a = this.layer) == null ? void 0 : _a.id;
       if (id !== void 0) {
         const connector = this.connector;
-        if (connector) {
-          const ngwLegend = yield connector.get("render.legend_symbols", __spreadValues$c({
-            params: { id: this.item.resourceId }
-          }, options));
+        if (connector && "resourceId" in this.item) {
+          const ngwLegend = yield connector.route("render.legend_symbols", { id: Number(this.item.resourceId) }).get(__spreadValues$c({}, options));
           const legend = {
             layerId: id,
-            legend: ngwLegend.map(({ display_name, icon }) => ({
-              name: display_name,
-              symbol: icon
-            }))
+            legend: ngwLegend.map((legend2) => __spreadValues$c({
+              /** @deprecated use display_name instead */
+              name: legend2.display_name,
+              /** @deprecated use icon instead */
+              symbol: legend2.icon
+            }, legend2))
           };
           return [legend];
         }
@@ -4737,16 +5462,18 @@ const _NgwWebmapItem = class _NgwWebmapItem extends Item {
   getItemOptions(item) {
     const transparency = item.item_type === "layer" && item.layer_transparency;
     const opacity = typeof transparency === "number" ? (100 - transparency) / 100 : void 0;
-    const options = {
+    const options = __spreadProps$6(__spreadValues$c({
       visibility: false,
-      name: item.display_name,
-      headers: this.options.headers,
-      crossOrigin: this.options.crossOrigin,
-      setViewDelay: this.options.setViewDelay,
-      params: { resource: this.item.resourceId, item: this.item }
-    };
+      name: item.display_name
+    }, this.options), {
+      params: {
+        resource: "resourceId" in this.item ? this.item.resourceId : void 0,
+        item: this.item
+      }
+    });
+    delete options.id;
     if (this.options.order) {
-      const subOrder = this.options.drawOrderEnabled && "draw_order_position" in item ? this._rootDescendantsCount - item.draw_order_position : this.id;
+      const subOrder = this.options.drawOrderEnabled && "draw_order_position" in item && item.draw_order_position !== void 0 && item.draw_order_position !== null ? this._rootDescendantsCount - item.draw_order_position : this.id;
       const subLevel = String(subOrder).padStart(4, "0");
       options.order = Number((this.options.order | 0) + "." + subLevel);
     }
@@ -4755,17 +5482,16 @@ const _NgwWebmapItem = class _NgwWebmapItem extends Item {
     }
     if (item.item_type === "layer") {
       const { maxZoom, minZoom } = this._getZoomRange(item);
-      Object.assign(options, {
-        updateWmsParams: item.updateWmsParams,
+      Object.assign(options, __spreadProps$6(__spreadValues$c({
+        updateWmsParams: item.updateWmsParams
+      }, options), {
         url: item.url,
-        headers: this.options.headers,
-        ratio: this.options.ratio,
         maxZoom,
         minZoom,
         minScale: item.layer_min_scale_denom,
         maxScale: item.layer_max_scale_denom,
         interactive: item.layer_identifiable
-      });
+      }));
     }
     if (opacity !== void 0) {
       options.opacity = opacity;
@@ -4803,7 +5529,7 @@ const _NgwWebmapItem = class _NgwWebmapItem extends Item {
       if (enabled) {
         this.properties.set("visibility", true);
       }
-      if (options.opacity !== void 0) {
+      if (options.opacity !== void 0 && options.opacity !== null) {
         this.webMap.setLayerOpacity(l, options.opacity);
       }
     };
@@ -4852,8 +5578,8 @@ const _NgwWebmapItem = class _NgwWebmapItem extends Item {
     return totalValue;
   }
 };
-__publicField$d(_NgwWebmapItem, "GetAdapterFromLayerType", {});
-__publicField$d(_NgwWebmapItem, "options", {
+__publicField$e(_NgwWebmapItem, "GetAdapterFromLayerType", {});
+__publicField$e(_NgwWebmapItem, "options", {
   properties: [
     {
       type: "boolean",
@@ -4893,24 +5619,24 @@ __publicField$d(_NgwWebmapItem, "options", {
 });
 let NgwWebmapItem = _NgwWebmapItem;
 
-var __defProp$i = Object.defineProperty;
+var __defProp$j = Object.defineProperty;
 var __getOwnPropSymbols$c = Object.getOwnPropertySymbols;
 var __hasOwnProp$c = Object.prototype.hasOwnProperty;
 var __propIsEnum$c = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$i = (obj, key, value) => key in obj ? __defProp$i(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __defNormalProp$j = (obj, key, value) => key in obj ? __defProp$j(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __spreadValues$b = (a, b) => {
   for (var prop in b || (b = {}))
     if (__hasOwnProp$c.call(b, prop))
-      __defNormalProp$i(a, prop, b[prop]);
+      __defNormalProp$j(a, prop, b[prop]);
   if (__getOwnPropSymbols$c)
     for (var prop of __getOwnPropSymbols$c(b)) {
       if (__propIsEnum$c.call(b, prop))
-        __defNormalProp$i(a, prop, b[prop]);
+        __defNormalProp$j(a, prop, b[prop]);
     }
   return a;
 };
-var __publicField$c = (obj, key, value) => __defNormalProp$i(obj, typeof key !== "symbol" ? key + "" : key, value);
-var __async$c = (__this, __arguments, generator) => {
+var __publicField$d = (obj, key, value) => __defNormalProp$j(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __async$d = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
       try {
@@ -4931,7 +5657,7 @@ var __async$c = (__this, __arguments, generator) => {
   });
 };
 function createOnFirstShowAdapter(_0) {
-  return __async$c(this, arguments, function* ({
+  return __async$d(this, arguments, function* ({
     webMap,
     adapterOptions = {},
     onLayerAdded,
@@ -4939,10 +5665,10 @@ function createOnFirstShowAdapter(_0) {
   }) {
     class OnFirstShowAdapter {
       constructor() {
-        __publicField$c(this, "options", {});
-        __publicField$c(this, "layer", []);
-        __publicField$c(this, "_removed", false);
-        __publicField$c(this, "_creatingInProgress", false);
+        __publicField$d(this, "options", {});
+        __publicField$d(this, "layer", []);
+        __publicField$d(this, "_removed", false);
+        __publicField$d(this, "_creatingInProgress", false);
       }
       addLayer() {
         return this.layer;
@@ -4957,7 +5683,7 @@ function createOnFirstShowAdapter(_0) {
         return this._removed;
       }
       showLayer() {
-        return __async$c(this, null, function* () {
+        return __async$d(this, null, function* () {
           this.options.visibility = true;
           if (this.layer.length) {
             for (const x of this.layer) {
@@ -4969,7 +5695,7 @@ function createOnFirstShowAdapter(_0) {
         });
       }
       hideLayer() {
-        return __async$c(this, null, function* () {
+        return __async$d(this, null, function* () {
           this.options.visibility = false;
           if (this.layer) {
             for (const x of this.layer) {
@@ -4979,7 +5705,7 @@ function createOnFirstShowAdapter(_0) {
         });
       }
       loadLayer() {
-        return __async$c(this, null, function* () {
+        return __async$d(this, null, function* () {
           if (!this.layer.length && !this._creatingInProgress) {
             this._creatingInProgress = true;
             const Adapter = yield createAdapter(this);
@@ -5013,7 +5739,7 @@ function createOnFirstShowAdapter(_0) {
   });
 }
 
-var __async$b = (__this, __arguments, generator) => {
+var __async$c = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
       try {
@@ -5034,7 +5760,7 @@ var __async$b = (__this, __arguments, generator) => {
   });
 };
 function createOnFirstShowNgwAdapter(_0) {
-  return __async$b(this, arguments, function* ({
+  return __async$c(this, arguments, function* ({
     webMap,
     connector,
     item,
@@ -5070,24 +5796,27 @@ function createOnFirstShowNgwAdapter(_0) {
 
 const WEBMAP_BASELAYER_ID_PREFIX = "webmap-baselayer";
 
-var __defProp$h = Object.defineProperty;
+var __defProp$i = Object.defineProperty;
+var __defProps$5 = Object.defineProperties;
+var __getOwnPropDescs$5 = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols$b = Object.getOwnPropertySymbols;
 var __hasOwnProp$b = Object.prototype.hasOwnProperty;
 var __propIsEnum$b = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$h = (obj, key, value) => key in obj ? __defProp$h(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __defNormalProp$i = (obj, key, value) => key in obj ? __defProp$i(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __spreadValues$a = (a, b) => {
   for (var prop in b || (b = {}))
     if (__hasOwnProp$b.call(b, prop))
-      __defNormalProp$h(a, prop, b[prop]);
+      __defNormalProp$i(a, prop, b[prop]);
   if (__getOwnPropSymbols$b)
     for (var prop of __getOwnPropSymbols$b(b)) {
       if (__propIsEnum$b.call(b, prop))
-        __defNormalProp$h(a, prop, b[prop]);
+        __defNormalProp$i(a, prop, b[prop]);
     }
   return a;
 };
-var __publicField$b = (obj, key, value) => __defNormalProp$h(obj, typeof key !== "symbol" ? key + "" : key, value);
-var __async$a = (__this, __arguments, generator) => {
+var __spreadProps$5 = (a, b) => __defProps$5(a, __getOwnPropDescs$5(b));
+var __publicField$c = (obj, key, value) => __defNormalProp$i(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __async$b = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
       try {
@@ -5111,21 +5840,20 @@ class NgwWebmapLayerAdapter {
   constructor(map, options) {
     this.map = map;
     this.options = options;
-    __publicField$b(this, "layer");
-    __publicField$b(this, "NgwWebmapItem", NgwWebmapItem);
+    __publicField$c(this, "layer");
+    __publicField$c(this, "NgwWebmapItem", NgwWebmapItem);
     /**
      * Radius for searching objects in pixels
      */
-    __publicField$b(this, "pixelRadius", 10);
+    __publicField$c(this, "pixelRadius", 10);
     // webmapSettings.identify_radius,
-    __publicField$b(this, "resourceId");
-    __publicField$b(this, "webmapClassName", "webmap");
-    __publicField$b(this, "emitter", new EventEmitter());
-    __publicField$b(this, "_extent");
-    __publicField$b(this, "response");
-    __publicField$b(this, "_webmapLayersIds");
-    __publicField$b(this, "_webmapBaselayersIds", []);
-    __publicField$b(this, "_lastActiveBaselayer");
+    __publicField$c(this, "resourceId");
+    __publicField$c(this, "webmapClassName", "webmap");
+    __publicField$c(this, "emitter", new EventEmitter());
+    __publicField$c(this, "_extent");
+    __publicField$c(this, "webmapResource");
+    __publicField$c(this, "_webmapBaselayersIds", []);
+    __publicField$c(this, "_lastActiveBaselayer");
     const r = options.resourceId;
     if (Array.isArray(r)) {
       this.resourceId = r[0];
@@ -5138,11 +5866,11 @@ class NgwWebmapLayerAdapter {
     }
   }
   addLayer(options) {
-    return __async$a(this, null, function* () {
-      var _a, _b;
+    return __async$b(this, null, function* () {
+      var _a;
       this.options = __spreadValues$a(__spreadValues$a({}, this.options), options);
       this.layer = yield this._getWebMapLayerItem();
-      const extentConstrained = (_b = (_a = this.response) == null ? void 0 : _a.webmap) == null ? void 0 : _b.extent_constrained;
+      const extentConstrained = (_a = this.webmapResource) == null ? void 0 : _a.constraining_extent;
       if (this.options.useExtentConstrained && this._extent && extentConstrained) {
         this.options.webMap.setView({ maxBounds: this._extent });
       }
@@ -5167,25 +5895,24 @@ class NgwWebmapLayerAdapter {
       this.options.webMap.setView({ maxBounds: null });
     }
     delete this.layer;
-    delete this.response;
-    delete this._webmapLayersIds;
+    delete this.webmapResource;
   }
   showLayer() {
-    return __async$a(this, null, function* () {
+    return __async$b(this, null, function* () {
       if (this.layer && this.layer.properties) {
         return this.layer.properties.property("visibility").set(true);
       }
     });
   }
   hideLayer() {
-    return __async$a(this, null, function* () {
+    return __async$b(this, null, function* () {
       if (this.layer && this.layer.properties) {
         return this.layer.properties.property("visibility").set(false);
       }
     });
   }
   setOpacity(val) {
-    return __async$a(this, null, function* () {
+    return __async$b(this, null, function* () {
       if (this.layer && this.layer.properties) {
         return this.layer.properties.property("opacity").set(val);
       }
@@ -5196,7 +5923,7 @@ class NgwWebmapLayerAdapter {
     return this.getBounds();
   }
   getBounds() {
-    const webmap = this.response && this.response.webmap;
+    const webmap = this.webmapResource;
     if (webmap) {
       return getNgwWebmapExtent(webmap);
     }
@@ -5205,8 +5932,8 @@ class NgwWebmapLayerAdapter {
     return this.layer && this.layer.tree.getDescendants() || [];
   }
   getBookmarksResourceId() {
-    const webmap = this.response && this.response.webmap;
-    if (webmap) {
+    const webmap = this.webmapResource;
+    if (webmap && webmap.bookmark_resource) {
       return webmap.bookmark_resource.id;
     }
   }
@@ -5245,7 +5972,7 @@ class NgwWebmapLayerAdapter {
     );
   }
   getLegend(options) {
-    return __async$a(this, null, function* () {
+    return __async$b(this, null, function* () {
       const legends = [];
       let deps = this.getDependLayers();
       deps = deps.sort((a, b) => b.id - a.id);
@@ -5257,78 +5984,65 @@ class NgwWebmapLayerAdapter {
     });
   }
   getIdentificationIds(options) {
-    return __async$a(this, null, function* () {
+    return __async$b(this, null, function* () {
       const visibleLayers = [];
-      let ids = this._webmapLayersIds;
-      if (!ids) {
-        ids = yield this._getWebMapIds(options);
-        this._webmapLayersIds = ids;
-      }
-      if (ids && ids.length) {
-        let deps = this.getDependLayers();
-        deps = deps.sort((a, b) => b.id - a.id);
-        deps.forEach((x) => {
-          const item = x.item;
-          const parentId = item.parentId;
-          if (parentId !== void 0 && item.item_type === "layer" && item.layer_identifiable) {
-            const visible = x.properties.property("visibility");
-            const isVisible = visible.get() && !visible.isBlocked();
-            if (isVisible) {
-              visibleLayers.push(parentId);
-            }
+      let deps = this.getDependLayers();
+      deps = deps.sort((a, b) => b.id - a.id);
+      deps.forEach((x) => {
+        const item = x.item;
+        const parentId = "style_parent_id" in item ? item.style_parent_id : void 0;
+        if (parentId !== void 0 && parentId !== null && item.item_type === "layer" && item.layer_identifiable) {
+          const visible = x.properties.property("visibility");
+          const isVisible = visible.get() && !visible.isBlocked();
+          if (isVisible) {
+            visibleLayers.push(parentId);
           }
-        });
-      }
+        }
+      });
       return visibleLayers;
     });
   }
   _getWebMapLayerItem() {
-    return __async$a(this, null, function* () {
-      if (this.resourceId) {
-        const webmap = yield this.getWebMapConfig(this.resourceId);
-        if (webmap && webmap.root_item) {
-          return new Promise((resolve) => {
-            const options = {};
-            if (this.options.connector && this.options.connector.options.auth) {
-              const headers = this.options.connector.getAuthorizationHeaders();
-              if (headers) {
-                options.headers = headers;
-              }
-            }
-            options.setViewDelay = this.options.setViewDelay;
-            options.order = this.options.order;
-            options.ratio = this.options.ratio;
-            options.crossOrigin = this.options.crossOrigin;
-            options.minZoom = this.options.minZoom;
-            options.maxZoom = this.options.maxZoom;
-            options.drawOrderEnabled = webmap.draw_order_enabled;
-            options.popupOptions = this.options.popupOptions;
-            const layer = new this.NgwWebmapItem(
-              this.options.webMap,
-              webmap.root_item,
-              options,
-              this.options.connector
-            );
-            layer.emitter.on("init", () => resolve(layer));
-          });
-        }
+    return __async$b(this, null, function* () {
+      if (!this.resourceId) {
+        return void 0;
+      }
+      const webmap = yield this.getWebMapConfig(this.resourceId);
+      if (!webmap || !webmap.root_item) {
+        return void 0;
       }
+      return new Promise((resolve) => {
+        var _a;
+        const connector = this.options.connector;
+        const headers = (connector == null ? void 0 : connector.options.auth) ? connector.getAuthorizationHeaders() : void 0;
+        const withCredentials = connector.withCredentials;
+        const options = __spreadProps$5(__spreadValues$a({}, this.options), {
+          withCredentials,
+          headers,
+          drawOrderEnabled: (_a = webmap.draw_order_enabled) != null ? _a : false
+        });
+        const layer = new this.NgwWebmapItem(
+          this.options.webMap,
+          webmap.root_item,
+          options,
+          connector
+        );
+        layer.emitter.on("init", () => {
+          resolve(layer);
+        });
+      });
     });
   }
   getWebMapConfig(id) {
-    return __async$a(this, null, function* () {
+    return __async$b(this, null, function* () {
+      var _a;
       const data = yield this.options.connector.getResource(id);
       if (data) {
-        this.response = data;
         const webmap = data[this.webmapClassName];
+        this.webmapResource = webmap;
         this._setupBaselayers(data);
         if (webmap) {
-          this._extent = [
-            webmap.extent_left,
-            webmap.extent_bottom,
-            webmap.extent_right,
-            webmap.extent_top
-          ];
+          this._extent = (_a = webmap.initial_extent) != null ? _a : void 0;
           this._updateItemsParams(webmap.root_item, this.options.webMap, data);
           return webmap;
         }
@@ -5380,23 +6094,25 @@ class NgwWebmapLayerAdapter {
   _updateItemsParams(item, webMap, data) {
     if (item) {
       if (item.item_type === "group" || item.item_type === "root") {
-        if (item.children) {
-          item.children = item.children.map(
+        if ("children" in item && item.children) {
+          const children = item.children.map(
             (x) => this._updateItemsParams(x, webMap, data)
           );
+          item.children = children;
         }
         if (item.item_type === "root") {
           item.display_name = data.resource.display_name;
         }
       } else if (item.item_type === "layer") {
+        const layerItem = item;
         const url = fixUrlStr(
           this.options.connector.options.baseUrl + "/api/component/render/image"
         );
-        const resourceId = item.layer_style_id;
-        item.url = url;
-        item.resourceId = resourceId;
-        item.updateWmsParams = (params) => updateImageParams(params, resourceId);
-        const adapter = item.layer_adapter.toUpperCase();
+        const resourceId = layerItem.layer_style_id;
+        layerItem.url = url;
+        layerItem.resourceId = resourceId;
+        layerItem.updateWmsParams = (params) => updateImageParams(params, resourceId);
+        const adapter = layerItem.layer_adapter.toUpperCase();
         const layerAdapterOptions = ngwApiToAdapterOptions({
           options: {
             adapter,
@@ -5405,56 +6121,31 @@ class NgwWebmapLayerAdapter {
           webMap,
           baseUrl: this.options.connector.options.baseUrl || ""
         });
-        item = __spreadValues$a(__spreadValues$a({}, item), layerAdapterOptions);
+        item = __spreadValues$a(__spreadValues$a({}, layerItem), layerAdapterOptions);
       }
     }
     return item;
   }
-  _getWebMapIds(options) {
-    return __async$a(this, null, function* () {
-      const webMapItem = this.layer;
-      if (webMapItem && webMapItem.item.item_type === "root") {
-        const layers = webMapItem.tree.getDescendants();
-        const promises = [];
-        for (const x of layers) {
-          const item = x.item;
-          if (item.item_type === "layer") {
-            const id = item.layer_style_id;
-            const promise = this.options.connector.getResource(id, options).then((y) => {
-              if (y) {
-                const parentId = Number(y.resource.parent.id);
-                item.parentId = parentId;
-                return parentId;
-              }
-            });
-            promises.push(promise);
-          }
-        }
-        const ids = yield Promise.all(promises);
-        return ids.filter((x) => x !== void 0);
-      }
-    });
-  }
 }
 
-var __defProp$g = Object.defineProperty;
+var __defProp$h = Object.defineProperty;
 var __getOwnPropSymbols$a = Object.getOwnPropertySymbols;
 var __hasOwnProp$a = Object.prototype.hasOwnProperty;
 var __propIsEnum$a = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$g = (obj, key, value) => key in obj ? __defProp$g(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __defNormalProp$h = (obj, key, value) => key in obj ? __defProp$h(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __spreadValues$9 = (a, b) => {
   for (var prop in b || (b = {}))
     if (__hasOwnProp$a.call(b, prop))
-      __defNormalProp$g(a, prop, b[prop]);
+      __defNormalProp$h(a, prop, b[prop]);
   if (__getOwnPropSymbols$a)
     for (var prop of __getOwnPropSymbols$a(b)) {
       if (__propIsEnum$a.call(b, prop))
-        __defNormalProp$g(a, prop, b[prop]);
+        __defNormalProp$h(a, prop, b[prop]);
     }
   return a;
 };
-var __publicField$a = (obj, key, value) => __defNormalProp$g(obj, typeof key !== "symbol" ? key + "" : key, value);
-var __async$9 = (__this, __arguments, generator) => {
+var __publicField$b = (obj, key, value) => __defNormalProp$h(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __async$a = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
       try {
@@ -5477,9 +6168,9 @@ var __async$9 = (__this, __arguments, generator) => {
 class NgwKit {
   constructor(options) {
     this.options = options;
-    __publicField$a(this, "url");
-    __publicField$a(this, "connector");
-    __publicField$a(this, "webMap");
+    __publicField$b(this, "url");
+    __publicField$b(this, "connector");
+    __publicField$b(this, "webMap");
     if (this.options.connector) {
       this.url = this.options.connector.options.baseUrl || "";
       this.connector = this.options.connector;
@@ -5489,7 +6180,7 @@ class NgwKit {
       } else {
         throw new Error("url is not defined");
       }
-      this.connector = new NgwConnector({
+      this.connector = new NgwConnectorExtended({
         baseUrl: this.url,
         auth: this.options.auth
       });
@@ -5499,7 +6190,7 @@ class NgwKit {
     classAdapters[cls] = adapter;
   }
   onLoadSync(webMap) {
-    return __async$9(this, null, function* () {
+    return __async$a(this, null, function* () {
       if (this.options.resourceId && this.url) {
         const resourceIds = [this.options.resourceId];
         if (resourceIds.length) {
@@ -5540,37 +6231,57 @@ class NgwKit {
   }
 }
 
-var __defProp$f = Object.defineProperty;
+var __defProp$g = Object.defineProperty;
 var __getOwnPropSymbols$9 = Object.getOwnPropertySymbols;
 var __hasOwnProp$9 = Object.prototype.hasOwnProperty;
 var __propIsEnum$9 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$f = (obj, key, value) => key in obj ? __defProp$f(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __defNormalProp$g = (obj, key, value) => key in obj ? __defProp$g(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __spreadValues$8 = (a, b) => {
   for (var prop in b || (b = {}))
     if (__hasOwnProp$9.call(b, prop))
-      __defNormalProp$f(a, prop, b[prop]);
+      __defNormalProp$g(a, prop, b[prop]);
   if (__getOwnPropSymbols$9)
     for (var prop of __getOwnPropSymbols$9(b)) {
       if (__propIsEnum$9.call(b, prop))
-        __defNormalProp$f(a, prop, b[prop]);
+        __defNormalProp$g(a, prop, b[prop]);
     }
   return a;
 };
-var __publicField$9 = (obj, key, value) => __defNormalProp$f(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __publicField$a = (obj, key, value) => __defNormalProp$g(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __async$9 = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
 class IdentifyItem {
   constructor(options) {
-    __publicField$9(this, "id");
-    __publicField$9(this, "label");
-    __publicField$9(this, "layerId");
-    __publicField$9(this, "parent");
-    __publicField$9(this, "fields");
-    __publicField$9(this, "geom");
-    __publicField$9(this, "extensions");
-    __publicField$9(this, "connector");
-    __publicField$9(this, "_item");
-    __publicField$9(this, "_geojson");
-    __publicField$9(this, "_resource");
-    __publicField$9(this, "_extent");
+    __publicField$a(this, "id");
+    __publicField$a(this, "label");
+    __publicField$a(this, "layerId");
+    __publicField$a(this, "parent");
+    __publicField$a(this, "fields");
+    __publicField$a(this, "geom");
+    __publicField$a(this, "extensions");
+    __publicField$a(this, "connector");
+    __publicField$a(this, "_item");
+    __publicField$a(this, "_geojson");
+    __publicField$a(this, "_resource");
+    __publicField$a(this, "_extent");
     const f = options.feature;
     this.id = f.id;
     this.geom = f.geom;
@@ -5598,12 +6309,16 @@ class IdentifyItem {
     });
   }
   resource(opt) {
-    if (this._resource) {
-      return Promise.resolve(this._resource.feature_layer);
-    }
-    return this.connector.getResource(this.layerId, opt).then((resp) => {
+    return __async$9(this, null, function* () {
+      if (this._resource && this._resource.feature_layer) {
+        return this._resource.feature_layer;
+      }
+      const resp = yield this.connector.getResource(this.layerId, opt);
+      if (!(resp == null ? void 0 : resp.feature_layer)) {
+        throw new Error("Resource is not avector layer");
+      }
       this._resource = resp;
-      return this._resource.feature_layer;
+      return resp.feature_layer;
     });
   }
   getBounds(opt) {
@@ -5656,21 +6371,21 @@ function fetchNgwLayerFeature(options) {
   });
 }
 
-var __defProp$e = Object.defineProperty;
+var __defProp$f = Object.defineProperty;
 var __defProps$4 = Object.defineProperties;
 var __getOwnPropDescs$4 = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols$8 = Object.getOwnPropertySymbols;
 var __hasOwnProp$8 = Object.prototype.hasOwnProperty;
 var __propIsEnum$8 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$e = (obj, key, value) => key in obj ? __defProp$e(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __defNormalProp$f = (obj, key, value) => key in obj ? __defProp$f(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __spreadValues$7 = (a, b) => {
   for (var prop in b || (b = {}))
     if (__hasOwnProp$8.call(b, prop))
-      __defNormalProp$e(a, prop, b[prop]);
+      __defNormalProp$f(a, prop, b[prop]);
   if (__getOwnPropSymbols$8)
     for (var prop of __getOwnPropSymbols$8(b)) {
       if (__propIsEnum$8.call(b, prop))
-        __defNormalProp$e(a, prop, b[prop]);
+        __defNormalProp$f(a, prop, b[prop]);
     }
   return a;
 };
@@ -5767,13 +6482,13 @@ function featureLayerIdentify(options) {
   if (!wkt) {
     throw new Error("Not valid geometry format to make intersection");
   }
-  const data = {
+  const json = {
     geom: wkt,
     srs: 3857,
     layers
   };
-  return options.connector.post("feature_layer.identify", {
-    data,
+  return options.connector.route("feature_layer.identify").post({
+    json,
     signal,
     cache
   });
@@ -5833,9 +6548,11 @@ var __async$7 = (__this, __arguments, generator) => {
 };
 function getCompanyLogo(connector, options) {
   return __async$7(this, null, function* () {
-    var _a;
-    const settings = yield connector.get("pyramid.settings", null, {
-      component: "pyramid"
+    var _a, _b;
+    const settings = yield connector.route("pyramid.settings").get({
+      query: {
+        component: "pyramid"
+      }
     });
     if (settings && settings.company_logo && settings.company_logo.enabled) {
       const anchor = document.createElement("a");
@@ -5852,12 +6569,21 @@ function getCompanyLogo(connector, options) {
       img.style.maxWidth = "100px";
       img.src = "";
       try {
-        const src = yield connector.get("pyramid.company_logo", {
-          responseType: "blob"
-        });
-        const urlCreator = window.URL || window.webkitURL;
-        const imageUrl = urlCreator.createObjectURL(src);
-        img.src = imageUrl;
+        const resp = yield connector.route("pyramid.csettings").get();
+        const logo = (_b = resp.pyramid) == null ? void 0 : _b.header_logo;
+        if (logo) {
+          const [mimeType, base64Data] = logo;
+          const byteCharacters = atob(base64Data);
+          const byteNumbers = new Array(byteCharacters.length);
+          for (let i = 0; i < byteCharacters.length; i++) {
+            byteNumbers[i] = byteCharacters.charCodeAt(i);
+          }
+          const byteArray = new Uint8Array(byteNumbers);
+          const blob = new Blob([byteArray], { type: mimeType });
+          const urlCreator = window.URL || window.webkitURL;
+          const imageUrl = urlCreator.createObjectURL(blob);
+          img.src = imageUrl;
+        }
       } catch (er) {
         console.warn(er);
       }
@@ -6514,19 +7240,19 @@ const typeExpressions = {
   typeof: evaluateArgs(([arg]) => typeOfValue(arg))
 };
 
-var __defProp$d = Object.defineProperty;
+var __defProp$e = Object.defineProperty;
 var __getOwnPropSymbols$7 = Object.getOwnPropertySymbols;
 var __hasOwnProp$7 = Object.prototype.hasOwnProperty;
 var __propIsEnum$7 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$d = (obj, key, value) => key in obj ? __defProp$d(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __defNormalProp$e = (obj, key, value) => key in obj ? __defProp$e(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __spreadValues$6 = (a, b) => {
   for (var prop in b || (b = {}))
     if (__hasOwnProp$7.call(b, prop))
-      __defNormalProp$d(a, prop, b[prop]);
+      __defNormalProp$e(a, prop, b[prop]);
   if (__getOwnPropSymbols$7)
     for (var prop of __getOwnPropSymbols$7(b)) {
       if (__propIsEnum$7.call(b, prop))
-        __defNormalProp$d(a, prop, b[prop]);
+        __defNormalProp$e(a, prop, b[prop]);
     }
   return a;
 };
@@ -6551,19 +7277,19 @@ function evaluate(expression, data = {}) {
   throw new Error(`Expression "${name}" is not supported.`);
 }
 
-var __defProp$c = Object.defineProperty;
+var __defProp$d = Object.defineProperty;
 var __getOwnPropSymbols$6 = Object.getOwnPropertySymbols;
 var __hasOwnProp$6 = Object.prototype.hasOwnProperty;
 var __propIsEnum$6 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$c = (obj, key, value) => key in obj ? __defProp$c(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __defNormalProp$d = (obj, key, value) => key in obj ? __defProp$d(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __spreadValues$5 = (a, b) => {
   for (var prop in b || (b = {}))
     if (__hasOwnProp$6.call(b, prop))
-      __defNormalProp$c(a, prop, b[prop]);
+      __defNormalProp$d(a, prop, b[prop]);
   if (__getOwnPropSymbols$6)
     for (var prop of __getOwnPropSymbols$6(b)) {
       if (__propIsEnum$6.call(b, prop))
-        __defNormalProp$c(a, prop, b[prop]);
+        __defNormalProp$d(a, prop, b[prop]);
     }
   return a;
 };
@@ -6602,19 +7328,19 @@ function createExpressionCallback(paint) {
   return;
 }
 
-var __defProp$b = Object.defineProperty;
+var __defProp$c = Object.defineProperty;
 var __getOwnPropSymbols$5 = Object.getOwnPropertySymbols;
 var __hasOwnProp$5 = Object.prototype.hasOwnProperty;
 var __propIsEnum$5 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$b = (obj, key, value) => key in obj ? __defProp$b(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __defNormalProp$c = (obj, key, value) => key in obj ? __defProp$c(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __spreadValues$4 = (a, b) => {
   for (var prop in b || (b = {}))
     if (__hasOwnProp$5.call(b, prop))
-      __defNormalProp$b(a, prop, b[prop]);
+      __defNormalProp$c(a, prop, b[prop]);
   if (__getOwnPropSymbols$5)
     for (var prop of __getOwnPropSymbols$5(b)) {
       if (__propIsEnum$5.call(b, prop))
-        __defNormalProp$b(a, prop, b[prop]);
+        __defNormalProp$c(a, prop, b[prop]);
     }
   return a;
 };
@@ -6738,95 +7464,95 @@ function preparePaint({
   return newPaint;
 }
 
-var __defProp$a = Object.defineProperty;
-var __defNormalProp$a = (obj, key, value) => key in obj ? __defProp$a(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$8 = (obj, key, value) => __defNormalProp$a(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$b = Object.defineProperty;
+var __defNormalProp$b = (obj, key, value) => key in obj ? __defProp$b(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$9 = (obj, key, value) => __defNormalProp$b(obj, typeof key !== "symbol" ? key + "" : key, value);
 class KeyCodes {
   constructor() {
-    __publicField$8(this, "backspace", 8);
-    __publicField$8(this, "tab", 9);
-    __publicField$8(this, "enter", 13);
-    __publicField$8(this, "shift", 16);
-    __publicField$8(this, "ctrl", 17);
-    __publicField$8(this, "alt", 18);
-    __publicField$8(this, "pause/break", 19);
-    __publicField$8(this, "caps_lock", 20);
-    __publicField$8(this, "escape", 27);
-    __publicField$8(this, "page_up", 33);
-    __publicField$8(this, "page_down", 34);
-    __publicField$8(this, "end", 35);
-    __publicField$8(this, "home", 36);
-    __publicField$8(this, "left_arrow", 37);
-    __publicField$8(this, "up_arrow", 38);
-    __publicField$8(this, "right_arrow", 39);
-    __publicField$8(this, "down_arrow", 40);
-    __publicField$8(this, "insert", 45);
-    __publicField$8(this, "delete", 46);
-    __publicField$8(this, "left_window_key", 91);
-    __publicField$8(this, "right_window_key", 92);
-    __publicField$8(this, "select_key", 93);
-    __publicField$8(this, "numpad_0", 96);
-    __publicField$8(this, "numpad_1", 97);
-    __publicField$8(this, "numpad_2", 98);
-    __publicField$8(this, "numpad_3", 99);
-    __publicField$8(this, "numpad_4", 100);
-    __publicField$8(this, "numpad_5", 101);
-    __publicField$8(this, "numpad_6", 102);
-    __publicField$8(this, "numpad_7", 103);
-    __publicField$8(this, "numpad_8", 104);
-    __publicField$8(this, "numpad_9", 105);
-    __publicField$8(this, "multiply", 106);
-    __publicField$8(this, "add", 107);
-    __publicField$8(this, "subtract", 109);
-    __publicField$8(this, "decimal_point", 110);
-    __publicField$8(this, "divide", 111);
-    __publicField$8(this, "f1", 112);
-    __publicField$8(this, "f2", 113);
-    __publicField$8(this, "f3", 114);
-    __publicField$8(this, "f4", 115);
-    __publicField$8(this, "f5", 116);
-    __publicField$8(this, "f6", 117);
-    __publicField$8(this, "f7", 118);
-    __publicField$8(this, "f8", 119);
-    __publicField$8(this, "f9", 120);
-    __publicField$8(this, "f10", 121);
-    __publicField$8(this, "f11", 122);
-    __publicField$8(this, "f12", 123);
-    __publicField$8(this, "num_lock", 144);
-    __publicField$8(this, "scroll_lock", 145);
-    __publicField$8(this, "semi-colon", 186);
-    __publicField$8(this, "equal_sign", 187);
-    __publicField$8(this, ",", 188);
+    __publicField$9(this, "backspace", 8);
+    __publicField$9(this, "tab", 9);
+    __publicField$9(this, "enter", 13);
+    __publicField$9(this, "shift", 16);
+    __publicField$9(this, "ctrl", 17);
+    __publicField$9(this, "alt", 18);
+    __publicField$9(this, "pause/break", 19);
+    __publicField$9(this, "caps_lock", 20);
+    __publicField$9(this, "escape", 27);
+    __publicField$9(this, "page_up", 33);
+    __publicField$9(this, "page_down", 34);
+    __publicField$9(this, "end", 35);
+    __publicField$9(this, "home", 36);
+    __publicField$9(this, "left_arrow", 37);
+    __publicField$9(this, "up_arrow", 38);
+    __publicField$9(this, "right_arrow", 39);
+    __publicField$9(this, "down_arrow", 40);
+    __publicField$9(this, "insert", 45);
+    __publicField$9(this, "delete", 46);
+    __publicField$9(this, "left_window_key", 91);
+    __publicField$9(this, "right_window_key", 92);
+    __publicField$9(this, "select_key", 93);
+    __publicField$9(this, "numpad_0", 96);
+    __publicField$9(this, "numpad_1", 97);
+    __publicField$9(this, "numpad_2", 98);
+    __publicField$9(this, "numpad_3", 99);
+    __publicField$9(this, "numpad_4", 100);
+    __publicField$9(this, "numpad_5", 101);
+    __publicField$9(this, "numpad_6", 102);
+    __publicField$9(this, "numpad_7", 103);
+    __publicField$9(this, "numpad_8", 104);
+    __publicField$9(this, "numpad_9", 105);
+    __publicField$9(this, "multiply", 106);
+    __publicField$9(this, "add", 107);
+    __publicField$9(this, "subtract", 109);
+    __publicField$9(this, "decimal_point", 110);
+    __publicField$9(this, "divide", 111);
+    __publicField$9(this, "f1", 112);
+    __publicField$9(this, "f2", 113);
+    __publicField$9(this, "f3", 114);
+    __publicField$9(this, "f4", 115);
+    __publicField$9(this, "f5", 116);
+    __publicField$9(this, "f6", 117);
+    __publicField$9(this, "f7", 118);
+    __publicField$9(this, "f8", 119);
+    __publicField$9(this, "f9", 120);
+    __publicField$9(this, "f10", 121);
+    __publicField$9(this, "f11", 122);
+    __publicField$9(this, "f12", 123);
+    __publicField$9(this, "num_lock", 144);
+    __publicField$9(this, "scroll_lock", 145);
+    __publicField$9(this, "semi-colon", 186);
+    __publicField$9(this, "equal_sign", 187);
+    __publicField$9(this, ",", 188);
     // "comma";
-    __publicField$8(this, "-", 189);
+    __publicField$9(this, "-", 189);
     // "dash";
-    __publicField$8(this, ".", 190);
+    __publicField$9(this, ".", 190);
     // "period";
-    __publicField$8(this, "/", 191);
+    __publicField$9(this, "/", 191);
     // "forward slash";
-    __publicField$8(this, "`", 192);
+    __publicField$9(this, "`", 192);
     // "grave accent";
-    __publicField$8(this, "[", 219);
+    __publicField$9(this, "[", 219);
     // "open bracket";
-    __publicField$8(this, "\\", 220);
+    __publicField$9(this, "\\", 220);
     // "back slash";
-    __publicField$8(this, "]", 221);
+    __publicField$9(this, "]", 221);
     // "close braket";
-    __publicField$8(this, "'", 222);
+    __publicField$9(this, "'", 222);
   }
   // "single quote"
 }
 
-var __defProp$9 = Object.defineProperty;
-var __defNormalProp$9 = (obj, key, value) => key in obj ? __defProp$9(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$7 = (obj, key, value) => __defNormalProp$9(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$a = Object.defineProperty;
+var __defNormalProp$a = (obj, key, value) => key in obj ? __defProp$a(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$8 = (obj, key, value) => __defNormalProp$a(obj, typeof key !== "symbol" ? key + "" : key, value);
 class Keys {
   constructor() {
-    __publicField$7(this, "keyCodeAlias", new KeyCodes());
-    __publicField$7(this, "keys", {});
-    __publicField$7(this, "_windowOnFocus");
-    __publicField$7(this, "_keysPressed");
-    __publicField$7(this, "_keysReleased");
+    __publicField$8(this, "keyCodeAlias", new KeyCodes());
+    __publicField$8(this, "keys", {});
+    __publicField$8(this, "_windowOnFocus");
+    __publicField$8(this, "_keysPressed");
+    __publicField$8(this, "_keysReleased");
     this._windowOnFocus = this.windowOnFocus.bind(this);
     this._keysPressed = this.keysPressed.bind(this);
     this._keysReleased = this.keysReleased.bind(this);
@@ -6865,15 +7591,15 @@ class Keys {
   }
 }
 
-var __defProp$8 = Object.defineProperty;
-var __defNormalProp$8 = (obj, key, value) => key in obj ? __defProp$8(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$6 = (obj, key, value) => __defNormalProp$8(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$9 = Object.defineProperty;
+var __defNormalProp$9 = (obj, key, value) => key in obj ? __defProp$9(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$7 = (obj, key, value) => __defNormalProp$9(obj, typeof key !== "symbol" ? key + "" : key, value);
 class StateItem {
   constructor(webMap, opt) {
     this.webMap = webMap;
-    __publicField$6(this, "name");
-    __publicField$6(this, "event");
-    __publicField$6(this, "value");
+    __publicField$7(this, "name");
+    __publicField$7(this, "event");
+    __publicField$7(this, "value");
     if (opt) {
       if (opt.value) {
         this.setValue(opt.value);
@@ -6882,7 +7608,11 @@ class StateItem {
         this.name = opt.name;
       }
       if (opt.event) {
-        this.event = opt.event;
+        if (typeof opt.event === "string") {
+          this.event = [opt.event];
+        } else {
+          this.event = opt.event;
+        }
       }
     }
   }
@@ -6894,6 +7624,34 @@ class StateItem {
   }
 }
 
+var __defProp$8 = Object.defineProperty;
+var __defNormalProp$8 = (obj, key, value) => key in obj ? __defProp$8(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$6 = (obj, key, value) => __defNormalProp$8(obj, typeof key !== "symbol" ? key + "" : key, value);
+class BoundState extends StateItem {
+  constructor() {
+    super(...arguments);
+    __publicField$6(this, "name", "bounds");
+    __publicField$6(this, "event", ["moveend"]);
+  }
+  getValue() {
+    return this.webMap.getBounds();
+  }
+  setValue(bounds) {
+    this.webMap.setView({ bounds });
+  }
+  toString() {
+    const data = this.getValue();
+    if (data) {
+      return data.slice(0, 4).map((x) => x.toFixed(5)).join("_");
+    }
+    return void 0;
+  }
+  parse(str) {
+    const lngLat = str.split("_").map(Number);
+    return lngLat;
+  }
+}
+
 var __defProp$7 = Object.defineProperty;
 var __defNormalProp$7 = (obj, key, value) => key in obj ? __defProp$7(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField$5 = (obj, key, value) => __defNormalProp$7(obj, typeof key !== "symbol" ? key + "" : key, value);
@@ -6901,7 +7659,7 @@ class CenterState extends StateItem {
   constructor() {
     super(...arguments);
     __publicField$5(this, "name", "center");
-    __publicField$5(this, "event", "moveend");
+    __publicField$5(this, "event", ["moveend"]);
   }
   getValue() {
     return this.webMap.getCenter();
@@ -6909,9 +7667,13 @@ class CenterState extends StateItem {
   setValue(val) {
     this.webMap.setCenter(val);
   }
-  toString(data) {
-    const d = data.map((x) => x.toFixed(5));
-    return d[0] + "_" + d[1];
+  toString() {
+    const data = this.getValue();
+    if (data) {
+      const d = data.map((x) => x.toFixed(5));
+      return d[0] + "_" + d[1];
+    }
+    return "";
   }
   parse(str) {
     const lngLat = str.split("_").map(Number);
@@ -6926,7 +7688,7 @@ class ZoomState extends StateItem {
   constructor() {
     super(...arguments);
     __publicField$4(this, "name", "zoom");
-    __publicField$4(this, "event", "zoomend");
+    __publicField$4(this, "event", ["zoomend"]);
   }
   getValue() {
     const zoom = this.webMap.getZoom();
@@ -6935,8 +7697,8 @@ class ZoomState extends StateItem {
   setValue(val) {
     this.webMap.setZoom(val);
   }
-  toString(val) {
-    return String(val);
+  toString() {
+    return String(this.getValue());
   }
   parse(str) {
     return Number(str);
@@ -7005,14 +7767,14 @@ const _WebMapMain = class _WebMapMain {
     __publicField$3(this, "mapAdapter");
     __publicField$3(this, "runtimeParams", []);
     __publicField$3(this, "getPaintFunctions", _WebMapMain.getPaintFunctions);
-    __publicField$3(this, "mapState", [CenterState, ZoomState]);
+    __publicField$3(this, "mapStateItems", [CenterState, ZoomState, BoundState]);
     __publicField$3(this, "id", ID++);
     /**
      * From runtime params
      */
+    __publicField$3(this, "mapState", []);
     __publicField$3(this, "_initMapState", {});
     __publicField$3(this, "_starterKits");
-    __publicField$3(this, "_mapState", []);
     __publicField$3(this, "_extent");
     __publicField$3(this, "_eventsStatus", {});
     __publicField$3(this, "_coordFromMapClickAbort");
@@ -7047,7 +7809,7 @@ const _WebMapMain = class _WebMapMain {
   create() {
     return __async$6(this, null, function* () {
       if (!this.getEventStatus("create")) {
-        yield this._setInitMapState(this.mapState);
+        yield this._setInitMapState(this.mapStateItems);
         yield this._setupMap();
         this._emitStatusEvent("create", this);
       }
@@ -7067,16 +7829,22 @@ const _WebMapMain = class _WebMapMain {
       this.mapAdapter.destroy();
     }
   }
-  getState() {
+  mapStateWithFunc(func) {
     const state = {};
-    this._mapState.forEach((x) => {
-      state[x.name] = x.getValue();
+    this.mapState.forEach((x) => {
+      state[x.name] = func(x);
     });
     return state;
   }
+  getStateAsString() {
+    return this.mapStateWithFunc((x) => x.toString());
+  }
+  getState() {
+    return this.mapStateWithFunc((x) => x.getValue());
+  }
   getRuntimeParams() {
     const state = {};
-    this._mapState.forEach((x) => {
+    this.mapState.forEach((x) => {
       for (const r of this.runtimeParams) {
         const val = r.get(x.name);
         if (val !== void 0) {
@@ -7110,9 +7878,11 @@ const _WebMapMain = class _WebMapMain {
    * @param cursor - Available cursor name from https://developer.mozilla.org/ru/docs/Web/CSS/cursor
    */
   setCursor(cursor) {
-    if (this.mapAdapter.setCursor) {
-      this.mapAdapter.setCursor(cursor);
-    }
+    this.onLoad().then(() => {
+      if (this.mapAdapter.setCursor) {
+        this.mapAdapter.setCursor(cursor);
+      }
+    });
   }
   getCursor() {
     if (this.mapAdapter.getCursor) {
@@ -7418,7 +8188,7 @@ const _WebMapMain = class _WebMapMain {
   _setInitMapState(states) {
     for (const X of states) {
       const state = new X(this);
-      this._mapState.push(state);
+      this.mapState.push(state);
       for (const r of this.runtimeParams) {
         const str = r.get(state.name);
         if (str !== void 0) {
@@ -7454,13 +8224,15 @@ const _WebMapMain = class _WebMapMain {
     events.forEach((x) => {
       this._mapEvents[x] = (data) => {
         if (this.runtimeParams.length) {
-          const mapStatusEvent = this._mapState.find((y) => y.event === x);
-          if (mapStatusEvent) {
-            const value = mapStatusEvent.toString(mapStatusEvent.getValue());
+          const mapStatusEvents = this.mapState.filter(
+            (y) => y.event.includes(x)
+          );
+          mapStatusEvents.forEach((mapStatusEvent) => {
+            const value = mapStatusEvent.toString();
             this.runtimeParams.forEach((r) => {
               r.set(mapStatusEvent.name, value);
             });
-          }
+          });
         }
         if (this._eventsStatus) {
           this.emitter.emit(x, data);
@@ -7805,7 +8577,7 @@ class WebMapLayers extends WebMapMain {
           }
         }
         const opacity = options.opacity;
-        if (opacity !== void 0 && opacity <= 1) {
+        if (opacity !== void 0 && opacity !== null && opacity <= 1) {
           this.setLayerOpacity(_adapter, opacity);
         }
         const getBounds = layer && (_adapter.getBounds || _adapter.getExtent);
@@ -8036,11 +8808,11 @@ class WebMapLayers extends WebMapMain {
     }
     return Promise.resolve();
   }
-  updateLayer(layerDef) {
+  updateLayer(layerDef, options) {
     const layer = this.getLayer(layerDef);
     if (layer) {
       if (layer.updateLayer) {
-        return Promise.resolve(layer.updateLayer());
+        return Promise.resolve(layer.updateLayer(options));
       } else if (this.isLayerVisible(layer)) {
         return this.hideLayer(layer, { silent: true }).then(() => {
           return this.showLayer(layer, { silent: true });
@@ -8957,9 +9729,10 @@ function prepareWebMapOptions(options) {
     });
   }
   if (!options.connector) {
-    options.connector = new NgwConnector({
+    options.connector = new NgwConnectorExtended({
       baseUrl: options.baseUrl || "",
-      auth: options.auth
+      auth: options.auth,
+      withCredentials: options.withCredentials
     });
   } else if (options.connector) {
     options.baseUrl = options.connector.options.baseUrl;
@@ -9188,8 +9961,16 @@ const _NgwMap = class _NgwMap extends WebMap {
     this._addPromise("identify", promise, abortController);
     return promise;
   }
-  fetchIdentifyGeoJson(identify, multiple = false) {
+  fetchIdentifyGeoJson(identify, { multiple, signal } = {}) {
     const abortController = new AbortController();
+    if (signal) {
+      if (signal.aborted) {
+        return Promise.reject(new NgwConnectorExtended.errors.AbortError());
+      }
+      signal.addEventListener("abort", () => {
+        abortController.abort("AbortError");
+      });
+    }
     const promise = fetchIdentifyGeoJson({
       identify,
       connector: this.connector,
@@ -9207,7 +9988,7 @@ const _NgwMap = class _NgwMap extends WebMap {
    * @deprecated use {@link fetchIdentifyGeoJson} instead
    */
   getIdentifyGeoJson(identify, multiple = false) {
-    return this.fetchIdentifyGeoJson(identify, multiple);
+    return this.fetchIdentifyGeoJson(identify, { multiple });
   }
   getNgwLayers() {
     return __async$1(this, null, function* () {
@@ -9230,7 +10011,7 @@ const _NgwMap = class _NgwMap extends WebMap {
         if (mem.layer.getDependLayers) {
           const dependLayers = mem.layer.getDependLayers();
           const dependFit = dependLayers.find((x) => {
-            return x.item && x.item.parentId === id;
+            return x.item && "style_parent_id" in x.item && x.item.style_parent_id !== void 0 && x.item.style_parent_id === id;
           });
           if (dependFit) {
             return dependFit.layer;
@@ -9273,14 +10054,7 @@ const _NgwMap = class _NgwMap extends WebMap {
             item = yield this.connector.getResource(resourceId);
           }
           if (item) {
-            fetchNgwExtent({
-              resourceId: item.resource.id,
-              connector: this.connector
-            }).then((extent) => {
-              if (extent) {
-                this.fitBounds(extent, options);
-              }
-            });
+            this.fitResource(item.resource.id);
           }
         }
       } else {
@@ -9292,6 +10066,18 @@ const _NgwMap = class _NgwMap extends WebMap {
       }
     });
   }
+  fitResource(resource, options) {
+    return __async$1(this, null, function* () {
+      const resourceId = yield this.connector.resources.getIdOrFail(resource);
+      const extent = yield fetchNgwExtent({
+        resourceId,
+        connector: this.connector
+      });
+      if (extent) {
+        this.fitBounds(extent, options);
+      }
+    });
+  }
   /** @deprecated use {@link fitLayer} instead */
   zoomToLayer(layerDef) {
     return __async$1(this, null, function* () {
@@ -9471,8 +10257,7 @@ const _NgwMap = class _NgwMap extends WebMap {
           group.splice(index, 1);
         }
       };
-      promise.then(removeFromGroup);
-      promise.catch(removeFromGroup);
+      promise.then(removeFromGroup, removeFromGroup);
       group.push([promise, abortController]);
     }
   }