@nextgis/ngw-connector 1.18.21 → 2.0.0-alpha.0

package/lib/ngw-connector.global.js

@@ -1,2262 +1,2011 @@
-/** Bundle of @nextgis/ngw-connector; version: 1.18.21; author: NextGIS */
+/** Bundle of @nextgis/ngw-connector; version: 2.0.0-alpha.0; author: NextGIS */
 var NgwConnector = (function () {
-    'use strict';
-
-    /******************************************************************************
-    Copyright (c) Microsoft Corporation.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose with or without fee is hereby granted.
-
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
-    ***************************************************************************** */
-    /* global Reflect, Promise, SuppressedError, Symbol */
-
-    var extendStatics = function(d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-
-    function __extends(d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    }
-
-    var __assign = function() {
-        __assign = Object.assign || function __assign(t) {
-            for (var s, i = 1, n = arguments.length; i < n; i++) {
-                s = arguments[i];
-                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-            }
-            return t;
-        };
-        return __assign.apply(this, arguments);
-    };
-
-    function __awaiter(thisArg, _arguments, P, generator) {
-        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-        return new (P || (P = Promise))(function (resolve, reject) {
-            function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-            function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-            step((generator = generator.apply(thisArg, _arguments || [])).next());
-        });
-    }
-
-    function __generator(thisArg, body) {
-        var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-        function verb(n) { return function (v) { return step([n, v]); }; }
-        function step(op) {
-            if (f) throw new TypeError("Generator is already executing.");
-            while (g && (g = 0, op[0] && (_ = 0)), _) try {
-                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-                if (y = 0, t) op = [op[0] & 2, t.value];
-                switch (op[0]) {
-                    case 0: case 1: t = op; break;
-                    case 4: _.label++; return { value: op[1], done: false };
-                    case 5: _.label++; y = op[1]; op = [0]; continue;
-                    case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                    default:
-                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                        if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                        if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                        if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                        if (t[2]) _.ops.pop();
-                        _.trys.pop(); continue;
-                }
-                op = body.call(thisArg, _);
-            } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-            if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-        }
-    }
-
-    function __spreadArray(to, from, pack) {
-        if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-            if (ar || !(i in from)) {
-                if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-                ar[i] = from[i];
-            }
-        }
-        return to.concat(ar || Array.prototype.slice.call(from));
-    }
-
-    typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-        var e = new Error(message);
-        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-    };
-
-    var events = {exports: {}};
-
-    var R = typeof Reflect === 'object' ? Reflect : null;
-    var ReflectApply = R && typeof R.apply === 'function'
-      ? R.apply
-      : function ReflectApply(target, receiver, args) {
-        return Function.prototype.apply.call(target, receiver, args);
-      };
+  'use strict';
 
-    var ReflectOwnKeys;
-    if (R && typeof R.ownKeys === 'function') {
-      ReflectOwnKeys = R.ownKeys;
-    } else if (Object.getOwnPropertySymbols) {
-      ReflectOwnKeys = function ReflectOwnKeys(target) {
-        return Object.getOwnPropertyNames(target)
-          .concat(Object.getOwnPropertySymbols(target));
-      };
-    } else {
-      ReflectOwnKeys = function ReflectOwnKeys(target) {
-        return Object.getOwnPropertyNames(target);
-      };
-    }
+  var domain;
 
-    function ProcessEmitWarning(warning) {
-      if (console && console.warn) console.warn(warning);
-    }
+  // This constructor is used to store event handlers. Instantiating this is
+  // faster than explicitly calling `Object.create(null)` to get a "clean" empty
+  // object (tested with v8 v4.9).
+  function EventHandlers() {}
+  EventHandlers.prototype = Object.create(null);
 
-    var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {
-      return value !== value;
-    };
+  function EventEmitter() {
+    EventEmitter.init.call(this);
+  }
 
-    function EventEmitter() {
-      EventEmitter.init.call(this);
-    }
-    events.exports = EventEmitter;
-    events.exports.once = once;
+  // nodejs oddity
+  // require('events') === require('events').EventEmitter
+  EventEmitter.EventEmitter = EventEmitter;
 
-    // Backwards-compat with node 0.10.x
-    EventEmitter.EventEmitter = EventEmitter;
+  EventEmitter.usingDomains = false;
 
-    EventEmitter.prototype._events = undefined;
-    EventEmitter.prototype._eventsCount = 0;
-    EventEmitter.prototype._maxListeners = undefined;
+  EventEmitter.prototype.domain = undefined;
+  EventEmitter.prototype._events = undefined;
+  EventEmitter.prototype._maxListeners = undefined;
 
-    // By default EventEmitters will print a warning if more than 10 listeners are
-    // added to it. This is a useful default which helps finding memory leaks.
-    var defaultMaxListeners = 10;
+  // By default EventEmitters will print a warning if more than 10 listeners are
+  // added to it. This is a useful default which helps finding memory leaks.
+  EventEmitter.defaultMaxListeners = 10;
 
-    function checkListener(listener) {
-      if (typeof listener !== 'function') {
-        throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
-      }
+  EventEmitter.init = function() {
+    this.domain = null;
+    if (EventEmitter.usingDomains) {
+      // if there is an active domain, then attach to it.
+      if (domain.active ) ;
     }
 
-    Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
-      enumerable: true,
-      get: function() {
-        return defaultMaxListeners;
-      },
-      set: function(arg) {
-        if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {
-          throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.');
-        }
-        defaultMaxListeners = arg;
-      }
-    });
-
-    EventEmitter.init = function() {
-
-      if (this._events === undefined ||
-          this._events === Object.getPrototypeOf(this)._events) {
-        this._events = Object.create(null);
-        this._eventsCount = 0;
-      }
-
-      this._maxListeners = this._maxListeners || undefined;
-    };
-
-    // Obviously not all Emitters should be limited to 10. This function allows
-    // that to be increased. Set to zero for unlimited.
-    EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
-      if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {
-        throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + '.');
-      }
-      this._maxListeners = n;
-      return this;
-    };
-
-    function _getMaxListeners(that) {
-      if (that._maxListeners === undefined)
-        return EventEmitter.defaultMaxListeners;
-      return that._maxListeners;
+    if (!this._events || this._events === Object.getPrototypeOf(this)._events) {
+      this._events = new EventHandlers();
+      this._eventsCount = 0;
     }
 
-    EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
-      return _getMaxListeners(this);
-    };
-
-    EventEmitter.prototype.emit = function emit(type) {
-      var args = [];
-      for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
-      var doError = (type === 'error');
-
-      var events = this._events;
-      if (events !== undefined)
-        doError = (doError && events.error === undefined);
-      else if (!doError)
-        return false;
-
-      // If there is no 'error' event listener then throw.
-      if (doError) {
-        var er;
-        if (args.length > 0)
-          er = args[0];
-        if (er instanceof Error) {
-          // Note: The comments on the `throw` lines are intentional, they show
-          // up in Node's output if this results in an unhandled exception.
-          throw er; // Unhandled 'error' event
-        }
+    this._maxListeners = this._maxListeners || undefined;
+  };
+
+  // Obviously not all Emitters should be limited to 10. This function allows
+  // that to be increased. Set to zero for unlimited.
+  EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
+    if (typeof n !== 'number' || n < 0 || isNaN(n))
+      throw new TypeError('"n" argument must be a positive number');
+    this._maxListeners = n;
+    return this;
+  };
+
+  function $getMaxListeners(that) {
+    if (that._maxListeners === undefined)
+      return EventEmitter.defaultMaxListeners;
+    return that._maxListeners;
+  }
+
+  EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
+    return $getMaxListeners(this);
+  };
+
+  // These standalone emit* functions are used to optimize calling of event
+  // handlers for fast cases because emit() itself often has a variable number of
+  // arguments and can be deoptimized because of that. These functions always have
+  // the same number of arguments and thus do not get deoptimized, so the code
+  // inside them can execute faster.
+  function emitNone(handler, isFn, self) {
+    if (isFn)
+      handler.call(self);
+    else {
+      var len = handler.length;
+      var listeners = arrayClone(handler, len);
+      for (var i = 0; i < len; ++i)
+        listeners[i].call(self);
+    }
+  }
+  function emitOne(handler, isFn, self, arg1) {
+    if (isFn)
+      handler.call(self, arg1);
+    else {
+      var len = handler.length;
+      var listeners = arrayClone(handler, len);
+      for (var i = 0; i < len; ++i)
+        listeners[i].call(self, arg1);
+    }
+  }
+  function emitTwo(handler, isFn, self, arg1, arg2) {
+    if (isFn)
+      handler.call(self, arg1, arg2);
+    else {
+      var len = handler.length;
+      var listeners = arrayClone(handler, len);
+      for (var i = 0; i < len; ++i)
+        listeners[i].call(self, arg1, arg2);
+    }
+  }
+  function emitThree(handler, isFn, self, arg1, arg2, arg3) {
+    if (isFn)
+      handler.call(self, arg1, arg2, arg3);
+    else {
+      var len = handler.length;
+      var listeners = arrayClone(handler, len);
+      for (var i = 0; i < len; ++i)
+        listeners[i].call(self, arg1, arg2, arg3);
+    }
+  }
+
+  function emitMany(handler, isFn, self, args) {
+    if (isFn)
+      handler.apply(self, args);
+    else {
+      var len = handler.length;
+      var listeners = arrayClone(handler, len);
+      for (var i = 0; i < len; ++i)
+        listeners[i].apply(self, args);
+    }
+  }
+
+  EventEmitter.prototype.emit = function emit(type) {
+    var er, handler, len, args, i, events, domain;
+    var doError = (type === 'error');
+
+    events = this._events;
+    if (events)
+      doError = (doError && events.error == null);
+    else if (!doError)
+      return false;
+
+    domain = this.domain;
+
+    // If there is no 'error' event listener then throw.
+    if (doError) {
+      er = arguments[1];
+      if (domain) {
+        if (!er)
+          er = new Error('Uncaught, unspecified "error" event');
+        er.domainEmitter = this;
+        er.domain = domain;
+        er.domainThrown = false;
+        domain.emit('error', er);
+      } else if (er instanceof Error) {
+        throw er; // Unhandled 'error' event
+      } else {
         // At least give some kind of context to the user
-        var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));
+        var err = new Error('Uncaught, unspecified "error" event. (' + er + ')');
         err.context = er;
-        throw err; // Unhandled 'error' event
+        throw err;
       }
+      return false;
+    }
 
-      var handler = events[type];
-
-      if (handler === undefined)
-        return false;
-
-      if (typeof handler === 'function') {
-        ReflectApply(handler, this, args);
-      } else {
-        var len = handler.length;
-        var listeners = arrayClone(handler, len);
-        for (var i = 0; i < len; ++i)
-          ReflectApply(listeners[i], this, args);
-      }
+    handler = events[type];
+
+    if (!handler)
+      return false;
+
+    var isFn = typeof handler === 'function';
+    len = arguments.length;
+    switch (len) {
+      // fast cases
+      case 1:
+        emitNone(handler, isFn, this);
+        break;
+      case 2:
+        emitOne(handler, isFn, this, arguments[1]);
+        break;
+      case 3:
+        emitTwo(handler, isFn, this, arguments[1], arguments[2]);
+        break;
+      case 4:
+        emitThree(handler, isFn, this, arguments[1], arguments[2], arguments[3]);
+        break;
+      // slower
+      default:
+        args = new Array(len - 1);
+        for (i = 1; i < len; i++)
+          args[i - 1] = arguments[i];
+        emitMany(handler, isFn, this, args);
+    }
 
-      return true;
-    };
+    return true;
+  };
 
-    function _addListener(target, type, listener, prepend) {
-      var m;
-      var events;
-      var existing;
+  function _addListener(target, type, listener, prepend) {
+    var m;
+    var events;
+    var existing;
 
-      checkListener(listener);
+    if (typeof listener !== 'function')
+      throw new TypeError('"listener" argument must be a function');
 
-      events = target._events;
-      if (events === undefined) {
-        events = target._events = Object.create(null);
-        target._eventsCount = 0;
-      } else {
-        // To avoid recursion in the case that type === "newListener"! Before
-        // adding it to the listeners, first emit "newListener".
-        if (events.newListener !== undefined) {
-          target.emit('newListener', type,
-                      listener.listener ? listener.listener : listener);
-
-          // Re-assign `events` because a newListener handler could have caused the
-          // this._events to be assigned to a new object
-          events = target._events;
-        }
-        existing = events[type];
+    events = target._events;
+    if (!events) {
+      events = target._events = new EventHandlers();
+      target._eventsCount = 0;
+    } else {
+      // To avoid recursion in the case that type === "newListener"! Before
+      // adding it to the listeners, first emit "newListener".
+      if (events.newListener) {
+        target.emit('newListener', type,
+                    listener.listener ? listener.listener : listener);
+
+        // Re-assign `events` because a newListener handler could have caused the
+        // this._events to be assigned to a new object
+        events = target._events;
       }
+      existing = events[type];
+    }
 
-      if (existing === undefined) {
-        // Optimize the case of one listener. Don't need the extra array object.
-        existing = events[type] = listener;
-        ++target._eventsCount;
+    if (!existing) {
+      // Optimize the case of one listener. Don't need the extra array object.
+      existing = events[type] = listener;
+      ++target._eventsCount;
+    } else {
+      if (typeof existing === 'function') {
+        // Adding the second element, need to change to array.
+        existing = events[type] = prepend ? [listener, existing] :
+                                            [existing, listener];
       } else {
-        if (typeof existing === 'function') {
-          // Adding the second element, need to change to array.
-          existing = events[type] =
-            prepend ? [listener, existing] : [existing, listener];
-          // If we've already got an array, just append.
-        } else if (prepend) {
+        // If we've already got an array, just append.
+        if (prepend) {
           existing.unshift(listener);
         } else {
           existing.push(listener);
         }
+      }
 
-        // Check for listener leak
-        m = _getMaxListeners(target);
-        if (m > 0 && existing.length > m && !existing.warned) {
+      // Check for listener leak
+      if (!existing.warned) {
+        m = $getMaxListeners(target);
+        if (m && m > 0 && existing.length > m) {
           existing.warned = true;
-          // No error code for this since it is a Warning
-          // eslint-disable-next-line no-restricted-syntax
           var w = new Error('Possible EventEmitter memory leak detected. ' +
-                              existing.length + ' ' + String(type) + ' listeners ' +
-                              'added. Use emitter.setMaxListeners() to ' +
-                              'increase limit');
+                              existing.length + ' ' + type + ' listeners added. ' +
+                              'Use emitter.setMaxListeners() to increase limit');
           w.name = 'MaxListenersExceededWarning';
           w.emitter = target;
           w.type = type;
           w.count = existing.length;
-          ProcessEmitWarning(w);
+          emitWarning(w);
         }
       }
-
-      return target;
     }
 
-    EventEmitter.prototype.addListener = function addListener(type, listener) {
-      return _addListener(this, type, listener, false);
-    };
+    return target;
+  }
+  function emitWarning(e) {
+    typeof console.warn === 'function' ? console.warn(e) : console.log(e);
+  }
+  EventEmitter.prototype.addListener = function addListener(type, listener) {
+    return _addListener(this, type, listener, false);
+  };
 
-    EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+  EventEmitter.prototype.on = EventEmitter.prototype.addListener;
 
-    EventEmitter.prototype.prependListener =
-        function prependListener(type, listener) {
-          return _addListener(this, type, listener, true);
-        };
+  EventEmitter.prototype.prependListener =
+      function prependListener(type, listener) {
+        return _addListener(this, type, listener, true);
+      };
 
-    function onceWrapper() {
-      if (!this.fired) {
-        this.target.removeListener(this.type, this.wrapFn);
-        this.fired = true;
-        if (arguments.length === 0)
-          return this.listener.call(this.target);
-        return this.listener.apply(this.target, arguments);
+  function _onceWrap(target, type, listener) {
+    var fired = false;
+    function g() {
+      target.removeListener(type, g);
+      if (!fired) {
+        fired = true;
+        listener.apply(target, arguments);
       }
     }
+    g.listener = listener;
+    return g;
+  }
+
+  EventEmitter.prototype.once = function once(type, listener) {
+    if (typeof listener !== 'function')
+      throw new TypeError('"listener" argument must be a function');
+    this.on(type, _onceWrap(this, type, listener));
+    return this;
+  };
+
+  EventEmitter.prototype.prependOnceListener =
+      function prependOnceListener(type, listener) {
+        if (typeof listener !== 'function')
+          throw new TypeError('"listener" argument must be a function');
+        this.prependListener(type, _onceWrap(this, type, listener));
+        return this;
+      };
 
-    function _onceWrap(target, type, listener) {
-      var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
-      var wrapped = onceWrapper.bind(state);
-      wrapped.listener = listener;
-      state.wrapFn = wrapped;
-      return wrapped;
-    }
+  // emits a 'removeListener' event iff the listener was removed
+  EventEmitter.prototype.removeListener =
+      function removeListener(type, listener) {
+        var list, events, position, i, originalListener;
 
-    EventEmitter.prototype.once = function once(type, listener) {
-      checkListener(listener);
-      this.on(type, _onceWrap(this, type, listener));
-      return this;
-    };
+        if (typeof listener !== 'function')
+          throw new TypeError('"listener" argument must be a function');
 
-    EventEmitter.prototype.prependOnceListener =
-        function prependOnceListener(type, listener) {
-          checkListener(listener);
-          this.prependListener(type, _onceWrap(this, type, listener));
+        events = this._events;
+        if (!events)
           return this;
-        };
 
-    // Emits a 'removeListener' event if and only if the listener was removed.
-    EventEmitter.prototype.removeListener =
-        function removeListener(type, listener) {
-          var list, events, position, i, originalListener;
+        list = events[type];
+        if (!list)
+          return this;
 
-          checkListener(listener);
+        if (list === listener || (list.listener && list.listener === listener)) {
+          if (--this._eventsCount === 0)
+            this._events = new EventHandlers();
+          else {
+            delete events[type];
+            if (events.removeListener)
+              this.emit('removeListener', type, list.listener || listener);
+          }
+        } else if (typeof list !== 'function') {
+          position = -1;
 
-          events = this._events;
-          if (events === undefined)
-            return this;
+          for (i = list.length; i-- > 0;) {
+            if (list[i] === listener ||
+                (list[i].listener && list[i].listener === listener)) {
+              originalListener = list[i].listener;
+              position = i;
+              break;
+            }
+          }
 
-          list = events[type];
-          if (list === undefined)
+          if (position < 0)
             return this;
 
-          if (list === listener || list.listener === listener) {
-            if (--this._eventsCount === 0)
-              this._events = Object.create(null);
-            else {
-              delete events[type];
-              if (events.removeListener)
-                this.emit('removeListener', type, list.listener || listener);
-            }
-          } else if (typeof list !== 'function') {
-            position = -1;
-
-            for (i = list.length - 1; i >= 0; i--) {
-              if (list[i] === listener || list[i].listener === listener) {
-                originalListener = list[i].listener;
-                position = i;
-                break;
-              }
-            }
-
-            if (position < 0)
+          if (list.length === 1) {
+            list[0] = undefined;
+            if (--this._eventsCount === 0) {
+              this._events = new EventHandlers();
               return this;
-
-            if (position === 0)
-              list.shift();
-            else {
-              spliceOne(list, position);
+            } else {
+              delete events[type];
             }
-
-            if (list.length === 1)
-              events[type] = list[0];
-
-            if (events.removeListener !== undefined)
-              this.emit('removeListener', type, originalListener || listener);
+          } else {
+            spliceOne(list, position);
           }
 
-          return this;
-        };
-
-    EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
-
-    EventEmitter.prototype.removeAllListeners =
-        function removeAllListeners(type) {
-          var listeners, events, i;
-
-          events = this._events;
-          if (events === undefined)
-            return this;
+          if (events.removeListener)
+            this.emit('removeListener', type, originalListener || listener);
+        }
 
-          // not listening for removeListener, no need to emit
-          if (events.removeListener === undefined) {
-            if (arguments.length === 0) {
-              this._events = Object.create(null);
-              this._eventsCount = 0;
-            } else if (events[type] !== undefined) {
-              if (--this._eventsCount === 0)
-                this._events = Object.create(null);
-              else
-                delete events[type];
-            }
-            return this;
-          }
+        return this;
+      };
+      
+  // Alias for removeListener added in NodeJS 10.0
+  // https://nodejs.org/api/events.html#events_emitter_off_eventname_listener
+  EventEmitter.prototype.off = function(type, listener){
+      return this.removeListener(type, listener);
+  };
+
+  EventEmitter.prototype.removeAllListeners =
+      function removeAllListeners(type) {
+        var listeners, events;
+
+        events = this._events;
+        if (!events)
+          return this;
 
-          // emit removeListener for all listeners on all events
+        // not listening for removeListener, no need to emit
+        if (!events.removeListener) {
           if (arguments.length === 0) {
-            var keys = Object.keys(events);
-            var key;
-            for (i = 0; i < keys.length; ++i) {
-              key = keys[i];
-              if (key === 'removeListener') continue;
-              this.removeAllListeners(key);
-            }
-            this.removeAllListeners('removeListener');
-            this._events = Object.create(null);
+            this._events = new EventHandlers();
             this._eventsCount = 0;
-            return this;
+          } else if (events[type]) {
+            if (--this._eventsCount === 0)
+              this._events = new EventHandlers();
+            else
+              delete events[type];
           }
+          return this;
+        }
 
-          listeners = events[type];
-
-          if (typeof listeners === 'function') {
-            this.removeListener(type, listeners);
-          } else if (listeners !== undefined) {
-            // LIFO order
-            for (i = listeners.length - 1; i >= 0; i--) {
-              this.removeListener(type, listeners[i]);
-            }
+        // emit removeListener for all listeners on all events
+        if (arguments.length === 0) {
+          var keys = Object.keys(events);
+          for (var i = 0, key; i < keys.length; ++i) {
+            key = keys[i];
+            if (key === 'removeListener') continue;
+            this.removeAllListeners(key);
           }
-
+          this.removeAllListeners('removeListener');
+          this._events = new EventHandlers();
+          this._eventsCount = 0;
           return this;
-        };
-
-    function _listeners(target, type, unwrap) {
-      var events = target._events;
+        }
 
-      if (events === undefined)
-        return [];
+        listeners = events[type];
 
-      var evlistener = events[type];
-      if (evlistener === undefined)
-        return [];
+        if (typeof listeners === 'function') {
+          this.removeListener(type, listeners);
+        } else if (listeners) {
+          // LIFO order
+          do {
+            this.removeListener(type, listeners[listeners.length - 1]);
+          } while (listeners[0]);
+        }
 
-      if (typeof evlistener === 'function')
-        return unwrap ? [evlistener.listener || evlistener] : [evlistener];
+        return this;
+      };
 
-      return unwrap ?
-        unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
+  EventEmitter.prototype.listeners = function listeners(type) {
+    var evlistener;
+    var ret;
+    var events = this._events;
+
+    if (!events)
+      ret = [];
+    else {
+      evlistener = events[type];
+      if (!evlistener)
+        ret = [];
+      else if (typeof evlistener === 'function')
+        ret = [evlistener.listener || evlistener];
+      else
+        ret = unwrapListeners(evlistener);
     }
 
-    EventEmitter.prototype.listeners = function listeners(type) {
-      return _listeners(this, type, true);
-    };
-
-    EventEmitter.prototype.rawListeners = function rawListeners(type) {
-      return _listeners(this, type, false);
-    };
+    return ret;
+  };
 
-    EventEmitter.listenerCount = function(emitter, type) {
-      if (typeof emitter.listenerCount === 'function') {
-        return emitter.listenerCount(type);
-      } else {
-        return listenerCount.call(emitter, type);
-      }
-    };
+  EventEmitter.listenerCount = function(emitter, type) {
+    if (typeof emitter.listenerCount === 'function') {
+      return emitter.listenerCount(type);
+    } else {
+      return listenerCount.call(emitter, type);
+    }
+  };
 
-    EventEmitter.prototype.listenerCount = listenerCount;
-    function listenerCount(type) {
-      var events = this._events;
+  EventEmitter.prototype.listenerCount = listenerCount;
+  function listenerCount(type) {
+    var events = this._events;
 
-      if (events !== undefined) {
-        var evlistener = events[type];
+    if (events) {
+      var evlistener = events[type];
 
-        if (typeof evlistener === 'function') {
-          return 1;
-        } else if (evlistener !== undefined) {
-          return evlistener.length;
-        }
+      if (typeof evlistener === 'function') {
+        return 1;
+      } else if (evlistener) {
+        return evlistener.length;
       }
-
-      return 0;
     }
 
-    EventEmitter.prototype.eventNames = function eventNames() {
-      return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
-    };
-
-    function arrayClone(arr, n) {
-      var copy = new Array(n);
-      for (var i = 0; i < n; ++i)
-        copy[i] = arr[i];
-      return copy;
+    return 0;
+  }
+
+  EventEmitter.prototype.eventNames = function eventNames() {
+    return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : [];
+  };
+
+  // About 1.5x faster than the two-arg version of Array#splice().
+  function spliceOne(list, index) {
+    for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1)
+      list[i] = list[k];
+    list.pop();
+  }
+
+  function arrayClone(arr, i) {
+    var copy = new Array(i);
+    while (i--)
+      copy[i] = arr[i];
+    return copy;
+  }
+
+  function unwrapListeners(arr) {
+    var ret = new Array(arr.length);
+    for (var i = 0; i < ret.length; ++i) {
+      ret[i] = arr[i].listener || arr[i];
     }
-
-    function spliceOne(list, index) {
-      for (; index + 1 < list.length; index++)
-        list[index] = list[index + 1];
-      list.pop();
+    return ret;
+  }
+
+  function defined(val) {
+    return val !== void 0 && val !== null;
+  }
+  function full(val) {
+    return typeof val === "string" ? !!val : defined(val);
+  }
+
+  function isEqual(a, b, o, p) {
+    if (a instanceof Array) {
+      if (!(b instanceof Array))
+        return false;
+      return b.sort().join("") === a.sort().join("");
+    } else if (a instanceof Date) {
+      if (!(b instanceof Date))
+        return false;
+      return "" + a === "" + b;
+    } else if (a instanceof Function) {
+      if (!(b instanceof Function))
+        return false;
+    } else if (a instanceof Object) {
+      if (!(b instanceof Object))
+        return false;
+      if (a === o) {
+        return b === p;
+      } else {
+        return objectDeepEqual(a, b);
+      }
     }
-
-    function unwrapListeners(arr) {
-      var ret = new Array(arr.length);
-      for (var i = 0; i < ret.length; ++i) {
-        ret[i] = arr[i].listener || arr[i];
+    return a === b;
+  }
+  function objectDeepEqual(o, p) {
+    const keysO = Object.keys(o).sort();
+    const keysP = Object.keys(p).sort();
+    if (keysO.length !== keysP.length)
+      return false;
+    if (keysO.join("") !== keysP.join(""))
+      return false;
+    for (let i = 0; i < keysO.length; i++) {
+      const oVal = o[keysO[i]];
+      const pVal = p[keysP[i]];
+      if (!isEqual(oVal, pVal, o, p)) {
+        return false;
       }
-      return ret;
     }
-
-    function once(emitter, name) {
-      return new Promise(function (resolve, reject) {
-        function errorListener(err) {
-          emitter.removeListener(name, resolver);
-          reject(err);
+    return true;
+  }
+
+  function objectRemoveEmpty(obj) {
+    const newObj = {};
+    Object.keys(obj).forEach((key) => {
+      if (!(obj[key] instanceof Array) && obj[key] === Object(obj[key])) {
+        newObj[key] = objectRemoveEmpty(obj[key]);
+      } else if (obj[key] !== void 0) {
+        newObj[key] = obj[key];
+      }
+    });
+    return newObj;
+  }
+
+  function fixUrlStr(url) {
+    return url.replace(/([^:]\/)\/+/g, "$1");
+  }
+
+  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$a = (obj, key, value) => {
+    __defNormalProp$a(obj, typeof key !== "symbol" ? key + "" : key, value);
+    return value;
+  };
+  const _Cache = class _Cache {
+    constructor(options = {}) {
+      __publicField$a(this, "cache", []);
+      var _a;
+      const namespace = (_a = options.namespace) != null ? _a : "default";
+      if (_Cache.instance[namespace]) {
+        return _Cache.instance[namespace];
+      }
+      _Cache.instance[namespace] = this;
+      return this;
+    }
+    clean() {
+      this.cache.length = 0;
+    }
+    all() {
+      return this.cache;
+    }
+    /**
+     * Caching only a non-empty value.
+     *
+     * Useful for get or create strategy
+     * @example
+     * ```javascript
+     * const cache = new Cache();
+     * const getItemFunc = () => fetch(url).then((data) => {
+     *  return data.json(); // undefined
+     * });
+     * const item = await cache.addFull('foo', getItemFunc);
+     * if (!item) {
+     *   await createItem(); // 'New item'
+     * }
+     *
+     * // somewhere else in the code
+     * const item = await cache.addFull('foo', getItemFunc).then((resp) => {
+     *   console.log(resp); // 'New item'
+     * })
+     *
+     * ```
+     */
+    addFull(key, valueToSet, props) {
+      return this.add(key, valueToSet, props, true);
+    }
+    add(key, valueToSet, props, onlyFull) {
+      const exist = this._find(key, props);
+      if (!exist) {
+        let value;
+        if (valueToSet instanceof Function) {
+          value = valueToSet();
+        } else {
+          value = valueToSet;
         }
-
-        function resolver() {
-          if (typeof emitter.removeListener === 'function') {
-            emitter.removeListener('error', errorListener);
-          }
-          resolve([].slice.call(arguments));
+        const props_ = props && JSON.parse(JSON.stringify(objectRemoveEmpty(props)));
+        const cacheItem = {
+          key,
+          value,
+          props: props_,
+          // TODO: remove backward compatibility use only props
+          options: props_
+        };
+        if (onlyFull && !full(value)) {
+          return value;
         }
-        eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
-        if (name !== 'error') {
-          addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
+        this.cache.push(cacheItem);
+        if (value instanceof Promise) {
+          value.catch((er) => {
+            this.delete(key, props);
+            throw er;
+          });
+          if (onlyFull) {
+            value.then((x) => {
+              if (!full(x)) {
+                this.delete(key, props);
+              }
+              return x;
+            });
+          }
+          return value;
         }
-      });
+        return value;
+      } else {
+        return exist.value;
+      }
     }
-
-    function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
-      if (typeof emitter.on === 'function') {
-        eventTargetAgnosticAddListener(emitter, 'error', handler, flags);
+    match(key, props) {
+      const cacheRecord = this._find(key, props);
+      if (cacheRecord) {
+        return cacheRecord.value;
       }
     }
-
-    function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
-      if (typeof emitter.on === 'function') {
-        if (flags.once) {
-          emitter.once(name, listener);
-        } else {
-          emitter.on(name, listener);
-        }
-      } else if (typeof emitter.addEventListener === 'function') {
-        // EventTarget does not have `error` event semantics like Node
-        // EventEmitters, we do not listen for `error` events here.
-        emitter.addEventListener(name, function wrapListener(arg) {
-          // IE does not have builtin `{ once: true }` support so we
-          // have to do it manually.
-          if (flags.once) {
-            emitter.removeEventListener(name, wrapListener);
-          }
-          listener(arg);
-        });
+    matchAll(key, props) {
+      if (key) {
+        return this.cache.filter((x) => this._filter(x, key, props)).map((x) => x.value);
+      }
+      return this.cache.map((x) => x.value);
+    }
+    delete(keyOrItem, props) {
+      let exist = [];
+      if (typeof keyOrItem === "string") {
+        exist = this.cache.filter((x) => this._filter(x, keyOrItem, props));
       } else {
-        throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
+        exist.push(keyOrItem);
+      }
+      for (const e of exist) {
+        const index = this.cache.indexOf(e);
+        this.cache.splice(index, 1);
       }
     }
-
-    var CancelError = /** @class */ (function (_super) {
-        __extends(CancelError, _super);
-        function CancelError() {
-            var _this = _super.call(this) || this;
-            _this.name = 'CancelError';
-            Object.setPrototypeOf(_this, CancelError.prototype);
-            return _this;
-        }
-        return CancelError;
-    }(Error));
-
-    var PromiseControl = /** @class */ (function () {
-        function PromiseControl(options) {
-            if (options === void 0) { options = {}; }
-            this.options = options;
-            this._promises = new Map();
+    _find(key, props) {
+      return this.cache.find((x) => this._filter(x, key, props));
+    }
+    _filter(item, key, props) {
+      if (item.key === key) {
+        if (props) {
+          const itemProps = item.props || item.options;
+          return objectDeepEqual(itemProps || {}, objectRemoveEmpty(props));
         }
-        Object.defineProperty(PromiseControl.prototype, "isLoaded", {
-            get: function () {
-                return this._promises.size > 0;
-            },
-            enumerable: false,
-            configurable: true
+        return true;
+      }
+      return false;
+    }
+  };
+  __publicField$a(_Cache, "instance", {});
+  let Cache = _Cache;
+
+  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$9 = (obj, key, value) => {
+    __defNormalProp$9(obj, typeof key !== "symbol" ? key + "" : key, value);
+    return value;
+  };
+  class CancelError extends Error {
+    constructor() {
+      super();
+      __publicField$9(this, "name", "CancelError");
+      Object.setPrototypeOf(this, CancelError.prototype);
+    }
+  }
+
+  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$8 = (obj, key, value) => {
+    __defNormalProp$8(obj, typeof key !== "symbol" ? key + "" : key, value);
+    return value;
+  };
+  class PromiseControl {
+    constructor(options = {}) {
+      this.options = options;
+      __publicField$8(this, "_promises", /* @__PURE__ */ new Map());
+    }
+    get isLoaded() {
+      return this._promises.size > 0;
+    }
+    remove(promise) {
+      if (this._promises.has(promise)) {
+        this._promises.delete(promise);
+        this._onStop();
+      }
+    }
+    get(promise) {
+      return this._promises.get(promise);
+    }
+    add(promise, name) {
+      const key = name ? name : promise;
+      const exist = this._promises.get(key);
+      if (this.options.onStart && !this.isLoaded) {
+        this.options.onStart();
+      }
+      if (exist) {
+        return exist;
+      }
+      this._promises.set(key, promise);
+      promise.finally(() => {
+        this.remove(key);
+      });
+      return promise;
+    }
+    abort() {
+      if (this.isLoaded) {
+        this._promises.forEach((x) => {
+          if (x.cancel) {
+            x.cancel();
+          }
         });
-        PromiseControl.prototype.remove = function (promise) {
-            if (this._promises.has(promise)) {
-                this._promises.delete(promise);
-                this._onStop();
-            }
-        };
-        PromiseControl.prototype.get = function (promise) {
-            return this._promises.get(promise);
-        };
-        PromiseControl.prototype.add = function (promise, name) {
-            var _this = this;
-            var key = name ? name : promise;
-            var exist = this._promises.get(key);
-            if (this.options.onStart && !this.isLoaded) {
-                this.options.onStart();
-            }
-            if (exist) {
-                return exist;
-            }
-            this._promises.set(key, promise);
-            promise.finally(function () {
-                _this.remove(key);
-            });
-            return promise;
+        this._promises.clear();
+        this._onStop();
+      }
+    }
+    waitFunc(func, name = "") {
+      name = name || func.name;
+      const exist = this.get(name);
+      if (exist) {
+        return exist;
+      }
+      return this.add(func(), name);
+    }
+    WaitForMe(name = "") {
+      const get = this.get.bind(this);
+      const add = this.add.bind(this);
+      return function(target, key, descriptor) {
+        const originalMethod = descriptor.value;
+        name = name || key;
+        descriptor.value = function(...args) {
+          const exist = get(name);
+          if (exist) {
+            return exist;
+          }
+          const result = add(originalMethod.apply(this, args), name);
+          return result;
         };
-        PromiseControl.prototype.abort = function () {
-            if (this.isLoaded) {
-                this._promises.forEach(function (x) {
-                    if (x.cancel) {
-                        x.cancel();
-                    }
-                });
-                this._promises.clear();
-                this._onStop();
+        return descriptor;
+      };
+    }
+    /** @deprecated use {@link PromiseControl.WaitForMe } instead */
+    GetOrCreateDecorator(name = "") {
+      return this.WaitForMe(name);
+    }
+    _onStop() {
+      if (this.options.onStop && !this.isLoaded) {
+        this.options.onStop();
+      }
+    }
+  }
+
+  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$7 = (obj, key, value) => {
+    __defNormalProp$7(obj, typeof key !== "symbol" ? key + "" : key, value);
+    return value;
+  };
+  class TimeoutError extends Error {
+    constructor() {
+      super();
+      __publicField$7(this, "name", "TimeoutError");
+      Object.setPrototypeOf(this, TimeoutError.prototype);
+    }
+  }
+
+  var __defProp$6 = Object.defineProperty;
+  var __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __publicField$6 = (obj, key, value) => {
+    __defNormalProp$6(obj, typeof key !== "symbol" ? key + "" : key, value);
+    return value;
+  };
+  var _a;
+  const handleCallback = (resolve, reject, callback, r) => {
+    try {
+      resolve(callback(r));
+    } catch (e) {
+      reject(e);
+    }
+  };
+  let ID$1 = 0;
+  const _CancelablePromise = class _CancelablePromise {
+    constructor(executor, timeout) {
+      // @ts-ignore
+      __publicField$6(this, _a);
+      __publicField$6(this, "id", ID$1++);
+      __publicField$6(this, "_isCanceled", false);
+      __publicField$6(this, "_isPending", true);
+      __publicField$6(this, "_promise");
+      __publicField$6(this, "_cancelPromise");
+      __publicField$6(this, "_cancelHandlers", []);
+      __publicField$6(this, "_setCanceledCallback");
+      __publicField$6(this, "_parentPromise");
+      __publicField$6(this, "_children", []);
+      this._cancelPromise = new Promise((resolve_, reject_) => {
+        this._setCanceledCallback = (er) => resolve_(er || new CancelError());
+      });
+      const promises = [
+        this._cancelPromise,
+        new Promise((resolve, reject) => {
+          const onResolve = (value) => {
+            if (value instanceof _CancelablePromise) {
+              this.attach(value);
+            } else {
+              this._isPending = false;
+            }
+            resolve(value);
+          };
+          const onReject = (error) => {
+            this._isPending = false;
+            reject(error);
+          };
+          const onCancel = (handler) => {
+            if (!this._isPending) {
+              throw new Error(
+                "The `onCancel` handler was attached after the promise settled."
+              );
+            }
+            this._cancelHandlers.push(handler);
+          };
+          return executor(onResolve, onReject, onCancel);
+        })
+      ];
+      if (timeout) {
+        promises.push(
+          new Promise((resolve, reject) => {
+            setTimeout(() => {
+              if (this._isPending) {
+                try {
+                  this.cancel();
+                } finally {
+                  reject(new TimeoutError());
+                }
+              }
+            }, timeout);
+          })
+        );
+      }
+      this._promise = Promise.race(promises);
+    }
+    static createControl(opt) {
+      return new PromiseControl(opt);
+    }
+    static resolve(value) {
+      return new _CancelablePromise((resolve) => resolve(value));
+    }
+    static reject(value) {
+      return new _CancelablePromise((resolve, reject) => reject(value));
+    }
+    static all(values) {
+      return new _CancelablePromise((resolve, reject) => {
+        Promise.all(values).then(resolve).catch(reject);
+      }).catch((er) => {
+        if (er instanceof this.CancelError) {
+          for (const v of values) {
+            const v_ = v;
+            if ("cancel" in v_) {
+              v_.cancel();
             }
-        };
-        PromiseControl.prototype.waitFunc = function (func, name) {
-            if (name === void 0) { name = ''; }
-            name = name || func.name;
-            var exist = this.get(name);
-            if (exist) {
-                return exist;
+          }
+        }
+        throw er;
+      });
+    }
+    attach(p) {
+      if (this._isCanceled) {
+        p.cancel();
+      } else {
+        this._children.push(p);
+      }
+    }
+    then(onfulfilled, onrejected) {
+      const p = new _CancelablePromise((resolve, reject) => {
+        if (this._promise) {
+          const reject_ = (r) => {
+            if (onrejected) {
+              handleCallback(resolve, reject, onrejected, r);
+            } else {
+              reject(r);
+            }
+          };
+          this._promise.then((r) => {
+            if (this._isCanceled) {
+              reject_(r);
+            } else {
+              if (onfulfilled) {
+                handleCallback(resolve, reject, onfulfilled, r);
+              } else {
+                resolve(r);
+              }
             }
-            return this.add(func(), name);
-        };
-        PromiseControl.prototype.WaitForMe = function (name) {
-            if (name === void 0) { name = ''; }
-            var get = this.get.bind(this);
-            var add = this.add.bind(this);
-            return function (target, key, descriptor) {
-                var originalMethod = descriptor.value;
-                name = name || key;
-                descriptor.value = function () {
-                    var args = [];
-                    for (var _i = 0; _i < arguments.length; _i++) {
-                        args[_i] = arguments[_i];
-                    }
-                    var exist = get(name);
-                    if (exist) {
-                        return exist;
-                    }
-                    var result = add(originalMethod.apply(this, args), name);
-                    return result;
-                };
-                return descriptor;
-            };
-        };
-        /** @deprecated use {@link PromiseControl.WaitForMe } instead */
-        PromiseControl.prototype.GetOrCreateDecorator = function (name) {
-            if (name === void 0) { name = ''; }
-            return this.WaitForMe(name);
-        };
-        PromiseControl.prototype._onStop = function () {
-            if (this.options.onStop && !this.isLoaded) {
-                this.options.onStop();
+          }, reject_);
+        }
+      });
+      p._parentPromise = this;
+      this._children.push(p);
+      return p;
+    }
+    catch(onrejected) {
+      if (this._isCanceled && onrejected) {
+        onrejected(new CancelError());
+      }
+      return this.then(void 0, onrejected);
+    }
+    finally(onfinally) {
+      if (this._promise) {
+        return this._promise.finally(onfinally);
+      }
+      if (this._isCanceled) {
+        return Promise.reject(new CancelError());
+      }
+      return Promise.reject(onfinally);
+    }
+    cancel() {
+      if (this._isCanceled || !this._isPending) {
+        return this;
+      }
+      this._isCanceled = true;
+      const parent = this._getTopParent();
+      if (parent) {
+        parent.cancel();
+      }
+      if (this._children) {
+        this._children.forEach((x) => x.cancel());
+      }
+      if (this._isPending) {
+        if (this._cancelHandlers.length) {
+          try {
+            for (const handler of this._cancelHandlers) {
+              handler();
             }
-        };
-        return PromiseControl;
-    }());
-
-    var TimeoutError = /** @class */ (function (_super) {
-        __extends(TimeoutError, _super);
-        function TimeoutError() {
-            var _this = _super.call(this) || this;
-            _this.name = 'TimeoutError';
-            Object.setPrototypeOf(_this, TimeoutError.prototype);
-            return _this;
+          } catch (error) {
+          }
         }
-        return TimeoutError;
-    }(Error));
-
-    var handleCallback = function (resolve, reject, callback, r) {
+        if (this._setCanceledCallback) {
+          this._setCanceledCallback();
+        }
+      }
+      this._destroy();
+      return this;
+    }
+    _getTopParent() {
+      let parent = this._parentPromise;
+      let hasParent = !!parent;
+      while (hasParent) {
+        if (parent && parent._parentPromise) {
+          parent = parent._parentPromise;
+          hasParent = !!parent;
+        } else {
+          hasParent = false;
+        }
+      }
+      return parent;
+    }
+    _destroy() {
+      this._setCanceledCallback = void 0;
+      this._cancelPromise = void 0;
+      this._promise = void 0;
+    }
+  };
+  _a = Symbol.toStringTag;
+  __publicField$6(_CancelablePromise, "CancelError", CancelError);
+  __publicField$6(_CancelablePromise, "TimeoutError", TimeoutError);
+  __publicField$6(_CancelablePromise, "PromiseControl", PromiseControl);
+  let CancelablePromise = _CancelablePromise;
+  Object.setPrototypeOf(CancelablePromise.prototype, Promise.prototype);
+
+  var __defProp$5 = Object.defineProperty;
+  var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __publicField$5 = (obj, key, value) => {
+    __defNormalProp$5(obj, typeof key !== "symbol" ? key + "" : key, value);
+    return value;
+  };
+  class NgwError extends Error {
+    constructor(er) {
+      super();
+      __publicField$5(this, "name", "NgwError");
+      __publicField$5(this, "title");
+      __publicField$5(this, "message");
+      __publicField$5(this, "detail");
+      __publicField$5(this, "exception");
+      __publicField$5(this, "status_code");
+      __publicField$5(this, "data");
+      __publicField$5(this, "guru_meditation");
+      Object.assign(this, er);
+      Object.setPrototypeOf(this, NgwError.prototype);
+    }
+  }
+
+  var __defProp$4 = Object.defineProperty;
+  var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __publicField$4 = (obj, key, value) => {
+    __defNormalProp$4(obj, typeof key !== "symbol" ? key + "" : key, value);
+    return value;
+  };
+  class ResourceNotFoundError extends NgwError {
+    constructor(obj) {
+      super(obj);
+      __publicField$4(this, "name", "ResourceNotFoundError");
+      __publicField$4(this, "exception", "nextgisweb.resource.exception.ResourceNotFound");
+      Object.setPrototypeOf(this, ResourceNotFoundError.prototype);
+    }
+  }
+
+  function isObject(val) {
+    return Object.prototype.toString.call(val) === "[object Object]";
+  }
+
+  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$3 = Object.defineProperty;
+  var __defProps = Object.defineProperties;
+  var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+  var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
+  var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+  var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+  var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __spreadValues$1 = (a, b) => {
+    for (var prop in b || (b = {}))
+      if (__hasOwnProp$1.call(b, prop))
+        __defNormalProp$3(a, prop, b[prop]);
+    if (__getOwnPropSymbols$1)
+      for (var prop of __getOwnPropSymbols$1(b)) {
+        if (__propIsEnum$1.call(b, prop))
+          __defNormalProp$3(a, prop, b[prop]);
+      }
+    return a;
+  };
+  var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+  var __publicField$3 = (obj, key, value) => {
+    __defNormalProp$3(obj, typeof key !== "symbol" ? key + "" : key, value);
+    return value;
+  };
+  var __async = (__this, __arguments, generator) => {
+    return new Promise((resolve, reject) => {
+      var fulfilled = (value) => {
         try {
-            resolve(callback(r));
+          step(generator.next(value));
+        } catch (e) {
+          reject(e);
         }
-        catch (e) {
-            reject(e);
+      };
+      var rejected = (value) => {
+        try {
+          step(generator.throw(value));
+        } catch (e) {
+          reject(e);
         }
-    };
-    var ID$1 = 0;
+      };
+      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) {
+      this.connector = connector;
+      __publicField$3(this, "cache", new Cache());
+    }
+    // -------------------------------------------------------------------------
+    // Resource Methods
+    // -------------------------------------------------------------------------
     /**
-     * Promise that can be canceled
+     * Receive resource from NGW by id, keyname or search-object parameter.
+     * @param resource - Resource id, keyname or search-object
      *
-     * @example
-     * Catch `CancelError`
-     * ```javascript
-     * import CancelablePromise from "@nextgis/cancelable-promise";
-     *
-     * const promise = new CancelablePromise((resolve, reject) => {
-     *  setTimeout(() => resolve(), 100);
-     * }).catch((er) => {
-     *  if (er.name === "CancelError") {
-     *    // handle cancel error
-     *  }
-     *  throw er;
-     * });
-     *
-     * promise.cancel();
-     * ```
-     * @example
-     * Handle `onCancel` callback
-     * ```javascript
-     * import CancelablePromise from "@nextgis/cancelable-promise";
-     *
-     * const promise = new CancelablePromise((resolve, reject, onCancel) => {
-     *   const xhr = new XMLHttpRequest();
-     *   xhr.open("GET", url, true);
-     *   xhr.onload = () => {
-     *     resolve(xhr.responseText);
-     *   };
-     *   xhr.onerror = (er) => {
-     *     reject(er);
-     *   };
-     *
-     *   onCancel(() => {
-     *     xhr.abort();
-     *   });
+     * @remarks
+     * Fetching resource would be cached to speed up next call
+     */
+    getOne(resource, requestOptions) {
+      const cache = new Cache();
+      const forCache = {};
+      const opt = __spreadProps(__spreadValues$1({}, requestOptions), { cache: false });
+      if (typeof resource === "string") {
+        forCache.keyname = resource;
+      } else if (typeof resource === "number") {
+        forCache.id = resource;
+      } else if (isObject(resource)) {
+        if (resource.id !== void 0) {
+          forCache.id = resource.id;
+        } else {
+          if (resource.keyname) {
+            forCache.keyname = resource.keyname;
+          }
+          if (resource.display_name) {
+            forCache.display_name = resource.display_name;
+          }
+        }
+      }
+      const makeRequest = () => {
+        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 CancelablePromise.resolve(void 0);
+      };
+      return cache.addFull("resource", makeRequest, forCache);
+    }
+    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
      *
-     *   xhr.send();
-     * });
+     * @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 CancelablePromise.resolve(resource);
+      } else if (typeof resource === "string" || isObject(resource)) {
+        return this.getOne(resource, requestOptions).then((res) => {
+          if (res) {
+            return res.resource.id;
+          }
+        });
+      }
+      return CancelablePromise.resolve(void 0);
+    }
+    /**
+     * A fast way to retrieve resource ID for any resource definition.
+     * @param resource - Any available resource definition
      *
-     * promise.cancel();
-     * ```
+     * @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
      */
-    var CancelablePromise$1 = /** @class */ (function () {
-        function CancelablePromise(executor, timeout) {
-            var _this = this;
-            this.id = ID$1++;
-            this._isCanceled = false;
-            this._isPending = true;
-            this._cancelHandlers = [];
-            this._children = [];
-            this._cancelPromise = new Promise(function (resolve_, reject_) {
-                _this._setCanceledCallback = function (er) { return resolve_(er || new CancelError()); };
-            });
-            var promises = [
-                this._cancelPromise,
-                new Promise(function (resolve, reject) {
-                    var onResolve = function (value) {
-                        if (value instanceof CancelablePromise) {
-                            _this.attach(value);
-                        }
-                        else {
-                            _this._isPending = false;
-                        }
-                        // TODO: fix types, `undefined` not allowed since 19.12.2020
-                        resolve(value);
-                    };
-                    var onReject = function (error) {
-                        _this._isPending = false;
-                        reject(error);
-                    };
-                    var onCancel = function (handler) {
-                        if (!_this._isPending) {
-                            throw new Error('The `onCancel` handler was attached after the promise settled.');
-                        }
-                        _this._cancelHandlers.push(handler);
-                    };
-                    return executor(onResolve, onReject, onCancel);
-                }),
-            ];
-            if (timeout) {
-                promises.push(new Promise(function (resolve, reject) {
-                    setTimeout(function () {
-                        if (_this._isPending) {
-                            try {
-                                _this.cancel();
-                            }
-                            finally {
-                                reject(new TimeoutError());
-                            }
-                        }
-                    }, timeout);
-                }));
-            }
-            this._promise = Promise.race(promises);
+    getIdOrFail(resource, requestOptions) {
+      return this.getId(resource, requestOptions).then((resp) => {
+        if (resp === void 0) {
+          throw new Error();
         }
-        CancelablePromise.createControl = function (opt) {
-            return new PromiseControl(opt);
-        };
-        CancelablePromise.resolve = function (value) {
-            return new CancelablePromise(function (resolve) { return resolve(value); });
-        };
-        CancelablePromise.reject = function (value) {
-            return new CancelablePromise(function (resolve, reject) { return reject(value); });
-        };
-        CancelablePromise.all = function (values) {
-            var _this = this;
-            return new CancelablePromise(function (resolve, reject) {
-                Promise.all(values).then(resolve).catch(reject);
-            }).catch(function (er) {
-                if (er instanceof _this.CancelError) {
-                    for (var _i = 0, values_1 = values; _i < values_1.length; _i++) {
-                        var v = values_1[_i];
-                        var v_ = v;
-                        if ('cancel' in v_) {
-                            v_.cancel();
-                        }
-                    }
-                }
-                throw er;
-            });
-        };
-        CancelablePromise.prototype.attach = function (p) {
-            if (this._isCanceled) {
-                p.cancel();
-            }
-            else {
-                this._children.push(p);
-            }
-        };
-        CancelablePromise.prototype.then = function (onfulfilled, onrejected) {
-            var _this = this;
-            var p = new CancelablePromise(function (resolve, reject) {
-                if (_this._promise) {
-                    var reject_1 = function (r) {
-                        if (onrejected) {
-                            handleCallback(resolve, reject, onrejected, r);
-                        }
-                        else {
-                            reject(r);
-                        }
-                    };
-                    _this._promise.then(function (r) {
-                        if (_this._isCanceled) {
-                            reject_1(r);
-                        }
-                        else {
-                            if (onfulfilled) {
-                                handleCallback(resolve, reject, onfulfilled, r);
-                            }
-                            else {
-                                resolve(r);
-                            }
-                        }
-                    }, reject_1);
-                }
-            });
-            p._parentPromise = this;
-            this._children.push(p);
-            return p;
-        };
-        CancelablePromise.prototype.catch = function (onrejected) {
-            if (this._isCanceled && onrejected) {
-                onrejected(new CancelError());
-            }
-            return this.then(undefined, onrejected);
-        };
-        CancelablePromise.prototype.finally = function (onfinally) {
-            if (this._promise) {
-                return this._promise.finally(onfinally);
+        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.get("resource.search", requestOptions, __spreadValues$1({
+            serialization: "full"
+          }, query)).then((resources) => {
+            if (resources) {
+              for (const x of resources) {
+                this.cache.add("resource.item", CancelablePromise.resolve(x), {
+                  id: x.resource.id
+                });
+              }
             }
-            if (this._isCanceled) {
-                return Promise.reject(new CancelError());
+            return resources;
+          });
+        }
+        return items;
+      });
+    }
+    getParent(resource, requestOptions) {
+      return this.getOne(resource, requestOptions).then((child) => {
+        if (child) {
+          return this.getOne(child.resource.parent.id, requestOptions);
+        }
+        return CancelablePromise.resolve(void 0);
+      });
+    }
+    getChildrenOf(resource, requestOptions) {
+      return this.getIdOrFail(resource).then(
+        (parent) => this._getChildrenOf(parent, requestOptions)
+      );
+    }
+    update(resource, data) {
+      return this.getId(resource).then((id) => {
+        if (id !== void 0) {
+          return this.connector.put("resource.item", { data }, { id });
+        }
+      });
+    }
+    /**
+     * Fast way to delete resource from NGW and clean cache.
+     * @param resource - Resource definition
+     */
+    delete(resource) {
+      return this.getId(resource).then((id) => {
+        if (id !== void 0) {
+          return this.connector.delete("resource.item", null, { id }).then(() => {
+            this._cleanResourceItemCache(id);
+            return void 0;
+          });
+        }
+      });
+    }
+    _getChildrenOf(parent, requestOptions, _items = []) {
+      return this.connector.get(
+        "resource.collection",
+        __spreadValues$1({ cache: true }, requestOptions),
+        {
+          parent
+        }
+      ).then((items) => {
+        const recursivePromises = [];
+        for (const item of items) {
+          this.cache.add("resource.item", CancelablePromise.resolve(item), {
+            id: item.resource.id
+          });
+          _items.push(item);
+          if ((requestOptions == null ? void 0 : requestOptions.recursive) && item.resource.children) {
+            recursivePromises.push(
+              this._getChildrenOf(item.resource.id, requestOptions, _items)
+            );
+          }
+        }
+        if (recursivePromises.length) {
+          return CancelablePromise.all(recursivePromises).then(() => {
+            return _items;
+          });
+        }
+        return _items;
+      });
+    }
+    _cleanResourceItemCache(id) {
+      return __async(this, null, function* () {
+        const all = this.cache.all();
+        const toDelete = [];
+        for (const c of all) {
+          const cid = c.options && c.options.id;
+          if (["resource.item", "resource"].includes(c.key) && cid !== void 0) {
+            if (typeof cid === "number") {
+              if (cid === id) {
+                toDelete.push(c);
+              }
+            } else {
+              const rid = yield this.getId(cid);
+              if (rid === id) {
+                toDelete.push(c);
+              }
             }
-            return Promise.reject(onfinally);
-        };
-        CancelablePromise.prototype.cancel = function () {
-            // No reason to run cancel action if promise is already complete
-            if (this._isCanceled || !this._isPending) {
-                return this;
+          }
+        }
+        for (const d of toDelete) {
+          this.cache.delete(d);
+        }
+      });
+    }
+    _fetchResourceById(id, requestOptions) {
+      const promise = () => this.connector.get("resource.item", requestOptions, { id });
+      return this.cache.add("resource.item", promise, {
+        id
+      }).catch((er) => {
+        if (!(er instanceof ResourceNotFoundError)) {
+          throw er;
+        }
+        return void 0;
+      });
+    }
+    _fetchResourceBy(resource, requestOptions) {
+      return this.getMany(resource, requestOptions).then((resources) => {
+        return resources[0];
+      });
+    }
+    _resourceCacheFilter(resource) {
+      return CancelablePromise.all(this.cache.matchAll("resource.item")).then(
+        (resources) => {
+          const items = [];
+          resources.filter((x) => {
+            if (x) {
+              if (resource.keyname && x.resource.keyname) {
+                return resource.keyname === x.resource.keyname;
+              }
+              if (defined(resource.id) && defined(x.resource.id)) {
+                return resource.id === x.resource.id;
+              }
+              return resourceCompare(resource, x.resource);
             }
-            this._isCanceled = true;
-            var parent = this._getTopParent();
-            if (parent) {
-                parent.cancel();
+          });
+          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);
+    }
+  }
+
+  var __defProp$2 = Object.defineProperty;
+  var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __publicField$2 = (obj, key, value) => {
+    __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
+    return value;
+  };
+  class InsufficientPermissionsError extends NgwError {
+    constructor(obj) {
+      super(obj);
+      __publicField$2(this, "name", "InsufficientPermissionsError");
+      __publicField$2(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;
+    });
+  }
+
+  function apiRequest(opt) {
+    const params = opt.params;
+    return new CancelablePromise((resolve, reject) => {
+      opt.connector.connect().then((apiItems) => {
+        let apiItem = apiItems && apiItems[opt.name];
+        if (apiItem) {
+          apiItem = [...apiItem];
+          let url = apiItem.shift();
+          if (apiItem.length) {
+            const replaceParams = {};
+            for (let fry = 0; fry < apiItem.length; fry++) {
+              const arg = apiItem[fry];
+              replaceParams[fry] = "{" + arg + "}";
+              if (params[arg] === void 0) {
+                throw new Error(
+                  "`" + arg + "` url api argument is not specified"
+                );
+              }
             }
-            if (this._children) {
-                this._children.forEach(function (x) { return x.cancel(); });
+            if (url) {
+              url = template(url, replaceParams);
             }
-            if (this._isPending) {
-                if (this._cancelHandlers.length) {
-                    try {
-                        for (var _i = 0, _a = this._cancelHandlers; _i < _a.length; _i++) {
-                            var handler = _a[_i];
-                            handler();
-                        }
-                    }
-                    catch (error) {
-                        // this._setCanceledCallback(error);
-                    }
-                }
-                if (this._setCanceledCallback) {
-                    this._setCanceledCallback();
-                }
+          }
+          if (params) {
+            const paramArray = [];
+            const paramList = params.paramList;
+            if (Array.isArray(paramList)) {
+              delete params.paramList;
+              paramList.forEach((x) => {
+                paramArray.push(`${x[0]}=${x[1]}`);
+              });
+            }
+            for (const p in params) {
+              if (apiItem.indexOf(p) === -1) {
+                paramArray.push(`${p}=${params[p]}`);
+              }
             }
-            this._destroy();
-            return this;
-        };
-        CancelablePromise.prototype._getTopParent = function () {
-            var parent = this._parentPromise;
-            var hasParent = !!parent;
-            while (hasParent) {
-                if (parent && parent._parentPromise) {
-                    parent = parent._parentPromise;
-                    hasParent = !!parent;
-                }
-                else {
-                    hasParent = false;
-                }
+            if (paramArray.length) {
+              url = url + "?" + paramArray.join("&");
             }
-            return parent;
-        };
-        CancelablePromise.prototype._destroy = function () {
-            this._setCanceledCallback = undefined;
-            this._cancelPromise = undefined;
-            this._promise = undefined;
-        };
-        CancelablePromise.CancelError = CancelError;
-        CancelablePromise.TimeoutError = TimeoutError;
-        CancelablePromise.PromiseControl = PromiseControl;
-        return CancelablePromise;
-    }());
-    Object.setPrototypeOf(CancelablePromise$1.prototype, Promise.prototype);
-
+          }
+          if (url) {
+            resolve(opt.connector.makeQuery(url, params, opt.requestOptions));
+          } else {
+            reject(new Error("request url is not set"));
+          }
+        } else {
+          resolve(void 0);
+        }
+      }).catch((er) => {
+        reject(er);
+      });
+    });
+  }
+
+  var __defProp$1 = Object.defineProperty;
+  var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __publicField$1 = (obj, key, value) => {
+    __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+    return value;
+  };
+  class NetworkError extends Error {
+    constructor(url) {
+      super();
+      __publicField$1(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 = Object.defineProperty;
+  var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __propIsEnum = Object.prototype.propertyIsEnumerable;
+  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __spreadValues = (a, b) => {
+    for (var prop in b || (b = {}))
+      if (__hasOwnProp.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    if (__getOwnPropSymbols)
+      for (var prop of __getOwnPropSymbols(b)) {
+        if (__propIsEnum.call(b, prop))
+          __defNormalProp(a, prop, b[prop]);
+      }
+    return a;
+  };
+  var __publicField = (obj, key, value) => {
+    __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+    return value;
+  };
+  let ID = 0;
+  class NgwConnector {
+    constructor(options) {
+      this.options = options;
+      __publicField(this, "id", ID++);
+      __publicField(this, "emitter", new EventEmitter());
+      __publicField(this, "user");
+      __publicField(this, "resources");
+      __publicField(this, "routeStr", "/api/component/pyramid/route");
+      __publicField(this, "activeRequests", []);
+      __publicField(this, "requestTransform");
+      const exist = findConnector(options);
+      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(this);
+        addConnector(this);
+      }
+    }
+    static create(options) {
+      return new this(options);
+    }
+    setRequestTransform(requestTransform) {
+      this.requestTransform = requestTransform;
+    }
     /**
-     * A promise you can stop
-     *
-     * @packageDocumentation
-     * @module cancelable-promise
+     * Fast way to specify the connection address to NextGIS Web.
+     * The current connection will be severed.
+     * @param baseUrl - NGW url
      */
-    var CancelablePromise = CancelablePromise$1;
-
+    setNgw(baseUrl) {
+      this.logout();
+      this.options.baseUrl = baseUrl;
+      addConnector(this);
+    }
     /**
-     * from https://github.com/CesiumGS/cesium/blob/master/Source/Core/defined.js
-     *
-     * @param val - The object.
-     * @returns Returns true if the object is defined, returns false otherwise.
-     *
+     * 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
-     * if (defined(positions)) {
-     *   doSomething();
-     * } else {
-     *   doSomethingElse();
-     * }
+     * const connector = new NgwConnector({baseUrl: 'https://demo.nextgis.com'});
+     * connector.connect()
+     *   .then(() => console.log('Ok'))
+     *   .catch((er) => console.log('Connection problem', er));
      * ```
      */
-    function defined(val) {
-        return val !== undefined && val !== null;
+    connect() {
+      const cache = new Cache();
+      const auth = this.options.auth;
+      const makeConnect = () => new CancelablePromise((resolve, reject) => {
+        const makeQuery = () => {
+          return this.makeQuery(this.routeStr, {}, {}).then((route) => {
+            resolve(route);
+          }).catch((er) => {
+            reject(er);
+          });
+        };
+        if (auth) {
+          const { login, password } = auth;
+          if (login && password) {
+            return this._login({ login, password }).then(() => {
+              return makeQuery();
+            }).catch((er) => reject(er));
+          }
+        }
+        return makeQuery();
+      });
+      return cache.add("route", makeConnect, {
+        id: this.id,
+        auth,
+        baseUrl: this.options.baseUrl
+      });
     }
     /**
-     * from https://github.com/CesiumGS/cesium/blob/master/Source/Core/defined.js
-     *
-     * @param val - The object.
-     * @returns Returns true if the object is defined and not empty string, returns false otherwise.
-     *
-     * @example
-     * ```javascript
-     * full('foo') // true
-     * full('') // false
-     * full(undefined) // false
-     * full(0) // true
-     * ```
+     * Quick way to change NextGIS Web user.
+     * @param credentials - New user credentials
      */
-    function full(val) {
-        return typeof val === 'string' ? !!val : defined(val);
+    login(credentials, options) {
+      this.logout();
+      addConnector(this);
+      return this._login(credentials, options);
     }
-
-    function isEqual(a, b, o, p) {
-        if (a instanceof Array) {
-            if (!(b instanceof Array))
-                return false;
-            //if (compareObjects(oVal, pVal === false) return false
-            //would work, too, and perhaps is a better fit, still, this is easy, too
-            return b.sort().join('') === a.sort().join('');
-        }
-        else if (a instanceof Date) {
-            if (!(b instanceof Date))
-                return false;
-            return '' + a === '' + b;
-        }
-        else if (a instanceof Function) {
-            if (!(b instanceof Function))
-                return false;
-            //ignore functions, or check them regardless?
-        }
-        else if (a instanceof Object) {
-            if (!(b instanceof Object))
-                return false;
-            if (a === o) {
-                return b === p;
-            }
-            else {
-                return objectDeepEqual(a, b);
-            }
-        }
-        return a === b;
-    }
-    // based on https://stackoverflow.com/a/13143059
-    function objectDeepEqual(o, p) {
-        var keysO = Object.keys(o).sort();
-        var keysP = Object.keys(p).sort();
-        if (keysO.length !== keysP.length)
-            return false;
-        if (keysO.join('') !== keysP.join(''))
-            return false;
-        for (var i = 0; i < keysO.length; i++) {
-            var oVal = o[keysO[i]];
-            var pVal = p[keysP[i]];
-            if (!isEqual(oVal, pVal, o, p)) {
-                return false;
-            }
+    /**
+     * Disconnecting a user. Aborting all current requests
+     */
+    logout() {
+      this.abort();
+      removeConnector(this);
+      this.options.auth = void 0;
+      this.user = void 0;
+      this.emitter.emit("logout");
+      this.resources.cache.clean();
+    }
+    getUserInfo(credentials, options) {
+      if (this.user && this.user.id) {
+        return CancelablePromise.resolve(this.user);
+      }
+      if (credentials) {
+        this.options.auth = credentials;
+      }
+      const options_ = __spreadValues({
+        headers: this.getAuthorizationHeaders(credentials)
+      }, 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
+        };
+      }
+    }
+    makeClientId(credentials) {
+      credentials = credentials || this.options.auth;
+      if (credentials) {
+        const { login, password } = credentials;
+        const str = unescape(encodeURIComponent(`${login}:${password}`));
+        {
+          return window.btoa(str);
         }
-        return true;
+      }
     }
-
-    function objectRemoveEmpty(obj) {
-        var newObj = {};
-        Object.keys(obj).forEach(function (key) {
-            if (!(obj[key] instanceof Array) && obj[key] === Object(obj[key])) {
-                newObj[key] = objectRemoveEmpty(obj[key]);
-            }
-            else if (obj[key] !== undefined) {
-                newObj[key] = obj[key];
-            }
-        });
-        return newObj;
+    /** Stop all api requests */
+    abort() {
+      for (const req of this.activeRequests) {
+        req.cancel();
+      }
+      this.activeRequests = [];
     }
-
-    function fixUrlStr(url) {
-        // remove double slash
-        return url.replace(/([^:]\/)\/+/g, '$1');
+    getActiveApiRequests() {
+      return [...this.activeRequests];
     }
-
     /**
+     * Send request to NGW api router.
+     * @param name - NGW route name from {@link https://docs.nextgis.com/docs_ngweb_dev/doc/developer/resource.html#routes | routes}
+     * @param params - Request item params or query params
+     * @param requestOptions - Request options
+     *
      * @example
      * ```javascript
-     * const cache1 = new Cache();
-     * cache1.add('foo', 'value');
      *
-     * const cache2 = new Cache();
-     * cache2.match('foo'); // value
+     * // there is such an NGW route item
+     * // "feature_layer.feature.item": [
+     * //   "/api/resource/{0}/feature/{1}",
+     * //   "id",
+     * //   "fid"
+     * // ],
+     *
+     * const connector = new NgwConnector({ baseUrl: 'https://example.nextgis.com' });
+     * connector.apiRequest('feature_layer.feature.item', {
+     *   // request params for {0} and {1}
+     *   'id': 2011,
+     *   'fid': 101,
+     *   // query params
+     *   'srs': 4326,
+     *   'geom_format': 'geojson',
+     * }, { method: 'GET' });
+     * // send get-request to 'https://example.nextgis.com/api/resource/2011/feature/101?srs=4326&geom_format=geojson'
      *
-     * const cache3 = new Cache({ namespace: 'foo' });
-     * cache3.match('foo'); // undefined
      * ```
+     */
+    apiRequest(name, params_ = {}, requestOptions = {}) {
+      var _a, _b;
+      const { method, headers, withCredentials, responseType } = requestOptions;
+      params_ = (_a = requestOptions.params) != null ? _a : params_;
+      const params = objectRemoveEmpty(params_);
+      const makeApiRequest = () => apiRequest({ name, params, requestOptions, connector: this });
+      if (requestOptions.cache && method === "GET") {
+        const cache = new Cache();
+        return cache.add(name, makeApiRequest, __spreadValues({
+          params
+        }, objectRemoveEmpty({
+          headers,
+          withCredentials,
+          responseType,
+          baseUrl: this.options.baseUrl,
+          userId: (_b = this.user) == null ? void 0 : _b.id
+        })));
+      }
+      return makeApiRequest();
+    }
+    /**
+     * Shortcut method for send POST request to NGW.
+     * @param name - NGW route name from {@link https://docs.nextgis.com/docs_ngweb_dev/doc/developer/resource.html#routes | routes}
+     * @param options - Request options
+     * @param params - Request item params or query params
      *
      * @example
      * ```javascript
-     * let COUNTER = 0;
-     * const createPromise = () => new Promise((res) => {
-     *   COUNTER++
-     *   setTimeout(() => res('Ok'), 300)
-     * });
-     *
-     * const cache = new Cache();
-     * for (let i = 0; i < 10; i++) {
-     *   cache.add('foo', createPromise).then((data) => {
-     *     console.log(data); // 'Ok'
-     *   });
-     * }
-     * console.log(COUNTER); // 1
+     * connector.post('resource.collection', { data: POST_PAYLOAD })
+     *   .then((newResource) => console.log(newResource))
+     *   .catch((error) => console.warn(error));
      * ```
      */
-    var Cache$1 = /** @class */ (function () {
-        function Cache(options) {
-            if (options === void 0) { options = {}; }
-            var _a;
-            this.cache = [];
-            var namespace = (_a = options.namespace) !== null && _a !== void 0 ? _a : 'default';
-            if (Cache.instance[namespace]) {
-                return Cache.instance[namespace];
-            }
-            Cache.instance[namespace] = this;
-            return this;
-        }
-        Cache.prototype.clean = function () {
-            this.cache.length = 0;
-        };
-        Cache.prototype.all = function () {
-            return this.cache;
-        };
-        /**
-         * Caching only a non-empty value.
-         *
-         * Useful for get or create strategy
-         * @example
-         * ```javascript
-         * const cache = new Cache();
-         * const getItemFunc = () => fetch(url).then((data) => {
-         *  return data.json(); // undefined
-         * });
-         * const item = await cache.addFull('foo', getItemFunc);
-         * if (!item) {
-         *   await createItem(); // 'New item'
-         * }
-         *
-         * // somewhere else in the code
-         * const item = await cache.addFull('foo', getItemFunc).then((resp) => {
-         *   console.log(resp); // 'New item'
-         * })
-         *
-         * ```
-         */
-        Cache.prototype.addFull = function (key, valueToSet, props) {
-            return this.add(key, valueToSet, props, true);
-        };
-        Cache.prototype.add = function (key, valueToSet, props, onlyFull) {
-            var _this = this;
-            var exist = this._find(key, props);
-            if (!exist) {
-                var value = void 0;
-                if (valueToSet instanceof Function) {
-                    value = valueToSet();
-                }
-                else {
-                    value = valueToSet;
-                }
-                var props_ = props && JSON.parse(JSON.stringify(objectRemoveEmpty(props)));
-                var cacheItem = {
-                    key: key,
-                    value: value,
-                    props: props_,
-                    // TODO: remove backward compatibility use only props
-                    options: props_,
-                };
-                if (onlyFull && !full(value)) {
-                    return value;
-                }
-                this.cache.push(cacheItem);
-                if (value instanceof Promise) {
-                    value.catch(function (er) {
-                        _this.delete(key, props);
-                        throw er;
-                    });
-                    if (onlyFull) {
-                        value.then(function (x) {
-                            if (!full(x)) {
-                                _this.delete(key, props);
-                            }
-                            return x;
-                        });
-                    }
-                    return value;
-                }
-                return value;
-            }
-            else {
-                return exist.value;
-            }
-        };
-        Cache.prototype.match = function (key, props) {
-            var cacheRecord = this._find(key, props);
-            if (cacheRecord) {
-                return cacheRecord.value;
-            }
-        };
-        Cache.prototype.matchAll = function (key, props) {
-            var _this = this;
-            if (key) {
-                return this.cache
-                    .filter(function (x) { return _this._filter(x, key, props); })
-                    .map(function (x) { return x.value; });
-            }
-            return this.cache.map(function (x) { return x.value; });
-        };
-        Cache.prototype.delete = function (keyOrItem, props) {
-            var _this = this;
-            var exist = [];
-            if (typeof keyOrItem === 'string') {
-                exist = this.cache.filter(function (x) { return _this._filter(x, keyOrItem, props); });
-            }
-            else {
-                exist.push(keyOrItem);
-            }
-            for (var _i = 0, exist_1 = exist; _i < exist_1.length; _i++) {
-                var e = exist_1[_i];
-                var index = this.cache.indexOf(e);
-                this.cache.splice(index, 1);
-            }
-        };
-        Cache.prototype._find = function (key, props) {
-            var _this = this;
-            return this.cache.find(function (x) { return _this._filter(x, key, props); });
-        };
-        Cache.prototype._filter = function (item, key, props) {
-            if (item.key === key) {
-                if (props) {
-                    // TODO: remove backward compatibility
-                    var itemProps = item.props || item.options;
-                    return objectDeepEqual(itemProps || {}, objectRemoveEmpty(props));
-                }
-                return true;
-            }
-            return false;
-        };
-        Cache.instance = {};
-        return Cache;
-    }());
-
+    post(name, options, params) {
+      options = options || {};
+      options.method = "POST";
+      return this.apiRequest(
+        name,
+        params,
+        options
+      );
+    }
     /**
-     * Caching for asynchronous functions
-     *
-     * @packageDocumentation
-     * @module cache
+     * Shortcut method for send GET request to NGW.
+     * @param name - NGW route name from {@link https://docs.nextgis.com/docs_ngweb_dev/doc/developer/resource.html#routes | routes}
+     * @param options - Request options
+     * @param params - Request item params or query params
      */
-    var Cache = Cache$1;
-
+    get(name, options, params) {
+      options = options || {};
+      options.method = "GET";
+      return this.apiRequest(
+        name,
+        params,
+        options
+      );
+    }
     /**
-     * Thrown when...
+     * Shortcut method for send PATCH request to NGW.
+     * @param name - NGW route name from {@link https://docs.nextgis.com/docs_ngweb_dev/doc/developer/resource.html#routes | routes}
+     * @param options - Request options
+     * @param params - Request item params or query params
      */
-    var NetworkError = /** @class */ (function (_super) {
-        __extends(NetworkError, _super);
-        function NetworkError(url) {
-            var _this = _super.call(this) || this;
-            _this.name = 'NetworkError';
-            Object.setPrototypeOf(_this, NetworkError.prototype);
-            _this.message = "Unable to request ".concat(url, ".\n    Possibly invalid NGW URL entered or CORS not configured to get request from ").concat(location.origin); // /control-panel/cors
-            return _this;
-        }
-        return NetworkError;
-    }(Error));
-
+    patch(name, options, params) {
+      options = options || {};
+      options.method = "PATCH";
+      return this.apiRequest(
+        name,
+        params,
+        options
+      );
+    }
     /**
-     * Thrown when...
+     * Shortcut method for send PUT request to NGW.
+     * @param name - NGW route name from {@link https://docs.nextgis.com/docs_ngweb_dev/doc/developer/resource.html#routes | routes}
+     * @param options - Request options
+     * @param params - Request item params or query params
      */
-    var NgwError = /** @class */ (function (_super) {
-        __extends(NgwError, _super);
-        function NgwError(er) {
-            var _this = _super.call(this) || this;
-            _this.name = 'NgwError';
-            Object.assign(_this, er);
-            Object.setPrototypeOf(_this, NgwError.prototype);
-            return _this;
+    put(name, options, params) {
+      options = options || {};
+      options.method = "PUT";
+      return this.apiRequest(
+        name,
+        params,
+        options
+      );
+    }
+    /**
+     * Shortcut method for send DELETE request to NGW.
+     * @param name - NGW route name from {@link https://docs.nextgis.com/docs_ngweb_dev/doc/developer/resource.html#routes | routes}
+     * @param options - Request options
+     * @param params - Request item params or query params
+     */
+    delete(name, options, params) {
+      options = options || {};
+      options.method = "DELETE";
+      return this.apiRequest(
+        name,
+        params,
+        options
+      );
+    }
+    /**
+     * Send request to NGW.
+     * @param url - URL address to NGW
+     * @param params - Query params
+     * @param options - Request options
+     */
+    makeQuery(url, params, options = {}) {
+      url = (this.options.baseUrl ? this.options.baseUrl : "") + url;
+      if (url) {
+        if (params) {
+          url = template(url, params);
         }
-        return NgwError;
-    }(Error));
-
-    function isObject(val) {
-        return Object.prototype.toString.call(val) === '[object Object]';
-    }
-
-    var loadData;
-    // @ts-ignore
-    {
-        loadData = function (url, callback, options, error, onCancel) {
-            if (options === void 0) { options = {}; }
-            options.method = options.method || 'GET';
-            var xhr = new XMLHttpRequest();
-            xhr.open(options.method || 'GET', url, true); // true for asynchronous
-            if (options.responseType === 'blob') {
-                xhr.responseType = options.responseType;
-            }
-            var getResponseText = function () {
-                try {
-                    return JSON.parse(xhr.responseText);
-                }
-                catch (er) {
-                    return xhr.responseText;
-                }
-            };
-            var processingResponse = function (forError) {
-                if (forError === void 0) { forError = false; }
-                var cb = forError ? error : callback;
-                if (options.responseType === 'blob') {
-                    cb(xhr.response);
-                }
-                else {
-                    if (xhr.responseText) {
-                        cb(getResponseText());
-                    }
-                    else {
-                        error({ message: '' });
-                    }
-                }
-            };
-            xhr.onload = function () {
-                if ([401, 403, 404, 422, 500].indexOf(xhr.status) !== -1) {
-                    error(new NgwError(getResponseText()));
-                }
-                processingResponse();
-            };
-            // xhr.onreadystatechange = () => {
-            //   if (
-            //     (xhr.readyState === 4 && xhr.status === 200) ||
-            //     (xhr.readyState === 3 && xhr.status === 201)
-            //   ) {
-            //     processingResponse();
-            //   } else if (xhr.readyState === 3 && xhr.status === 400) {
-            //     processingResponse();
-            //   } else if (xhr.readyState === 4 && xhr.status === 500) {
-            //     processingResponse();
-            //   } else if (xhr.readyState === 4 && xhr.status === 401) {
-            //     error(xhr.statusText);
-            //   } else if (xhr.readyState === 4) {
-            //     error('request error');
-            //   }
-            // };
-            xhr.onerror = function (er) {
-                if (xhr.status === 0) {
-                    error(new NetworkError(url));
-                }
-                else {
-                    error(er);
-                }
-            };
-            xhr.upload.onprogress = function (e) {
-                if (e.lengthComputable) {
-                    var percentComplete = (e.loaded / e.total) * 100;
-                    if (options.onProgress) {
-                        options.onProgress(percentComplete, e);
-                    }
-                    // console.log(percentComplete + '% uploaded');
-                }
-            };
-            var headers = options.headers;
-            if (headers) {
-                for (var h in headers) {
-                    var header = headers[h];
-                    if (typeof header === 'string') {
-                        xhr.setRequestHeader(h, header);
-                    }
-                }
-            }
-            if (options.withCredentials !== undefined) {
-                xhr.withCredentials = options.withCredentials;
-            }
-            var data;
-            if (options.file) {
-                data = new FormData();
-                data.append('file', options.file);
-                if (options.data) {
-                    for (var 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(function () {
-                    xhr.abort();
-                });
-            }
-            xhr.send(data);
-        };
+        url = encodeURI(fixUrlStr(url));
+        return this._loadData(url, options);
+      } else {
+        throw new Error("Empty `url` not allowed");
+      }
     }
-
-    // https://github.com/Leaflet/Leaflet/blob/b507e21c510b53cd704fb8d3f89bb46ea925c8eb/src/core/Util.js#L165
-    var templateRe = /\{ *([\w_-]+) *\}/g;
-    function template(str, data) {
-        return str.replace(templateRe, function (s, key) {
-            var value = data[key];
-            if (value === undefined) {
-                throw new Error('No value provided for letiable ' + s);
-            }
-            else if (typeof value === 'function') {
-                value = value(data);
-            }
-            return value;
-        });
+    // -------------------------------------------------------------------------
+    // Resource Methods
+    // -------------------------------------------------------------------------
+    /**
+     * {@link ResourcesControl.getOne}
+     */
+    getResource(resource, requestOptions) {
+      return this.resources.getOne(resource, requestOptions);
     }
-
-    function apiRequest(opt) {
-        var params = opt.params;
-        return new CancelablePromise(function (resolve, reject) {
-            opt.connector
-                .connect()
-                .then(function (apiItems) {
-                var apiItem = apiItems && apiItems[opt.name];
-                if (apiItem) {
-                    apiItem = __spreadArray([], apiItem, true);
-                    var url = apiItem.shift();
-                    if (apiItem.length) {
-                        var replaceParams = {};
-                        for (var fry = 0; fry < apiItem.length; fry++) {
-                            var arg = apiItem[fry];
-                            replaceParams[fry] = '{' + arg + '}';
-                            if (params[arg] === undefined) {
-                                throw new Error('`' + arg + '`' + ' url api argument is not specified');
-                            }
-                        }
-                        if (url) {
-                            url = template(url, replaceParams);
-                        }
-                    }
-                    // Transfer part of the parameters from `params` to the URL string
-                    if (params) {
-                        var paramArray_1 = [];
-                        var paramList = params.paramList;
-                        if (Array.isArray(paramList)) {
-                            delete params.paramList;
-                            paramList.forEach(function (x) {
-                                paramArray_1.push("".concat(x[0], "=").concat(x[1]));
-                            });
-                        }
-                        for (var p in params) {
-                            if (apiItem.indexOf(p) === -1) {
-                                paramArray_1.push("".concat(p, "=").concat(params[p]));
-                            }
-                        }
-                        if (paramArray_1.length) {
-                            url = url + '?' + paramArray_1.join('&');
-                        }
-                    }
-                    if (url) {
-                        resolve(opt.connector.makeQuery(url, params, opt.requestOptions));
-                    }
-                    else {
-                        reject(new Error('request url is not set'));
-                    }
-                }
-                else {
-                    resolve(undefined);
-                }
-            })
-                .catch(function (er) {
-                reject(er);
-            });
-        });
+    /**
+     * {@link ResourcesControl.getOneOrFail}
+     */
+    getResourceOrFail(resource, requestOptions) {
+      return this.resources.getOneOrFail(resource, requestOptions);
     }
-
     /**
-     * Thrown when ...
+     * @deprecated - use {@link getResource}
      */
-    var ResourceNotFoundError = /** @class */ (function (_super) {
-        __extends(ResourceNotFoundError, _super);
-        function ResourceNotFoundError(obj) {
-            var _this = _super.call(this, obj) || this;
-            _this.name = 'ResourceNotFoundError';
-            _this.exception = 'nextgisweb.resource.exception.ResourceNotFound';
-            Object.setPrototypeOf(_this, ResourceNotFoundError.prototype);
-            return _this;
-        }
-        return ResourceNotFoundError;
-    }(NgwError));
-
+    getResourceBy(resource) {
+      return this.resources.getOne(resource);
+    }
     /**
-     * Thrown when ...
+     * @deprecated - use {@link getResource}
      */
-    var InsufficientPermissionsError = /** @class */ (function (_super) {
-        __extends(InsufficientPermissionsError, _super);
-        function InsufficientPermissionsError(obj) {
-            var _this = _super.call(this, obj) || this;
-            _this.name = 'InsufficientPermissionsError';
-            _this.exception = 'nextgisweb.core.exception.InsufficientPermissions';
-            Object.setPrototypeOf(_this, InsufficientPermissionsError.prototype);
-            return _this;
-        }
-        return InsufficientPermissionsError;
-    }(NgwError));
-
-    var CONNECTORS = [];
-    function addConnector(connector) {
-        CONNECTORS.push(connector);
-    }
-    function findConnector(options) {
-        return CONNECTORS.find(function (x) {
-            if (x.options.baseUrl === options.baseUrl) {
-                if (options.auth) {
-                    if (x.options.auth) {
-                        return objectDeepEqual(x.options.auth, options.auth);
-                    }
-                }
-                else {
-                    // if auth not in find options; use first connector with same url
-                    return true;
-                }
-            }
-        });
+    getResourceByKeyname(keyname) {
+      return this.resources.getOne(keyname);
     }
-    function removeConnector(connector) {
-        var index = CONNECTORS.indexOf(connector);
-        if (index !== -1) {
-            CONNECTORS.splice(index, 1);
-        }
+    /**
+     * @deprecated - use {@link getResource}
+     */
+    getResourceById(id) {
+      return this.resources.getOne(id);
     }
-
-    var exclude = ['description'];
     /**
-     * @remarks
-     * https://docs.nextgis.ru/docs_ngweb_dev/doc/developer/resource.html#search-resources
-     *
-     * ```
-     * { keyname, owner_user: { id }} > { keyname, owner_user__id }
-     * ```
-     *
-     * @param resource - Any property from NGW resource item
+     * {@link ResourcesControl.getId}
      */
-    function resourceToQuery(resource, prefix) {
-        if (prefix === void 0) { prefix = ''; }
-        prefix = prefix ? prefix + '__' : '';
-        var query = {};
-        for (var _i = 0, _a = Object.entries(resource); _i < _a.length; _i++) {
-            var _b = _a[_i], key = _b[0], value = _b[1];
-            if (exclude.indexOf(key) === -1) {
-                if (isObject(value)) {
-                    if (key === 'owner_user') {
-                        var 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;
+    getResourceId(resource, requestOptions) {
+      return this.resources.getId(resource, requestOptions);
     }
-
-    function resourceCompare(res1, res2) {
-        return objectDeepEqual(res1, res2);
+    /**
+     * {@link ResourcesControl.getIdOrFail}
+     */
+    getResourceIdOrFail(resource, requestOptions) {
+      return this.resources.getIdOrFail(resource, requestOptions);
     }
-
-    var ResourcesControl = /** @class */ (function () {
-        function ResourcesControl(connector) {
-            this.connector = connector;
-            this.cache = new Cache();
-        }
-        // -------------------------------------------------------------------------
-        // 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
-         */
-        ResourcesControl.prototype.getOne = function (resource, requestOptions) {
-            var _this = this;
-            var cache = new Cache();
-            var forCache = {};
-            var opt = __assign(__assign({}, requestOptions), { cache: false });
-            if (typeof resource === 'string') {
-                forCache.keyname = resource;
-            }
-            else if (typeof resource === 'number') {
-                forCache.id = resource;
-            }
-            else if (isObject(resource)) {
-                if (resource.id !== undefined) {
-                    forCache.id = resource.id;
-                }
-                else if (resource.keyname) {
-                    forCache.keyname = resource.keyname;
-                }
-            }
-            var makeRequest = function () {
-                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 CancelablePromise.resolve(undefined);
-            };
-            return cache.addFull('resource', makeRequest, forCache);
-        };
-        ResourcesControl.prototype.getOneOrFail = function (resource, requestOptions) {
-            return this.getOne(resource, requestOptions).then(function (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.
-         */
-        ResourcesControl.prototype.getId = function (resource, requestOptions) {
-            if (typeof resource === 'number') {
-                return CancelablePromise.resolve(resource);
-            }
-            else if (typeof resource === 'string' || isObject(resource)) {
-                return this.getOne(resource, requestOptions).then(function (res) {
-                    if (res) {
-                        return res.resource.id;
-                    }
-                });
-            }
-            return CancelablePromise.resolve(undefined);
-        };
-        /**
-         * 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
-         */
-        ResourcesControl.prototype.getIdOrFail = function (resource, requestOptions) {
-            return this.getId(resource, requestOptions).then(function (resp) {
-                if (resp === undefined) {
-                    throw new Error();
-                }
-                return resp;
-            });
-        };
-        ResourcesControl.prototype.getMany = function (resource, requestOptions) {
-            var _this = this;
-            return this._resourceCacheFilter(resource).then(function (items) {
-                if (!items.length) {
-                    var query = {};
-                    if (resource.keyname) {
-                        query.keyname = resource.keyname;
-                    }
-                    else {
-                        Object.assign(query, resourceToQuery(resource));
-                    }
-                    return _this.connector
-                        .get('resource.search', requestOptions, __assign({ serialization: 'full' }, query))
-                        .then(function (resources) {
-                        if (resources) {
-                            for (var _i = 0, resources_1 = resources; _i < resources_1.length; _i++) {
-                                var x = resources_1[_i];
-                                _this.cache.add('resource.item', CancelablePromise.resolve(x), {
-                                    id: x.resource.id,
-                                });
-                            }
-                        }
-                        return resources;
-                    });
-                }
-                return items;
-            });
-        };
-        ResourcesControl.prototype.getParent = function (resource, requestOptions) {
-            var _this = this;
-            return this.getOne(resource, requestOptions).then(function (child) {
-                if (child) {
-                    return _this.getOne(child.resource.parent.id, requestOptions);
-                }
-                return CancelablePromise.resolve(undefined);
-            });
-        };
-        ResourcesControl.prototype.getChildrenOf = function (resource, requestOptions) {
-            var _this = this;
-            return this.getIdOrFail(resource).then(function (parent) {
-                return _this._getChildrenOf(parent, requestOptions);
-            });
-        };
-        ResourcesControl.prototype.update = function (resource, data) {
-            var _this = this;
-            return this.getId(resource).then(function (id) {
-                if (id !== undefined) {
-                    return _this.connector.put('resource.item', { data: data }, { id: id });
-                }
-            });
-        };
-        /**
-         * Fast way to delete resource from NGW and clean cache.
-         * @param resource - Resource definition
-         */
-        ResourcesControl.prototype.delete = function (resource) {
-            var _this = this;
-            return this.getId(resource).then(function (id) {
-                if (id !== undefined) {
-                    return _this.connector.delete('resource.item', null, { id: id }).then(function () {
-                        _this._cleanResourceItemCache(id);
-                        return undefined;
-                    });
-                }
-            });
-        };
-        ResourcesControl.prototype._getChildrenOf = function (parent, requestOptions, _items) {
-            var _this = this;
-            if (_items === void 0) { _items = []; }
-            return this.connector
-                .get('resource.collection', __assign({ cache: true }, requestOptions), {
-                parent: parent,
-            })
-                .then(function (items) {
-                var recursivePromises = [];
-                for (var _i = 0, items_1 = items; _i < items_1.length; _i++) {
-                    var item = items_1[_i];
-                    _this.cache.add('resource.item', CancelablePromise.resolve(item), {
-                        id: item.resource.id,
-                    });
-                    _items.push(item);
-                    if ((requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.recursive) && item.resource.children) {
-                        recursivePromises.push(_this._getChildrenOf(item.resource.id, requestOptions, _items));
-                    }
-                }
-                if (recursivePromises.length) {
-                    return CancelablePromise.all(recursivePromises).then(function () {
-                        return _items;
-                    });
-                }
-                return _items;
-            });
-        };
-        ResourcesControl.prototype._cleanResourceItemCache = function (id) {
-            return __awaiter(this, void 0, void 0, function () {
-                var all, toDelete, _i, all_1, c, cid, rid, _a, toDelete_1, d;
-                return __generator(this, function (_b) {
-                    switch (_b.label) {
-                        case 0:
-                            all = this.cache.all();
-                            toDelete = [];
-                            _i = 0, all_1 = all;
-                            _b.label = 1;
-                        case 1:
-                            if (!(_i < all_1.length)) return [3 /*break*/, 5];
-                            c = all_1[_i];
-                            cid = c.options && c.options.id;
-                            if (!(['resource.item', 'resource'].includes(c.key) && cid !== undefined)) return [3 /*break*/, 4];
-                            if (!(typeof cid === 'number')) return [3 /*break*/, 2];
-                            if (cid === id) {
-                                toDelete.push(c);
-                            }
-                            return [3 /*break*/, 4];
-                        case 2: return [4 /*yield*/, this.getId(cid)];
-                        case 3:
-                            rid = _b.sent();
-                            if (rid === id) {
-                                toDelete.push(c);
-                            }
-                            _b.label = 4;
-                        case 4:
-                            _i++;
-                            return [3 /*break*/, 1];
-                        case 5:
-                            for (_a = 0, toDelete_1 = toDelete; _a < toDelete_1.length; _a++) {
-                                d = toDelete_1[_a];
-                                this.cache.delete(d);
-                            }
-                            return [2 /*return*/];
-                    }
-                });
-            });
-        };
-        ResourcesControl.prototype._fetchResourceById = function (id, requestOptions) {
-            var _this = this;
-            var promise = function () {
-                return _this.connector.get('resource.item', requestOptions, { id: id });
-            };
-            return this.cache
-                .add('resource.item', promise, {
-                id: id,
-            })
-                .catch(function (er) {
-                if (!(er instanceof ResourceNotFoundError)) {
-                    throw er;
-                }
-                return undefined;
-            });
-        };
-        ResourcesControl.prototype._fetchResourceBy = function (resource, requestOptions) {
-            return this.getMany(resource, requestOptions).then(function (resources) {
-                return resources[0];
-            });
-        };
-        ResourcesControl.prototype._resourceCacheFilter = function (resource) {
-            return CancelablePromise.all(this.cache.matchAll('resource.item')).then(function (resources) {
-                var items = [];
-                resources.filter(function (x) {
-                    if (x) {
-                        // identical by uniq props
-                        if (resource.keyname && x.resource.keyname) {
-                            return resource.keyname === x.resource.keyname;
-                        }
-                        if (defined(resource.id) && defined(x.resource.id)) {
-                            return resource.id === x.resource.id;
-                        }
-                        return resourceCompare(resource, x.resource);
-                    }
-                });
-                return items;
-            });
-        };
-        return ResourcesControl;
-    }());
-
-    var ID = 0;
-    var NgwConnector$1 = /** @class */ (function () {
-        function NgwConnector(options) {
-            this.options = options;
-            this.id = ID++;
-            this.emitter = new events.exports.EventEmitter();
-            this.routeStr = '/api/component/pyramid/route';
-            this.activeRequests = [];
-            var exist = findConnector(options);
-            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(this);
-                addConnector(this);
-            }
-        }
-        NgwConnector.create = function (options) {
-            return new this(options);
-        };
-        NgwConnector.prototype.setRequestTransform = function (requestTransform) {
-            this.requestTransform = requestTransform;
-        };
-        /**
-         * Fast way to specify the connection address to NextGIS Web.
-         * The current connection will be severed.
-         * @param baseUrl - NGW url
-         */
-        NgwConnector.prototype.setNgw = function (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));
-         * ```
-         */
-        NgwConnector.prototype.connect = function () {
-            var _this = this;
-            var cache = new Cache();
-            var auth = this.options.auth;
-            var makeConnect = function () {
-                return new CancelablePromise(function (resolve, reject) {
-                    var makeQuery = function () {
-                        return _this.makeQuery(_this.routeStr, {}, {})
-                            .then(function (route) {
-                            resolve(route);
-                        })
-                            .catch(function (er) {
-                            reject(er);
-                        });
-                    };
-                    if (auth) {
-                        var login = auth.login, password = auth.password;
-                        if (login && password) {
-                            return _this._login({ login: login, password: password })
-                                .then(function () {
-                                return makeQuery();
-                            })
-                                .catch(function (er) { return reject(er); });
-                        }
-                    }
-                    return makeQuery();
-                });
-            };
-            return cache.add('route', makeConnect, {
-                id: this.id,
-                auth: auth,
-                baseUrl: this.options.baseUrl,
-            });
-        };
-        /**
-         * Quick way to change NextGIS Web user.
-         * @param credentials - New user credentials
-         */
-        NgwConnector.prototype.login = function (credentials, options) {
-            this.logout();
-            addConnector(this);
-            return this._login(credentials, options);
-        };
-        /**
-         * Disconnecting a user. Aborting all current requests
-         */
-        NgwConnector.prototype.logout = function () {
-            this.abort();
-            removeConnector(this);
-            this.options.auth = undefined;
-            this.user = undefined;
-            this.emitter.emit('logout');
-            this.resources.cache.clean();
-        };
-        NgwConnector.prototype.getUserInfo = function (credentials, options) {
-            if (this.user && this.user.id) {
-                return CancelablePromise.resolve(this.user);
-            }
-            if (credentials) {
-                this.options.auth = credentials;
-            }
-            var options_ = __assign({ headers: this.getAuthorizationHeaders(credentials) }, options);
-            // Do not use apiRequest('auth.current_user') to avoid circular-references
-            return this.makeQuery('/api/component/auth/current_user', {}, options_);
-        };
-        /**
-         * Obtaining the required Headers for authentication of requests in the NGW.
-         */
-        NgwConnector.prototype.getAuthorizationHeaders = function (credentials) {
-            var client = this.makeClientId(credentials);
-            if (client) {
-                return {
-                    Authorization: 'Basic ' + client,
-                };
-            }
-        };
-        NgwConnector.prototype.makeClientId = function (credentials) {
-            credentials = credentials || this.options.auth;
-            if (credentials) {
-                var login = credentials.login, password = credentials.password;
-                var str = unescape(encodeURIComponent("".concat(login, ":").concat(password)));
-                // @ts-ignore
-                {
-                    return window.btoa(str);
-                }
-            }
-        };
-        /** Stop all api requests */
-        NgwConnector.prototype.abort = function () {
-            for (var _i = 0, _a = this.activeRequests; _i < _a.length; _i++) {
-                var req = _a[_i];
-                req.cancel();
-            }
-            this.activeRequests = [];
-        };
-        NgwConnector.prototype.getActiveApiRequests = function () {
-            return __spreadArray([], this.activeRequests, true);
-        };
-        /**
-         * Send request to NGW api router.
-         * @param name - NGW route name from {@link https://docs.nextgis.com/docs_ngweb_dev/doc/developer/resource.html#routes | routes}
-         * @param params - Request item params or query params
-         * @param requestOptions - Request options
-         *
-         * @example
-         * ```javascript
-         *
-         * // there is such an NGW route item
-         * // "feature_layer.feature.item": [
-         * //   "/api/resource/{0}/feature/{1}",
-         * //   "id",
-         * //   "fid"
-         * // ],
-         *
-         * const connector = new NgwConnector({ baseUrl: 'https://example.nextgis.com' });
-         * connector.apiRequest('feature_layer.feature.item', {
-         *   // request params for {0} and {1}
-         *   'id': 2011,
-         *   'fid': 101,
-         *   // query params
-         *   'srs': 4326,
-         *   'geom_format': 'geojson',
-         * }, { method: 'GET' });
-         * // send get-request to 'https://example.nextgis.com/api/resource/2011/feature/101?srs=4326&geom_format=geojson'
-         *
-         * ```
-         */
-        NgwConnector.prototype.apiRequest = function (name, params_, requestOptions) {
-            var _this = this;
-            var _a, _b;
-            if (params_ === void 0) { params_ = {}; }
-            if (requestOptions === void 0) { requestOptions = {}; }
-            var method = requestOptions.method, headers = requestOptions.headers, withCredentials = requestOptions.withCredentials, responseType = requestOptions.responseType;
-            params_ = (_a = requestOptions.params) !== null && _a !== void 0 ? _a : params_;
-            var params = objectRemoveEmpty(params_);
-            var makeApiRequest = function () {
-                return apiRequest({ name: name, params: params, requestOptions: requestOptions, connector: _this });
-            };
-            if (requestOptions.cache && method === 'GET') {
-                var cache = new Cache();
-                return cache.add(name, makeApiRequest, __assign({ params: params }, objectRemoveEmpty({
-                    headers: headers,
-                    withCredentials: withCredentials,
-                    responseType: responseType,
-                    baseUrl: this.options.baseUrl,
-                    userId: (_b = this.user) === null || _b === void 0 ? void 0 : _b.id,
-                })));
-            }
-            return makeApiRequest();
-        };
-        /**
-         * Shortcut method for send POST request to NGW.
-         * @param name - NGW route name from {@link https://docs.nextgis.com/docs_ngweb_dev/doc/developer/resource.html#routes | routes}
-         * @param options - Request options
-         * @param params - Request item params or query params
-         *
-         * @example
-         * ```javascript
-         * connector.post('resource.collection', { data: POST_PAYLOAD })
-         *   .then((newResource) => console.log(newResource))
-         *   .catch((error) => console.warn(error));
-         * ```
-         */
-        NgwConnector.prototype.post = function (name, options, params) {
-            options = options || {};
-            options.method = 'POST';
-            return this.apiRequest(name, params, options);
-        };
-        /**
-         * Shortcut method for send GET request to NGW.
-         * @param name - NGW route name from {@link https://docs.nextgis.com/docs_ngweb_dev/doc/developer/resource.html#routes | routes}
-         * @param options - Request options
-         * @param params - Request item params or query params
-         */
-        NgwConnector.prototype.get = function (name, options, params) {
-            options = options || {};
-            options.method = 'GET';
-            return this.apiRequest(name, params, options);
-        };
-        /**
-         * Shortcut method for send PATCH request to NGW.
-         * @param name - NGW route name from {@link https://docs.nextgis.com/docs_ngweb_dev/doc/developer/resource.html#routes | routes}
-         * @param options - Request options
-         * @param params - Request item params or query params
-         */
-        NgwConnector.prototype.patch = function (name, options, params) {
-            options = options || {};
-            options.method = 'PATCH';
-            return this.apiRequest(name, params, options);
-        };
-        /**
-         * Shortcut method for send PUT request to NGW.
-         * @param name - NGW route name from {@link https://docs.nextgis.com/docs_ngweb_dev/doc/developer/resource.html#routes | routes}
-         * @param options - Request options
-         * @param params - Request item params or query params
-         */
-        NgwConnector.prototype.put = function (name, options, params) {
-            options = options || {};
-            options.method = 'PUT';
-            return this.apiRequest(name, params, options);
-        };
-        /**
-         * Shortcut method for send DELETE request to NGW.
-         * @param name - NGW route name from {@link https://docs.nextgis.com/docs_ngweb_dev/doc/developer/resource.html#routes | routes}
-         * @param options - Request options
-         * @param params - Request item params or query params
-         */
-        NgwConnector.prototype.delete = function (name, options, params) {
-            options = options || {};
-            options.method = 'DELETE';
-            return this.apiRequest(name, params, options);
-        };
-        /**
-         * Send request to NGW.
-         * @param url - URL address to NGW
-         * @param params - Query params
-         * @param options - Request options
-         */
-        NgwConnector.prototype.makeQuery = function (url, params, options) {
-            if (options === void 0) { options = {}; }
-            url = (this.options.baseUrl ? this.options.baseUrl : '') + url;
-            if (url) {
-                if (params) {
-                    url = template(url, params);
-                }
-                url = encodeURI(fixUrlStr(url));
-                return this._loadData(url, options);
-            }
-            else {
-                throw new Error('Empty `url` not allowed');
-            }
-        };
-        // -------------------------------------------------------------------------
-        // Resource Methods
-        // -------------------------------------------------------------------------
-        /**
-         * {@link ResourcesControl.getOne}
-         */
-        NgwConnector.prototype.getResource = function (resource, requestOptions) {
-            return this.resources.getOne(resource, requestOptions);
-        };
-        /**
-         * {@link ResourcesControl.getOneOrFail}
-         */
-        NgwConnector.prototype.getResourceOrFail = function (resource, requestOptions) {
-            return this.resources.getOneOrFail(resource, requestOptions);
-        };
-        /**
-         * @deprecated - use {@link getResource}
-         */
-        NgwConnector.prototype.getResourceBy = function (resource) {
-            return this.resources.getOne(resource);
-        };
-        /**
-         * @deprecated - use {@link getResource}
-         */
-        NgwConnector.prototype.getResourceByKeyname = function (keyname) {
-            return this.resources.getOne(keyname);
-        };
-        /**
-         * @deprecated - use {@link getResource}
-         */
-        NgwConnector.prototype.getResourceById = function (id) {
-            return this.resources.getOne(id);
-        };
-        /**
-         * {@link ResourcesControl.getId}
-         */
-        NgwConnector.prototype.getResourceId = function (resource, requestOptions) {
-            return this.resources.getId(resource, requestOptions);
-        };
-        /**
-         * {@link ResourcesControl.getIdOrFail}
-         */
-        NgwConnector.prototype.getResourceIdOrFail = function (resource, requestOptions) {
-            return this.resources.getIdOrFail(resource, requestOptions);
-        };
-        /**
-         * {@link ResourcesControl.getMany}
-         */
-        NgwConnector.prototype.getResourcesBy = function (resource, requestOptions) {
-            return this.resources.getMany(resource, requestOptions);
-        };
-        /**
-         * {@link ResourcesControl.getParent}
-         */
-        NgwConnector.prototype.getResourceParent = function (resource, requestOptions) {
-            return this.resources.getParent(resource, requestOptions);
-        };
-        /**
-         * {@link ResourcesControl.getChildrenOf}
-         */
-        NgwConnector.prototype.getResourceChildren = function (resource, requestOptions) {
-            return this.resources.getChildrenOf(resource, requestOptions);
-        };
-        /**
-         * {@link ResourcesControl.update}
-         */
-        NgwConnector.prototype.updateResource = function (resource, data) {
-            return this.resources.update(resource, data);
-        };
-        /**
-         * {@link ResourcesControl.delete}
-         */
-        NgwConnector.prototype.deleteResource = function (resource) {
-            return this.resources.delete(resource);
-        };
-        /**
-         * @internal
-         */
-        NgwConnector.prototype._loadData = function (url, options) {
-            var _this = this;
-            options.responseType = options.responseType || 'json';
-            var request = new CancelablePromise(function (resolve, reject, onCancel) {
-                if (_this.user) {
-                    options = options || {};
-                    // options.withCredentials = true;
-                    options.headers = __assign(__assign({}, _this.getAuthorizationHeaders()), options.headers);
-                }
-                if (_this.requestTransform) {
-                    var _a = _this.requestTransform(url, options), transUrl = _a[0], transOptions = _a[1];
-                    url = transUrl;
-                    options = transOptions;
-                }
-                loadData(url, resolve, options, reject, onCancel);
-            })
-                .then(function (resp) {
-                _this._cleanActiveRequests(request);
-                return resp;
-            })
-                .catch(function (httpError) {
-                _this._cleanActiveRequests(request);
-                if (httpError instanceof CancelablePromise.CancelError) ;
-                else {
-                    // @ts-ignore
-                    {
-                        console.warn('DEV WARN', httpError);
-                    }
-                    var er = _this._handleHttpError(httpError);
-                    if (er) {
-                        throw er;
-                    }
-                }
-            });
-            if (options.signal &&
-                typeof options.signal.addEventListener === 'function') {
-                options.signal.addEventListener('abort', function () {
-                    request.cancel();
-                    _this._cleanActiveRequests(request);
-                });
-            }
-            this.activeRequests.push(request);
-            return request;
-        };
-        NgwConnector.prototype._login = function (credentials, options) {
-            var _this = this;
-            return this.getUserInfo(credentials, options)
-                .then(function (data) {
-                _this.user = data;
-                _this.emitter.emit('login', data);
-                return data;
-            })
-                .catch(function (er) {
-                _this.emitter.emit('login:error', er);
-                throw er;
-            });
-        };
-        NgwConnector.prototype._cleanActiveRequests = function (request) {
-            var activeRequestIndex = this.activeRequests.indexOf(request);
-            if (activeRequestIndex !== -1) {
-                this.activeRequests.splice(activeRequestIndex, 1);
-            }
-        };
-        NgwConnector.prototype._handleHttpError = function (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;
-        };
-        NgwConnector.errors = {
-            NgwError: NgwError,
-            ResourceNotFoundError: ResourceNotFoundError,
-        };
-        return NgwConnector;
-    }());
-
     /**
-     * A lightweight HTTP client optimized for use with {@link http://docs.nextgis.ru/docs_ngweb_dev/doc/developer/toc.html | NextGIS Web} API
-     *
-     * @remarks
-     * Make sure CORS is registered in the {@link https://docs.nextgis.com/docs_ngcom/source/CORS.html | NextGIS Web settings } to be able to send requests.
-     *
-     * @packageDocumentation
-     * @module ngw-connector
+     * {@link ResourcesControl.getMany}
      */
-    var NgwConnector = NgwConnector$1;
+    getResourcesBy(resource, requestOptions) {
+      return this.resources.getMany(resource, requestOptions);
+    }
+    /**
+     * {@link ResourcesControl.getParent}
+     */
+    getResourceParent(resource, requestOptions) {
+      return this.resources.getParent(resource, requestOptions);
+    }
+    /**
+     * {@link ResourcesControl.getChildrenOf}
+     */
+    getResourceChildren(resource, requestOptions) {
+      return this.resources.getChildrenOf(resource, requestOptions);
+    }
+    /**
+     * {@link ResourcesControl.update}
+     */
+    updateResource(resource, data) {
+      return this.resources.update(resource, data);
+    }
+    /**
+     * {@link ResourcesControl.delete}
+     */
+    deleteResource(resource) {
+      return this.resources.delete(resource);
+    }
+    /**
+     * @internal
+     */
+    _loadData(url, options) {
+      options.responseType = options.responseType || "json";
+      if (options.signal && options.signal.aborted) {
+        return CancelablePromise.reject(new CancelablePromise.CancelError());
+      }
+      const request = new CancelablePromise((resolve, reject, onCancel) => {
+        if (this.user) {
+          options = options || {};
+          options.headers = __spreadValues(__spreadValues({}, this.getAuthorizationHeaders()), options.headers);
+        }
+        if (this.requestTransform) {
+          const [transUrl, transOptions] = this.requestTransform(url, options);
+          url = transUrl;
+          options = transOptions;
+        }
+        loadData(url, resolve, options, reject, onCancel);
+      }).then((resp) => {
+        this._cleanActiveRequests(request);
+        return resp;
+      }).catch((httpError) => {
+        this._cleanActiveRequests(request);
+        if (httpError instanceof CancelablePromise.CancelError) ; else {
+          {
+            console.warn("DEV WARN", httpError);
+          }
+          const er = this._handleHttpError(httpError);
+          if (er) {
+            throw er;
+          }
+        }
+      });
+      if (options.signal && typeof options.signal.addEventListener === "function") {
+        options.signal.addEventListener("abort", () => {
+          request.cancel();
+          this._cleanActiveRequests(request);
+        });
+      }
+      this.activeRequests.push(request);
+      return request;
+    }
+    _login(credentials, options) {
+      return this.getUserInfo(credentials, options).then((data) => {
+        this.user = data;
+        this.emitter.emit("login", data);
+        return data;
+      }).catch((er) => {
+        this.emitter.emit("login:error", er);
+        throw er;
+      });
+    }
+    _cleanActiveRequests(request) {
+      const activeRequestIndex = this.activeRequests.indexOf(request);
+      if (activeRequestIndex !== -1) {
+        this.activeRequests.splice(activeRequestIndex, 1);
+      }
+    }
+    _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(NgwConnector, "errors", {
+    NgwError,
+    ResourceNotFoundError
+  });
 
-    return NgwConnector;
+  return NgwConnector;
 
 })();
 //# sourceMappingURL=ngw-connector.global.js.map