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

package/lib/ngw-map.global.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 NgwMap = (function (exports) {
   'use strict';
 
@@ -32,7 +32,7 @@ var NgwMap = (function (exports) {
     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) {
@@ -827,12 +827,12 @@ var NgwMap = (function (exports) {
     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]) {
@@ -868,10 +868,23 @@ var NgwMap = (function (exports) {
      * });
      * ```
      */
-    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;
@@ -881,10 +894,12 @@ var NgwMap = (function (exports) {
           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;
@@ -911,9 +926,19 @@ var NgwMap = (function (exports) {
     }
     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);
       }
@@ -938,87 +963,305 @@ var NgwMap = (function (exports) {
       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 {
@@ -1038,123 +1281,967 @@ var NgwMap = (function (exports) {
       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);
@@ -1186,10 +2273,21 @@ var NgwMap = (function (exports) {
         }
       });
     }
-    _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) {
@@ -1238,7 +2336,7 @@ var NgwMap = (function (exports) {
       });
     }
     _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) => {
@@ -1262,78 +2360,22 @@ var NgwMap = (function (exports) {
           });
           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;
@@ -1379,343 +2421,57 @@ var NgwMap = (function (exports) {
             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.
@@ -1834,74 +2590,6 @@ var NgwMap = (function (exports) {
         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
     // -------------------------------------------------------------------------
@@ -1977,92 +2665,21 @@ var NgwMap = (function (exports) {
     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;
   };
@@ -2144,26 +2761,30 @@ var NgwMap = (function (exports) {
     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 {
@@ -2199,15 +2820,12 @@ var NgwMap = (function (exports) {
   }
   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;
@@ -2222,8 +2840,17 @@ var NgwMap = (function (exports) {
       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 = [];
@@ -2267,13 +2894,13 @@ var NgwMap = (function (exports) {
       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,
@@ -2294,7 +2921,7 @@ var NgwMap = (function (exports) {
       if (propertiesFilterList.length) {
         for (const x of propertiesFilterList) {
           getQueries(
-            __spreadProps$c(__spreadValues$r({}, opt), {
+            __spreadProps$f(__spreadValues$r({}, opt), {
               filters: x
             }),
             _queries,
@@ -2303,7 +2930,7 @@ var NgwMap = (function (exports) {
         }
       } else {
         _queries.push(
-          fetchNgwLayerItemsRequest(__spreadProps$c(__spreadValues$r({}, opt), {
+          fetchNgwLayerItemsRequest(__spreadProps$f(__spreadValues$r({}, opt), {
             paramList: [..._parentAllParams, ...paramList, ...filters2]
           }))
         );
@@ -2322,6 +2949,7 @@ var NgwMap = (function (exports) {
     const params = __spreadValues$r({}, FEATURE_REQUEST_PARAMS);
     const {
       limit,
+      query,
       cache,
       signal,
       offset,
@@ -2332,12 +2960,10 @@ var NgwMap = (function (exports) {
       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;
@@ -2356,38 +2982,31 @@ var NgwMap = (function (exports) {
       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 {
@@ -2408,61 +3027,56 @@ var NgwMap = (function (exports) {
     });
   };
   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;
@@ -2476,10 +3090,10 @@ var NgwMap = (function (exports) {
       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;
@@ -2608,14 +3222,14 @@ var NgwMap = (function (exports) {
     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) {
@@ -2678,19 +3292,19 @@ var NgwMap = (function (exports) {
     }
   }
 
-  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;
@@ -2787,23 +3401,23 @@ var NgwMap = (function (exports) {
     }
   }
 
-  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));
@@ -2911,7 +3525,7 @@ var NgwMap = (function (exports) {
       }
     }
   };
-  __publicField$l(_CheckProperty, "options", {
+  __publicField$m(_CheckProperty, "options", {
     hierarchy: true,
     bubble: false,
     propagation: false,
@@ -2920,31 +3534,31 @@ var NgwMap = (function (exports) {
   });
   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));
       }
@@ -3007,35 +3621,35 @@ var NgwMap = (function (exports) {
       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);
@@ -3049,7 +3663,7 @@ var NgwMap = (function (exports) {
     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;
     }
@@ -3089,25 +3703,25 @@ var NgwMap = (function (exports) {
     }
   }
 
-  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"];
@@ -3130,7 +3744,7 @@ var NgwMap = (function (exports) {
     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];
@@ -3145,11 +3759,10 @@ var NgwMap = (function (exports) {
     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];
@@ -3172,17 +3785,17 @@ var NgwMap = (function (exports) {
       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
         }));
@@ -3190,10 +3803,10 @@ var NgwMap = (function (exports) {
     }
   }
 
-  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 {
@@ -3215,18 +3828,18 @@ var NgwMap = (function (exports) {
   };
   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;
         }
@@ -3242,7 +3855,7 @@ var NgwMap = (function (exports) {
     }
   }
 
-  var __async$m = (__this, __arguments, generator) => {
+  var __async$n = (__this, __arguments, generator) => {
     return new Promise((resolve, reject) => {
       var fulfilled = (value) => {
         try {
@@ -3263,7 +3876,7 @@ var NgwMap = (function (exports) {
     });
   };
   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;
@@ -3336,23 +3949,23 @@ var NgwMap = (function (exports) {
     };
   }
 
-  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)
@@ -3364,8 +3977,8 @@ var NgwMap = (function (exports) {
       }
     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 {
@@ -3389,7 +4002,7 @@ var NgwMap = (function (exports) {
   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_;
@@ -3405,9 +4018,9 @@ var NgwMap = (function (exports) {
     }
     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;
@@ -3417,7 +4030,7 @@ var NgwMap = (function (exports) {
         }
       }
       addLayer(options) {
-        return __async$l(this, null, function* () {
+        return __async$m(this, null, function* () {
           if (!this.qms && options.qmsId) {
             try {
               this.qms = yield loadJson(
@@ -3461,29 +4074,29 @@ var NgwMap = (function (exports) {
     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;
     }
@@ -3499,33 +4112,33 @@ var NgwMap = (function (exports) {
       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 {
@@ -3546,7 +4159,7 @@ var NgwMap = (function (exports) {
     });
   };
   function createBasemapLayerAdapter(_0) {
-    return __async$k(this, arguments, function* ({
+    return __async$l(this, arguments, function* ({
       webMap,
       item
     }) {
@@ -3567,8 +4180,10 @@ var NgwMap = (function (exports) {
           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 }));
+                  }
                 });
               }
             }
@@ -3610,13 +4225,9 @@ var NgwMap = (function (exports) {
     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;
     });
   }
@@ -3647,26 +4258,26 @@ var NgwMap = (function (exports) {
     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 {
@@ -3687,17 +4298,17 @@ var NgwMap = (function (exports) {
     });
   };
   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);
@@ -3726,7 +4337,7 @@ var NgwMap = (function (exports) {
     return false;
   }
 
-  var __async$i = (__this, __arguments, generator) => {
+  var __async$j = (__this, __arguments, generator) => {
     return new Promise((resolve, reject) => {
       var fulfilled = (value) => {
         try {
@@ -3747,7 +4358,7 @@ var NgwMap = (function (exports) {
     });
   };
   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) => {
@@ -3785,30 +4396,30 @@ var NgwMap = (function (exports) {
     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 {
@@ -3829,7 +4440,7 @@ var NgwMap = (function (exports) {
     });
   };
   function createGeoJsonAdapter(props) {
-    return __async$h(this, null, function* () {
+    return __async$i(this, null, function* () {
       var _a, _b;
       const {
         item,
@@ -3852,7 +4463,7 @@ var NgwMap = (function (exports) {
           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;
@@ -3879,14 +4490,14 @@ var NgwMap = (function (exports) {
       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) {
@@ -3931,7 +4542,7 @@ var NgwMap = (function (exports) {
           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) {
@@ -3956,10 +4567,10 @@ var NgwMap = (function (exports) {
         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 || {};
@@ -3984,7 +4595,7 @@ var NgwMap = (function (exports) {
             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;
@@ -4013,7 +4624,7 @@ var NgwMap = (function (exports) {
                 isFull: _fullDataLoad
               });
             } catch (er) {
-              if (er instanceof Error && er.name !== "CancelError") {
+              if (er instanceof Error && er.name !== "AbortError") {
                 throw er;
               }
             }
@@ -4023,7 +4634,7 @@ var NgwMap = (function (exports) {
           });
         }
         propertiesFilter(filters, opt) {
-          return __async$h(this, null, function* () {
+          return __async$i(this, null, function* () {
             abort();
             if (this.filter && _fullDataLoad) {
               this.filter((e) => {
@@ -4037,7 +4648,7 @@ var NgwMap = (function (exports) {
               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);
@@ -4097,7 +4708,7 @@ var NgwMap = (function (exports) {
     });
   }
 
-  var __async$g = (__this, __arguments, generator) => {
+  var __async$h = (__this, __arguments, generator) => {
     return new Promise((resolve, reject) => {
       var fulfilled = (value) => {
         try {
@@ -4118,7 +4729,7 @@ var NgwMap = (function (exports) {
     });
   };
   function createWebMapAdapter(_0) {
-    return __async$g(this, arguments, function* ({
+    return __async$h(this, arguments, function* ({
       layerOptions: options,
       webMap,
       connector
@@ -4226,27 +4837,27 @@ var NgwMap = (function (exports) {
     }
   }
 
-  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 {
@@ -4266,11 +4877,47 @@ var NgwMap = (function (exports) {
       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;
@@ -4299,16 +4946,17 @@ var NgwMap = (function (exports) {
           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
@@ -4322,42 +4970,98 @@ var NgwMap = (function (exports) {
           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");
@@ -4365,26 +5069,26 @@ var NgwMap = (function (exports) {
     });
   }
 
-  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 {
@@ -4420,7 +5124,7 @@ var NgwMap = (function (exports) {
     "tmsclient_layer"
   ];
   function createAdapterFromFirstStyle(_0) {
-    return __async$e(this, arguments, function* ({
+    return __async$f(this, arguments, function* ({
       layerOptions,
       webMap,
       connector,
@@ -4431,7 +5135,7 @@ var NgwMap = (function (exports) {
       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
         );
@@ -4439,7 +5143,7 @@ var NgwMap = (function (exports) {
     });
   }
   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;
@@ -4454,13 +5158,13 @@ var NgwMap = (function (exports) {
         }
         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) {
@@ -4486,15 +5190,15 @@ var NgwMap = (function (exports) {
             } 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
                   }));
@@ -4538,31 +5242,46 @@ var NgwMap = (function (exports) {
     });
   }
 
-  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",
@@ -4583,6 +5302,9 @@ var NgwMap = (function (exports) {
     if (headers) {
       options.headers = headers;
     }
+    if (connector.withCredentials !== void 0) {
+      options.withCredentials = connector.withCredentials;
+    }
     return createAsyncAdapter(options, webMap, connector);
   }
   function extendNgwWebmapLayerAdapter(opt) {
@@ -4619,24 +5341,27 @@ var NgwMap = (function (exports) {
     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 {
@@ -4660,11 +5385,11 @@ var NgwMap = (function (exports) {
     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;
       }
@@ -4686,7 +5411,7 @@ var NgwMap = (function (exports) {
       }
     }
     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,
@@ -4715,21 +5440,21 @@ var NgwMap = (function (exports) {
       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];
           }
@@ -4740,16 +5465,18 @@ var NgwMap = (function (exports) {
     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);
       }
@@ -4758,17 +5485,16 @@ var NgwMap = (function (exports) {
       }
       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;
@@ -4806,7 +5532,7 @@ var NgwMap = (function (exports) {
         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);
         }
       };
@@ -4855,8 +5581,8 @@ var NgwMap = (function (exports) {
       return totalValue;
     }
   };
-  __publicField$d(_NgwWebmapItem, "GetAdapterFromLayerType", {});
-  __publicField$d(_NgwWebmapItem, "options", {
+  __publicField$e(_NgwWebmapItem, "GetAdapterFromLayerType", {});
+  __publicField$e(_NgwWebmapItem, "options", {
     properties: [
       {
         type: "boolean",
@@ -4896,24 +5622,24 @@ var NgwMap = (function (exports) {
   });
   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 {
@@ -4934,7 +5660,7 @@ var NgwMap = (function (exports) {
     });
   };
   function createOnFirstShowAdapter(_0) {
-    return __async$c(this, arguments, function* ({
+    return __async$d(this, arguments, function* ({
       webMap,
       adapterOptions = {},
       onLayerAdded,
@@ -4942,10 +5668,10 @@ var NgwMap = (function (exports) {
     }) {
       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;
@@ -4960,7 +5686,7 @@ var NgwMap = (function (exports) {
           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) {
@@ -4972,7 +5698,7 @@ var NgwMap = (function (exports) {
           });
         }
         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) {
@@ -4982,7 +5708,7 @@ var NgwMap = (function (exports) {
           });
         }
         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);
@@ -5016,7 +5742,7 @@ var NgwMap = (function (exports) {
     });
   }
 
-  var __async$b = (__this, __arguments, generator) => {
+  var __async$c = (__this, __arguments, generator) => {
     return new Promise((resolve, reject) => {
       var fulfilled = (value) => {
         try {
@@ -5037,7 +5763,7 @@ var NgwMap = (function (exports) {
     });
   };
   function createOnFirstShowNgwAdapter(_0) {
-    return __async$b(this, arguments, function* ({
+    return __async$c(this, arguments, function* ({
       webMap,
       connector,
       item,
@@ -5073,24 +5799,27 @@ var NgwMap = (function (exports) {
 
   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 {
@@ -5114,21 +5843,20 @@ var NgwMap = (function (exports) {
     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];
@@ -5141,11 +5869,11 @@ var NgwMap = (function (exports) {
       }
     }
     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 });
         }
@@ -5170,25 +5898,24 @@ var NgwMap = (function (exports) {
         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);
         }
@@ -5199,7 +5926,7 @@ var NgwMap = (function (exports) {
       return this.getBounds();
     }
     getBounds() {
-      const webmap = this.response && this.response.webmap;
+      const webmap = this.webmapResource;
       if (webmap) {
         return getNgwWebmapExtent(webmap);
       }
@@ -5208,8 +5935,8 @@ var NgwMap = (function (exports) {
       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;
       }
     }
@@ -5248,7 +5975,7 @@ var NgwMap = (function (exports) {
       );
     }
     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);
@@ -5260,78 +5987,65 @@ var NgwMap = (function (exports) {
       });
     }
     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;
           }
@@ -5383,23 +6097,25 @@ var NgwMap = (function (exports) {
     _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,
@@ -5408,56 +6124,31 @@ var NgwMap = (function (exports) {
             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 {
@@ -5480,9 +6171,9 @@ var NgwMap = (function (exports) {
   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;
@@ -5492,7 +6183,7 @@ var NgwMap = (function (exports) {
         } else {
           throw new Error("url is not defined");
         }
-        this.connector = new NgwConnector({
+        this.connector = new NgwConnectorExtended({
           baseUrl: this.url,
           auth: this.options.auth
         });
@@ -5502,7 +6193,7 @@ var NgwMap = (function (exports) {
       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) {
@@ -5543,37 +6234,57 @@ var NgwMap = (function (exports) {
     }
   }
 
-  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;
@@ -5601,12 +6312,16 @@ var NgwMap = (function (exports) {
       });
     }
     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) {
@@ -5659,21 +6374,21 @@ var NgwMap = (function (exports) {
     });
   }
 
-  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;
   };
@@ -5770,13 +6485,13 @@ var NgwMap = (function (exports) {
     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
     });
@@ -5836,9 +6551,11 @@ var NgwMap = (function (exports) {
   };
   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");
@@ -5855,12 +6572,21 @@ var NgwMap = (function (exports) {
         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);
         }
@@ -6517,19 +7243,19 @@ var NgwMap = (function (exports) {
     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;
   };
@@ -6554,19 +7280,19 @@ var NgwMap = (function (exports) {
     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;
   };
@@ -6605,19 +7331,19 @@ var NgwMap = (function (exports) {
     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;
   };
@@ -6741,95 +7467,95 @@ var NgwMap = (function (exports) {
     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);
@@ -6868,15 +7594,15 @@ var NgwMap = (function (exports) {
     }
   }
 
-  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);
@@ -6885,7 +7611,11 @@ var NgwMap = (function (exports) {
           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;
+          }
         }
       }
     }
@@ -6897,6 +7627,34 @@ var NgwMap = (function (exports) {
     }
   }
 
+  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);
@@ -6904,7 +7662,7 @@ var NgwMap = (function (exports) {
     constructor() {
       super(...arguments);
       __publicField$5(this, "name", "center");
-      __publicField$5(this, "event", "moveend");
+      __publicField$5(this, "event", ["moveend"]);
     }
     getValue() {
       return this.webMap.getCenter();
@@ -6912,9 +7670,13 @@ var NgwMap = (function (exports) {
     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);
@@ -6929,7 +7691,7 @@ var NgwMap = (function (exports) {
     constructor() {
       super(...arguments);
       __publicField$4(this, "name", "zoom");
-      __publicField$4(this, "event", "zoomend");
+      __publicField$4(this, "event", ["zoomend"]);
     }
     getValue() {
       const zoom = this.webMap.getZoom();
@@ -6938,8 +7700,8 @@ var NgwMap = (function (exports) {
     setValue(val) {
       this.webMap.setZoom(val);
     }
-    toString(val) {
-      return String(val);
+    toString() {
+      return String(this.getValue());
     }
     parse(str) {
       return Number(str);
@@ -7008,14 +7770,14 @@ var NgwMap = (function (exports) {
       __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");
@@ -7050,7 +7812,7 @@ var NgwMap = (function (exports) {
     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);
         }
@@ -7070,16 +7832,22 @@ var NgwMap = (function (exports) {
         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) {
@@ -7113,9 +7881,11 @@ var NgwMap = (function (exports) {
      * @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) {
@@ -7421,7 +8191,7 @@ var NgwMap = (function (exports) {
     _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) {
@@ -7457,13 +8227,15 @@ var NgwMap = (function (exports) {
       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);
@@ -7808,7 +8580,7 @@ var NgwMap = (function (exports) {
             }
           }
           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);
@@ -8039,11 +8811,11 @@ var NgwMap = (function (exports) {
       }
       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 });
@@ -8960,9 +9732,10 @@ var NgwMap = (function (exports) {
       });
     }
     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;
@@ -9191,8 +9964,16 @@ var NgwMap = (function (exports) {
       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,
@@ -9210,7 +9991,7 @@ var NgwMap = (function (exports) {
      * @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* () {
@@ -9233,7 +10014,7 @@ var NgwMap = (function (exports) {
           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;
@@ -9276,14 +10057,7 @@ var NgwMap = (function (exports) {
               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 {
@@ -9295,6 +10069,18 @@ var NgwMap = (function (exports) {
         }
       });
     }
+    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* () {
@@ -9474,8 +10260,7 @@ var NgwMap = (function (exports) {
             group.splice(index, 1);
           }
         };
-        promise.then(removeFromGroup);
-        promise.catch(removeFromGroup);
+        promise.then(removeFromGroup, removeFromGroup);
         group.push([promise, abortController]);
       }
     }