@nextgis/ngw-connector 1.11.3 → 1.12.0

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

@@ -1,4 +1,94 @@
-/** Bundle of @nextgis/ngw-connector; version: 1.11.3; author: NextGIS */
+/** Bundle of @nextgis/ngw-connector; version: 1.12.0; author: NextGIS */
+/*! *****************************************************************************
+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 */
+
+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 (_) 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));
+}
+
 var events = {exports: {}};
 
 var R = typeof Reflect === 'object' ? Reflect : null;
@@ -475,34 +565,43 @@ function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
   }
 }
 
-class CancelError extends Error {
-    constructor() {
-        super();
-        this.name = 'CancelError';
-        Object.setPrototypeOf(this, CancelError.prototype);
+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));
 
-class PromiseControl {
-    constructor(options = {}) {
+var PromiseControl = /** @class */ (function () {
+    function PromiseControl(options) {
+        if (options === void 0) { options = {}; }
         this.options = options;
         this._promises = new Map();
     }
-    get isLoaded() {
-        return this._promises.size > 0;
-    }
-    remove(promise) {
+    Object.defineProperty(PromiseControl.prototype, "isLoaded", {
+        get: function () {
+            return this._promises.size > 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    PromiseControl.prototype.remove = function (promise) {
         if (this._promises.has(promise)) {
             this._promises.delete(promise);
             this._onStop();
         }
-    }
-    get(promise) {
+    };
+    PromiseControl.prototype.get = function (promise) {
         return this._promises.get(promise);
-    }
-    add(promise, name) {
-        const key = name ? name : promise;
-        const exist = this._promises.get(key);
+    };
+    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();
         }
@@ -510,14 +609,14 @@ class PromiseControl {
             return exist;
         }
         this._promises.set(key, promise);
-        promise.finally(() => {
-            this.remove(key);
+        promise.finally(function () {
+            _this.remove(key);
         });
         return promise;
-    }
-    abort() {
+    };
+    PromiseControl.prototype.abort = function () {
         if (this.isLoaded) {
-            this._promises.forEach((x) => {
+            this._promises.forEach(function (x) {
                 if (x.cancel) {
                     x.cancel();
                 }
@@ -525,52 +624,63 @@ class PromiseControl {
             this._promises.clear();
             this._onStop();
         }
-    }
-    waitFunc(func, name = '') {
+    };
+    PromiseControl.prototype.waitFunc = function (func, name) {
+        if (name === void 0) { name = ''; }
         name = name || func.name;
-        const exist = this.get(name);
+        var 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);
+    };
+    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) {
-            const originalMethod = descriptor.value;
+            var originalMethod = descriptor.value;
             name = name || key;
-            descriptor.value = function (...args) {
-                const exist = get(name);
+            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;
                 }
-                const result = add(originalMethod.apply(this, args), name);
+                var result = add(originalMethod.apply(this, args), name);
                 return result;
             };
             return descriptor;
         };
-    }
+    };
     /** @deprecated use {@link PromiseControl.WaitForMe } instead */
-    GetOrCreateDecorator(name = '') {
+    PromiseControl.prototype.GetOrCreateDecorator = function (name) {
+        if (name === void 0) { name = ''; }
         return this.WaitForMe(name);
-    }
-    _onStop() {
+    };
+    PromiseControl.prototype._onStop = function () {
         if (this.options.onStop && !this.isLoaded) {
             this.options.onStop();
         }
-    }
-}
+    };
+    return PromiseControl;
+}());
 
-class TimeoutError extends Error {
-    constructor() {
-        super();
-        this.name = 'TimeoutError';
-        Object.setPrototypeOf(this, TimeoutError.prototype);
+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;
     }
-}
+    return TimeoutError;
+}(Error));
 
-const handleCallback = (resolve, reject, callback, r) => {
+var handleCallback = function (resolve, reject, callback, r) {
     try {
         resolve(callback(r));
     }
@@ -578,7 +688,7 @@ const handleCallback = (resolve, reject, callback, r) => {
         reject(e);
     }
 };
-let ID$1 = 0;
+var ID$1 = 0;
 /**
  * Promise that can be canceled
  *
@@ -623,48 +733,49 @@ let ID$1 = 0;
  * promise.cancel();
  * ```
  */
-class CancelablePromise$1 {
-    constructor(executor, timeout) {
+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((resolve_, reject_) => {
-            this._setCanceledCallback = (er) => resolve_(er || new CancelError());
+        this._cancelPromise = new Promise(function (resolve_, reject_) {
+            _this._setCanceledCallback = function (er) { return resolve_(er || new CancelError()); };
         });
-        const promises = [
+        var promises = [
             this._cancelPromise,
-            new Promise((resolve, reject) => {
-                const onResolve = (value) => {
-                    if (value instanceof CancelablePromise$1) {
-                        this.attach(value);
+            new Promise(function (resolve, reject) {
+                var onResolve = function (value) {
+                    if (value instanceof CancelablePromise) {
+                        _this.attach(value);
                     }
                     else {
-                        this._isPending = false;
+                        _this._isPending = false;
                     }
                     // TODO: fix types, `undefined` not allowed since 19.12.2020
                     resolve(value);
                 };
-                const onReject = (error) => {
-                    this._isPending = false;
+                var onReject = function (error) {
+                    _this._isPending = false;
                     reject(error);
                 };
-                const onCancel = (handler) => {
-                    if (!this._isPending) {
+                var onCancel = function (handler) {
+                    if (!_this._isPending) {
                         throw new Error('The `onCancel` handler was attached after the promise settled.');
                     }
-                    this._cancelHandlers.push(handler);
+                    _this._cancelHandlers.push(handler);
                 };
                 return executor(onResolve, onReject, onCancel);
             }),
         ];
         if (timeout) {
-            promises.push(new Promise((resolve, reject) => {
-                setTimeout(() => {
-                    if (this._isPending) {
+            promises.push(new Promise(function (resolve, reject) {
+                setTimeout(function () {
+                    if (_this._isPending) {
                         try {
-                            this.cancel();
+                            _this.cancel();
                         }
                         finally {
                             reject(new TimeoutError());
@@ -675,21 +786,23 @@ class CancelablePromise$1 {
         }
         this._promise = Promise.race(promises);
     }
-    static createControl(opt) {
+    CancelablePromise.createControl = function (opt) {
         return new PromiseControl(opt);
-    }
-    static resolve(value) {
-        return new CancelablePromise$1((resolve) => resolve(value));
-    }
-    static reject(value) {
-        return new CancelablePromise$1((resolve, reject) => reject(value));
-    }
-    static all(values) {
-        return new CancelablePromise$1((resolve, reject) => {
+    };
+    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((er) => {
-            if (er instanceof this.CancelError) {
-                for (const v of values) {
+        }).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];
                     if ('cancel' in v) {
                         v.cancel();
                     }
@@ -697,19 +810,20 @@ class CancelablePromise$1 {
             }
             throw er;
         });
-    }
-    attach(p) {
+    };
+    CancelablePromise.prototype.attach = function (p) {
         if (this._isCanceled) {
             p.cancel();
         }
         else {
             this._children.push(p);
         }
-    }
-    then(onfulfilled, onrejected) {
-        const p = new CancelablePromise$1((resolve, reject) => {
-            if (this._promise) {
-                const reject_ = (r) => {
+    };
+    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);
                     }
@@ -717,9 +831,9 @@ class CancelablePromise$1 {
                         reject(r);
                     }
                 };
-                this._promise.then((r) => {
-                    if (this._isCanceled) {
-                        reject_(r);
+                _this._promise.then(function (r) {
+                    if (_this._isCanceled) {
+                        reject_1(r);
                     }
                     else {
                         if (onfulfilled) {
@@ -729,20 +843,20 @@ class CancelablePromise$1 {
                             resolve(r);
                         }
                     }
-                }, reject_);
+                }, reject_1);
             }
         });
         p._parentPromise = this;
         this._children.push(p);
         return p;
-    }
-    catch(onrejected) {
+    };
+    CancelablePromise.prototype.catch = function (onrejected) {
         if (this._isCanceled && onrejected) {
             onrejected(new CancelError());
         }
         return this.then(undefined, onrejected);
-    }
-    finally(onfinally) {
+    };
+    CancelablePromise.prototype.finally = function (onfinally) {
         if (this._promise) {
             return this._promise.finally(onfinally);
         }
@@ -750,24 +864,25 @@ class CancelablePromise$1 {
             return Promise.reject(new CancelError());
         }
         return Promise.reject(onfinally);
-    }
-    cancel() {
+    };
+    CancelablePromise.prototype.cancel = function () {
         // No reason to run cancel action if promise is already complete
         if (this._isCanceled || !this._isPending) {
             return this;
         }
         this._isCanceled = true;
-        const parent = this._getTopParent();
+        var parent = this._getTopParent();
         if (parent) {
             parent.cancel();
         }
         if (this._children) {
-            this._children.forEach((x) => x.cancel());
+            this._children.forEach(function (x) { return x.cancel(); });
         }
         if (this._isPending) {
             if (this._cancelHandlers.length) {
                 try {
-                    for (const handler of this._cancelHandlers) {
+                    for (var _i = 0, _a = this._cancelHandlers; _i < _a.length; _i++) {
+                        var handler = _a[_i];
                         handler();
                     }
                 }
@@ -781,10 +896,10 @@ class CancelablePromise$1 {
         }
         this._destroy();
         return this;
-    }
-    _getTopParent() {
-        let parent = this._parentPromise;
-        let hasParent = !!parent;
+    };
+    CancelablePromise.prototype._getTopParent = function () {
+        var parent = this._parentPromise;
+        var hasParent = !!parent;
         while (hasParent) {
             if (parent && parent._parentPromise) {
                 parent = parent._parentPromise;
@@ -795,16 +910,17 @@ class CancelablePromise$1 {
             }
         }
         return parent;
-    }
-    _destroy() {
+    };
+    CancelablePromise.prototype._destroy = function () {
         this._setCanceledCallback = undefined;
         this._cancelPromise = undefined;
         this._promise = undefined;
-    }
-}
-CancelablePromise$1.CancelError = CancelError;
-CancelablePromise$1.TimeoutError = TimeoutError;
-CancelablePromise$1.PromiseControl = PromiseControl;
+    };
+    CancelablePromise.CancelError = CancelError;
+    CancelablePromise.TimeoutError = TimeoutError;
+    CancelablePromise.PromiseControl = PromiseControl;
+    return CancelablePromise;
+}());
 Object.setPrototypeOf(CancelablePromise$1.prototype, Promise.prototype);
 
 /**
@@ -883,15 +999,15 @@ function isEqual(a, b, o, p) {
 }
 // based on https://stackoverflow.com/a/13143059
 function objectDeepEqual(o, p) {
-    const keysO = Object.keys(o).sort();
-    const keysP = Object.keys(p).sort();
+    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 (let i = 0; i < keysO.length; i++) {
-        const oVal = o[keysO[i]];
-        const pVal = p[keysP[i]];
+    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;
         }
@@ -900,8 +1016,8 @@ function objectDeepEqual(o, p) {
 }
 
 function objectRemoveEmpty(obj) {
-    const newObj = {};
-    Object.keys(obj).forEach((key) => {
+    var newObj = {};
+    Object.keys(obj).forEach(function (key) {
         if (!(obj[key] instanceof Array) && obj[key] === Object(obj[key])) {
             newObj[key] = objectRemoveEmpty(obj[key]);
         }
@@ -947,23 +1063,24 @@ function fixUrlStr(url) {
  * console.log(COUNTER); // 1
  * ```
  */
-class Cache$1 {
-    constructor(options = {}) {
+var Cache$1 = /** @class */ (function () {
+    function Cache(options) {
+        if (options === void 0) { options = {}; }
         var _a;
         this.cache = [];
-        const namespace = (_a = options.namespace) !== null && _a !== void 0 ? _a : 'default';
-        if (Cache$1.instance[namespace]) {
-            return Cache$1.instance[namespace];
+        var namespace = (_a = options.namespace) !== null && _a !== void 0 ? _a : 'default';
+        if (Cache.instance[namespace]) {
+            return Cache.instance[namespace];
         }
-        Cache$1.instance[namespace] = this;
+        Cache.instance[namespace] = this;
         return this;
     }
-    clean() {
+    Cache.prototype.clean = function () {
         this.cache.length = 0;
-    }
-    all() {
+    };
+    Cache.prototype.all = function () {
         return this.cache;
-    }
+    };
     /**
      * Caching only a non-empty value.
      *
@@ -986,23 +1103,24 @@ class Cache$1 {
      *
      * ```
      */
-    addFull(key, valueToSet, props) {
+    Cache.prototype.addFull = function (key, valueToSet, props) {
         return this.add(key, valueToSet, props, true);
-    }
-    add(key, valueToSet, props, onlyFull) {
-        const exist = this._find(key, props);
+    };
+    Cache.prototype.add = function (key, valueToSet, props, onlyFull) {
+        var _this = this;
+        var exist = this._find(key, props);
         if (!exist) {
-            let value;
+            var value = void 0;
             if (valueToSet instanceof Function) {
                 value = valueToSet();
             }
             else {
                 value = valueToSet;
             }
-            const props_ = props && JSON.parse(JSON.stringify(objectRemoveEmpty(props)));
-            const cacheItem = {
-                key,
-                value,
+            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_,
@@ -1012,14 +1130,14 @@ class Cache$1 {
             }
             this.cache.push(cacheItem);
             if (value instanceof Promise) {
-                value.catch((er) => {
-                    this.delete(key, props);
+                value.catch(function (er) {
+                    _this.delete(key, props);
                     throw er;
                 });
                 if (onlyFull) {
-                    value.then((x) => {
+                    value.then(function (x) {
                         if (!full(x)) {
-                            this.delete(key, props);
+                            _this.delete(key, props);
                         }
                         return x;
                     });
@@ -1031,50 +1149,55 @@ class Cache$1 {
         else {
             return exist.value;
         }
-    }
-    match(key, props) {
-        const cacheRecord = this._find(key, props);
+    };
+    Cache.prototype.match = function (key, props) {
+        var cacheRecord = this._find(key, props);
         if (cacheRecord) {
             return cacheRecord.value;
         }
-    }
-    matchAll(key, props) {
+    };
+    Cache.prototype.matchAll = function (key, props) {
+        var _this = this;
         if (key) {
             return this.cache
-                .filter((x) => this._filter(x, key, props))
-                .map((x) => x.value);
+                .filter(function (x) { return _this._filter(x, key, props); })
+                .map(function (x) { return x.value; });
         }
-        return this.cache.map((x) => x.value);
-    }
-    delete(keyOrItem, props) {
-        let exist = [];
+        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((x) => this._filter(x, keyOrItem, props));
+            exist = this.cache.filter(function (x) { return _this._filter(x, keyOrItem, props); });
         }
         else {
             exist.push(keyOrItem);
         }
-        for (const e of exist) {
-            const index = this.cache.indexOf(e);
+        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);
         }
-    }
-    _find(key, props) {
-        return this.cache.find((x) => this._filter(x, key, props));
-    }
-    _filter(item, key, props) {
+    };
+    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
-                const itemProps = item.props || item.options;
+                var itemProps = item.props || item.options;
                 return objectDeepEqual(itemProps || {}, objectRemoveEmpty(props));
             }
             return true;
         }
         return false;
-    }
-}
-Cache$1.instance = {};
+    };
+    Cache.instance = {};
+    return Cache;
+}());
 
 /**
  * Caching for asynchronous functions
@@ -1087,43 +1210,49 @@ var Cache = Cache$1;
 /**
  * Thrown when...
  */
-class NgwError extends Error {
-    constructor(er) {
-        super();
-        this.name = 'NgwError';
-        Object.assign(this, er);
-        Object.setPrototypeOf(this, NgwError.prototype);
-    }
-}
+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;
+    }
+    return NgwError;
+}(Error));
 
 /**
  * Thrown when...
  */
-class NetworkError extends Error {
-    constructor(url) {
-        super();
-        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}`; // /control-panel/cors
-    }
-}
+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));
 
 function isObject(val) {
     return Object.prototype.toString.call(val) === '[object Object]';
 }
 
-let loadData;
+var loadData;
 // @ts-ignore
 {
-    loadData = (url, callback, options = {}, error, onCancel) => {
+    loadData = function (url, callback, options, error, onCancel) {
+        if (options === void 0) { options = {}; }
         options.method = options.method || 'GET';
-        const xhr = new XMLHttpRequest();
+        var xhr = new XMLHttpRequest();
         xhr.open(options.method || 'GET', url, true); // true for asynchronous
         if (options.responseType === 'blob') {
             xhr.responseType = options.responseType;
         }
-        const getResponseText = () => {
+        var getResponseText = function () {
             try {
                 return JSON.parse(xhr.responseText);
             }
@@ -1131,8 +1260,9 @@ let loadData;
                 return xhr.responseText;
             }
         };
-        const processingResponse = (forError = false) => {
-            const cb = forError ? error : callback;
+        var processingResponse = function (forError) {
+            if (forError === void 0) { forError = false; }
+            var cb = forError ? error : callback;
             if (options.responseType === 'blob') {
                 cb(xhr.response);
             }
@@ -1145,7 +1275,7 @@ let loadData;
                 }
             }
         };
-        xhr.onload = () => {
+        xhr.onload = function () {
             if ([401, 403, 404, 422, 500].indexOf(xhr.status) !== -1) {
                 error(new NgwError(getResponseText()));
             }
@@ -1167,7 +1297,7 @@ let loadData;
         //     error('request error');
         //   }
         // };
-        xhr.onerror = (er) => {
+        xhr.onerror = function (er) {
             if (xhr.status === 0) {
                 error(new NetworkError(url));
             }
@@ -1177,17 +1307,17 @@ let loadData;
         };
         xhr.upload.onprogress = function (e) {
             if (e.lengthComputable) {
-                const percentComplete = (e.loaded / e.total) * 100;
+                var percentComplete = (e.loaded / e.total) * 100;
                 if (options.onProgress) {
                     options.onProgress(percentComplete, e);
                 }
                 // console.log(percentComplete + '% uploaded');
             }
         };
-        const headers = options.headers;
+        var headers = options.headers;
         if (headers) {
-            for (const h in headers) {
-                const header = headers[h];
+            for (var h in headers) {
+                var header = headers[h];
                 if (typeof header === 'string') {
                     xhr.setRequestHeader(h, header);
                 }
@@ -1196,12 +1326,12 @@ let loadData;
         if (options.withCredentials !== undefined) {
             xhr.withCredentials = options.withCredentials;
         }
-        let data;
+        var data;
         if (options.file) {
             data = new FormData();
             data.append('file', options.file);
             if (options.data) {
-                for (const d in options.data) {
+                for (var d in options.data) {
                     data.append(d, data[d]);
                 }
             }
@@ -1214,7 +1344,7 @@ let loadData;
                 : null;
         }
         if (onCancel) {
-            onCancel(() => {
+            onCancel(function () {
                 xhr.abort();
             });
         }
@@ -1223,10 +1353,10 @@ let loadData;
 }
 
 // https://github.com/Leaflet/Leaflet/blob/b507e21c510b53cd704fb8d3f89bb46ea925c8eb/src/core/Util.js#L165
-const templateRe = /\{ *([\w_-]+) *\}/g;
+var templateRe = /\{ *([\w_-]+) *\}/g;
 function template(str, data) {
-    return str.replace(templateRe, (s, key) => {
-        let value = data[key];
+    return str.replace(templateRe, function (s, key) {
+        var value = data[key];
         if (value === undefined) {
             throw new Error('No value provided for letiable ' + s);
         }
@@ -1240,33 +1370,39 @@ function template(str, data) {
 /**
  * Thrown when ...
  */
-class ResourceNotFoundError extends NgwError {
-    constructor(obj) {
-        super(obj);
-        this.name = 'ResourceNotFoundError';
-        this.exception = 'nextgisweb.resource.exception.ResourceNotFound';
-        Object.setPrototypeOf(this, ResourceNotFoundError.prototype);
-    }
-}
+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));
 
 /**
  * Thrown when ...
  */
-class InsufficientPermissionsError extends NgwError {
-    constructor(obj) {
-        super(obj);
-        this.name = 'InsufficientPermissionsError';
-        this.exception = 'nextgisweb.core.exception.InsufficientPermissions';
-        Object.setPrototypeOf(this, InsufficientPermissionsError.prototype);
-    }
-}
-
-const CONNECTORS = [];
+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((x) => {
+    return CONNECTORS.find(function (x) {
         if (x.options.baseUrl === options.baseUrl) {
             if (options.auth) {
                 if (x.options.auth) {
@@ -1281,13 +1417,13 @@ function findConnector(options) {
     });
 }
 function removeConnector(connector) {
-    const index = CONNECTORS.indexOf(connector);
+    var index = CONNECTORS.indexOf(connector);
     if (index !== -1) {
         CONNECTORS.splice(index, 1);
     }
 }
 
-const exclude = ['description'];
+var exclude = ['description'];
 /**
  * @remarks
  * https://docs.nextgis.ru/docs_ngweb_dev/doc/developer/resource.html#search-resources
@@ -1298,14 +1434,16 @@ const exclude = ['description'];
  *
  * @param resource - Any property from NGW resource item
  */
-function resourceToQuery(resource, prefix = '') {
+function resourceToQuery(resource, prefix) {
+    if (prefix === void 0) { prefix = ''; }
     prefix = prefix ? prefix + '__' : '';
-    const query = {};
-    for (const [key, value] of Object.entries(resource)) {
+    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') {
-                    const children = resourceToQuery(value, key);
+                    var children = resourceToQuery(value, key);
                     Object.assign(query, children);
                 }
                 else if (key === 'parent' && 'id' in value) {
@@ -1324,8 +1462,8 @@ function resourceCompare(res1, res2) {
     return objectDeepEqual(res1, res2);
 }
 
-class ResourcesControl {
-    constructor(connector) {
+var ResourcesControl = /** @class */ (function () {
+    function ResourcesControl(connector) {
         this.connector = connector;
         this.cache = new Cache();
     }
@@ -1339,10 +1477,11 @@ class ResourcesControl {
      * @remarks
      * Fetching resource would be cached to speed up next call
      */
-    getOne(resource, requestOptions) {
-        const cache = new Cache();
-        const forCache = {};
-        const opt = { ...requestOptions, cache: false };
+    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;
         }
@@ -1352,28 +1491,28 @@ class ResourcesControl {
         else if (isObject(resource)) {
             forCache.id = resource.id;
         }
-        const makeRequest = () => {
+        var makeRequest = function () {
             if (typeof resource === 'string') {
-                return this._fetchResourceBy({ keyname: resource }, opt);
+                return _this._fetchResourceBy({ keyname: resource }, opt);
             }
             else if (typeof resource === 'number') {
-                return this._fetchResourceById(resource, opt);
+                return _this._fetchResourceById(resource, opt);
             }
             else if (isObject(resource)) {
-                return this._fetchResourceBy(resource, opt);
+                return _this._fetchResourceBy(resource, opt);
             }
             return CancelablePromise.resolve(undefined);
         };
         return cache.addFull('resource', makeRequest, forCache);
-    }
-    getOneOrFail(resource, requestOptions) {
-        return this.getOne(resource, requestOptions).then((res) => {
+    };
+    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
@@ -1384,19 +1523,19 @@ class ResourcesControl {
      * 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) {
+    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((res) => {
+            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
@@ -1405,33 +1544,32 @@ class ResourcesControl {
      * Similar with {@link NgwConnector.getResourceId | getResourceId} but rise error if resource is not exist.
      * To not make one more checks if the resource is definitely exists
      */
-    getIdOrFail(resource, requestOptions) {
-        return this.getId(resource, requestOptions).then((resp) => {
+    ResourcesControl.prototype.getIdOrFail = function (resource, requestOptions) {
+        return this.getId(resource, requestOptions).then(function (resp) {
             if (resp === undefined) {
                 throw new Error();
             }
             return resp;
         });
-    }
-    getMany(resource, requestOptions) {
-        return this._resourceCacheFilter(resource).then((items) => {
+    };
+    ResourcesControl.prototype.getMany = function (resource, requestOptions) {
+        var _this = this;
+        return this._resourceCacheFilter(resource).then(function (items) {
             if (!items.length) {
-                const query = {};
+                var query = {};
                 if (resource.keyname) {
                     query.keyname = resource.keyname;
                 }
                 else {
                     Object.assign(query, resourceToQuery(resource));
                 }
-                return this.connector
-                    .get('resource.search', requestOptions, {
-                    serialization: 'full',
-                    ...query,
-                })
-                    .then((resources) => {
+                return _this.connector
+                    .get('resource.search', requestOptions, __assign({ serialization: 'full' }, query))
+                    .then(function (resources) {
                     if (resources) {
-                        for (const x of resources) {
-                            this.cache.add('resource.item', CancelablePromise.resolve(x), {
+                        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,
                             });
                         }
@@ -1441,97 +1579,122 @@ class ResourcesControl {
             }
             return items;
         });
-    }
-    getParent(resource, requestOptions) {
-        return this.getOne(resource, requestOptions).then((child) => {
+    };
+    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 _this.getOne(child.resource.parent.id, requestOptions);
             }
             return CancelablePromise.resolve(undefined);
         });
-    }
-    getChildrenOf(resource, requestOptions) {
-        return this.getId(resource).then((parent) => {
-            return this.connector
-                .get('resource.collection', { cache: true, ...requestOptions }, {
-                parent,
+    };
+    ResourcesControl.prototype.getChildrenOf = function (resource, requestOptions) {
+        var _this = this;
+        return this.getId(resource).then(function (parent) {
+            return _this.connector
+                .get('resource.collection', __assign({ cache: true }, requestOptions), {
+                parent: parent,
             })
-                .then((items) => {
-                for (const i of items) {
-                    this.cache.add('resource.item', CancelablePromise.resolve(i), {
+                .then(function (items) {
+                for (var _i = 0, items_1 = items; _i < items_1.length; _i++) {
+                    var i = items_1[_i];
+                    _this.cache.add('resource.item', CancelablePromise.resolve(i), {
                         id: i.resource.id,
                     });
                 }
                 return items;
             });
         });
-    }
-    update(resource, data) {
-        return this.getId(resource).then((id) => {
+    };
+    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 }, { id });
+                return _this.connector.put('resource.item', { data: data }, { id: id });
             }
         });
-    }
+    };
     /**
      * Fast way to delete resource from NGW and clean cache.
      * @param resource - Resource definition
      */
-    delete(resource) {
-        return this.getId(resource).then((id) => {
+    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 }).then(() => {
-                    this._cleanResourceItemCache(id);
+                return _this.connector.delete('resource.item', null, { id: id }).then(function () {
+                    _this._cleanResourceItemCache(id);
                     return undefined;
                 });
             }
         });
-    }
-    async _cleanResourceItemCache(id) {
-        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 !== undefined) {
-                if (typeof cid === 'number') {
-                    if (cid === id) {
-                        toDelete.push(c);
-                    }
-                }
-                else {
-                    const rid = await this.getId(cid);
-                    if (rid === id) {
-                        toDelete.push(c);
-                    }
+    };
+    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*/];
                 }
-            }
-        }
-        for (const d of toDelete) {
-            this.cache.delete(d);
-        }
-    }
-    _fetchResourceById(id, requestOptions) {
-        const promise = () => this.connector.get('resource.item', requestOptions, { id });
+            });
+        });
+    };
+    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: id,
         })
-            .catch((er) => {
+            .catch(function (er) {
             if (!(er instanceof ResourceNotFoundError)) {
                 throw er;
             }
             return undefined;
         });
-    }
-    _fetchResourceBy(resource, requestOptions) {
-        return this.getMany(resource, requestOptions).then((resources) => {
+    };
+    ResourcesControl.prototype._fetchResourceBy = function (resource, requestOptions) {
+        return this.getMany(resource, requestOptions).then(function (resources) {
             return resources[0];
         });
-    }
-    _resourceCacheFilter(resource) {
-        return CancelablePromise.all(this.cache.matchAll('resource.item')).then((resources) => {
-            const items = [];
-            resources.filter((x) => {
+    };
+    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) {
@@ -1545,23 +1708,24 @@ class ResourcesControl {
             });
             return items;
         });
-    }
-}
+    };
+    return ResourcesControl;
+}());
 
 function apiRequest(opt) {
-    const params = opt.params;
-    return new CancelablePromise((resolve, reject) => {
+    var params = opt.params;
+    return new CancelablePromise(function (resolve, reject) {
         opt.connector
             .connect()
-            .then((apiItems) => {
-            let apiItem = apiItems && apiItems[opt.name];
+            .then(function (apiItems) {
+            var apiItem = apiItems && apiItems[opt.name];
             if (apiItem) {
-                apiItem = [...apiItem];
-                let url = apiItem.shift();
+                apiItem = __spreadArray([], apiItem, true);
+                var url = apiItem.shift();
                 if (apiItem.length) {
-                    const replaceParams = {};
-                    for (let fry = 0; fry < apiItem.length; fry++) {
-                        const arg = apiItem[fry];
+                    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');
@@ -1573,21 +1737,21 @@ function apiRequest(opt) {
                 }
                 // Transfer part of the parameters from `params` to the URL string
                 if (params) {
-                    const paramArray = [];
-                    const paramList = params.paramList;
+                    var paramArray_1 = [];
+                    var paramList = params.paramList;
                     if (Array.isArray(paramList)) {
                         delete params.paramList;
-                        paramList.forEach((x) => {
-                            paramArray.push(`${x[0]}=${x[1]}`);
+                        paramList.forEach(function (x) {
+                            paramArray_1.push("".concat(x[0], "=").concat(x[1]));
                         });
                     }
-                    for (const p in params) {
+                    for (var p in params) {
                         if (apiItem.indexOf(p) === -1) {
-                            paramArray.push(`${p}=${params[p]}`);
+                            paramArray_1.push("".concat(p, "=").concat(params[p]));
                         }
                     }
-                    if (paramArray.length) {
-                        url = url + '?' + paramArray.join('&');
+                    if (paramArray_1.length) {
+                        url = url + '?' + paramArray_1.join('&');
                     }
                 }
                 if (url) {
@@ -1601,20 +1765,20 @@ function apiRequest(opt) {
                 resolve(undefined);
             }
         })
-            .catch((er) => {
+            .catch(function (er) {
             reject(er);
         });
     });
 }
 
-let ID = 0;
-class NgwConnector$1 {
-    constructor(options) {
+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';
-        const exist = findConnector(options);
+        var exist = findConnector(options);
         if (exist) {
             return exist;
         }
@@ -1626,19 +1790,19 @@ class NgwConnector$1 {
             addConnector(this);
         }
     }
-    static create(options) {
+    NgwConnector.create = function (options) {
         return new this(options);
-    }
+    };
     /**
      * Fast way to specify the connection address to NextGIS Web.
      * The current connection will be severed.
      * @param baseUrl - NGW url
      */
-    setNgw(baseUrl) {
+    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
@@ -1652,101 +1816,105 @@ class NgwConnector$1 {
      *   .catch((er) => console.log('Connection problem', er));
      * ```
      */
-    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.getUserInfo({ login, password })
-                        .then(() => {
-                        makeQuery();
+    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((er) => reject(er));
+                        .catch(function (er) {
+                        reject(er);
+                    });
+                };
+                if (auth) {
+                    var login = auth.login, password = auth.password;
+                    if (login && password) {
+                        return _this.getUserInfo({ login: login, password: password })
+                            .then(function () {
+                            makeQuery();
+                        })
+                            .catch(function (er) { return reject(er); });
+                    }
                 }
-            }
-            return makeQuery();
-        });
+                return makeQuery();
+            });
+        };
         return cache.add('route', makeConnect, {
             id: this.id,
-            auth,
+            auth: auth,
             baseUrl: this.options.baseUrl,
         });
-    }
+    };
     /**
      * Quick way to change NextGIS Web user.
      * @param credentials - New user credentials
      */
-    login(credentials) {
+    NgwConnector.prototype.login = function (credentials) {
         this.logout();
         addConnector(this);
         return this.getUserInfo(credentials);
-    }
+    };
     /**
      * Disconnecting a user. Aborting all current requests
      */
-    logout() {
+    NgwConnector.prototype.logout = function () {
         removeConnector(this);
         this.options.auth = undefined;
         this.user = undefined;
         this.emitter.emit('logout');
         this.resources.cache.clean();
-    }
-    getUserInfo(credentials) {
+    };
+    NgwConnector.prototype.getUserInfo = function (credentials) {
+        var _this = this;
         if (this.user && this.user.id) {
             return CancelablePromise.resolve(this.user);
         }
         if (credentials) {
             this.options.auth = credentials;
         }
-        const options = {
+        var options = {
             headers: this.getAuthorizationHeaders(credentials),
             // withCredentials: true
         };
         // Do not use apiRequest('auth.current_user') to avoid circular-references
         return this.makeQuery('/api/component/auth/current_user', {}, options)
-            .then((data) => {
-            this.user = data;
-            this.emitter.emit('login', data);
+            .then(function (data) {
+            _this.user = data;
+            _this.emitter.emit('login', data);
             return data;
         })
-            .catch((er) => {
-            this.emitter.emit('login:error', er);
+            .catch(function (er) {
+            _this.emitter.emit('login:error', er);
             throw er;
         });
-    }
+    };
     /**
      * Obtaining the required Headers for authentication of requests in the NGW.
      */
-    getAuthorizationHeaders(credentials) {
-        const client = this.makeClientId(credentials);
+    NgwConnector.prototype.getAuthorizationHeaders = function (credentials) {
+        var client = this.makeClientId(credentials);
         if (client) {
             return {
                 Authorization: 'Basic ' + client,
             };
         }
-    }
-    makeClientId(credentials) {
+    };
+    NgwConnector.prototype.makeClientId = function (credentials) {
         credentials = credentials || this.options.auth;
         if (credentials) {
-            const { login, password } = credentials;
-            const str = unescape(encodeURIComponent(`${login}:${password}`));
+            var login = credentials.login, password = credentials.password;
+            var str = unescape(encodeURIComponent("".concat(login, ":").concat(password)));
             // @ts-ignore
             {
                 return window.btoa(str);
             }
         }
-    }
+    };
     /**
      * 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}
@@ -1776,25 +1944,27 @@ class NgwConnector$1 {
      *
      * ```
      */
-    apiRequest(name, params_ = {}, requestOptions = {}) {
-        const { method, headers, withCredentials, responseType } = requestOptions;
-        const params = objectRemoveEmpty(params_);
-        const makeApiRequest = () => apiRequest({ name, params, requestOptions, connector: this });
+    NgwConnector.prototype.apiRequest = function (name, params_, requestOptions) {
+        var _this = this;
+        if (params_ === void 0) { params_ = {}; }
+        if (requestOptions === void 0) { requestOptions = {}; }
+        var method = requestOptions.method, headers = requestOptions.headers, withCredentials = requestOptions.withCredentials, responseType = requestOptions.responseType;
+        var params = objectRemoveEmpty(params_);
+        var makeApiRequest = function () {
+            return apiRequest({ name: name, params: params, requestOptions: requestOptions, connector: _this });
+        };
         if (requestOptions.cache && method === 'GET') {
-            const cache = new Cache();
-            return cache.add(name, makeApiRequest, {
-                params,
-                ...objectRemoveEmpty({
-                    headers,
-                    withCredentials,
-                    responseType,
-                    baseUrl: this.options.baseUrl,
-                    auth: this.options.auth,
-                }),
-            });
+            var cache = new Cache();
+            return cache.add(name, makeApiRequest, __assign({ params: params }, objectRemoveEmpty({
+                headers: headers,
+                withCredentials: withCredentials,
+                responseType: responseType,
+                baseUrl: this.options.baseUrl,
+                auth: this.options.auth,
+            })));
         }
         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}
@@ -1808,62 +1978,63 @@ class NgwConnector$1 {
      *   .catch((error) => console.warn(error));
      * ```
      */
-    post(name, options, params) {
+    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
      */
-    get(name, options, 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
      */
-    patch(name, options, 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
      */
-    put(name, options, 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
      */
-    delete(name, options, 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
      */
-    makeQuery(url, params, 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) {
@@ -1876,112 +2047,110 @@ class NgwConnector$1 {
         else {
             throw new Error('Empty `url` not allowed');
         }
-    }
+    };
     // -------------------------------------------------------------------------
     // Resource Methods
     // -------------------------------------------------------------------------
     /**
      * {@inheritDoc ResourcesControl.getOne}
      */
-    getResource(resource, requestOptions) {
+    NgwConnector.prototype.getResource = function (resource, requestOptions) {
         return this.resources.getOne(resource, requestOptions);
-    }
+    };
     /**
      * {@inheritDoc ResourcesControl.getOneOrFail}
      */
-    getResourceOrFail(resource, requestOptions) {
+    NgwConnector.prototype.getResourceOrFail = function (resource, requestOptions) {
         return this.resources.getOneOrFail(resource, requestOptions);
-    }
+    };
     /**
      * @deprecated - use {@link NgwConnector.getResource}
      */
-    getResourceBy(resource) {
+    NgwConnector.prototype.getResourceBy = function (resource) {
         return this.resources.getOne(resource);
-    }
+    };
     /**
      * @deprecated - use {@link NgwConnector.getResource}
      */
-    getResourceByKeyname(keyname) {
+    NgwConnector.prototype.getResourceByKeyname = function (keyname) {
         return this.resources.getOne(keyname);
-    }
+    };
     /**
      * @deprecated - use {@link NgwConnector.getResource}
      */
-    getResourceById(id) {
+    NgwConnector.prototype.getResourceById = function (id) {
         return this.resources.getOne(id);
-    }
+    };
     /**
      * {@inheritDoc ResourcesControl.getId}
      */
-    getResourceId(resource, requestOptions) {
+    NgwConnector.prototype.getResourceId = function (resource, requestOptions) {
         return this.resources.getId(resource, requestOptions);
-    }
+    };
     /**
      * {@inheritDoc ResourcesControl.getIdOrFail}
      */
-    getResourceIdOrFail(resource, requestOptions) {
+    NgwConnector.prototype.getResourceIdOrFail = function (resource, requestOptions) {
         return this.resources.getIdOrFail(resource, requestOptions);
-    }
+    };
     /**
      * {@inheritDoc ResourcesControl.getMany}
      */
-    getResourcesBy(resource, requestOptions) {
+    NgwConnector.prototype.getResourcesBy = function (resource, requestOptions) {
         return this.resources.getMany(resource, requestOptions);
-    }
+    };
     /**
      * {@inheritDoc ResourcesControl.getParent}
      */
-    getResourceParent(resource, requestOptions) {
+    NgwConnector.prototype.getResourceParent = function (resource, requestOptions) {
         return this.resources.getParent(resource, requestOptions);
-    }
+    };
     /**
      * {@inheritDoc ResourcesControl.getChildrenOf}
      */
-    getResourceChildren(resource, requestOptions) {
+    NgwConnector.prototype.getResourceChildren = function (resource, requestOptions) {
         return this.resources.getChildrenOf(resource, requestOptions);
-    }
+    };
     /**
      * {@inheritDoc ResourcesControl.update}
      */
-    updateResource(resource, data) {
+    NgwConnector.prototype.updateResource = function (resource, data) {
         return this.resources.update(resource, data);
-    }
+    };
     /**
      * {@inheritDoc ResourcesControl.delete}
      */
-    deleteResource(resource) {
+    NgwConnector.prototype.deleteResource = function (resource) {
         return this.resources.delete(resource);
-    }
+    };
     /**
      * @internal
      */
-    _loadData(url, options) {
+    NgwConnector.prototype._loadData = function (url, options) {
+        var _this = this;
         options.responseType = options.responseType || 'json';
-        return new CancelablePromise((resolve, reject, onCancel) => {
-            if (this.user) {
+        return new CancelablePromise(function (resolve, reject, onCancel) {
+            if (_this.user) {
                 options = options || {};
                 // options.withCredentials = true;
-                options.headers = {
-                    ...this.getAuthorizationHeaders(),
-                    ...options.headers,
-                };
+                options.headers = __assign(__assign({}, _this.getAuthorizationHeaders()), options.headers);
             }
             loadData(url, resolve, options, reject, onCancel);
-        }).catch((httpError) => {
+        }).catch(function (httpError) {
             if (httpError instanceof CancelablePromise.CancelError) ;
             else {
                 // @ts-ignore
                 {
                     console.warn('DEV WARN', httpError);
                 }
-                const er = this._handleHttpError(httpError);
+                var er = _this._handleHttpError(httpError);
                 if (er) {
                     throw er;
                 }
             }
         });
-    }
-    _handleHttpError(er) {
+    };
+    NgwConnector.prototype._handleHttpError = function (er) {
         if (er) {
             if (er instanceof NgwError) {
                 if (er.exception === 'nextgisweb.resource.exception.ResourceNotFound') {
@@ -1993,12 +2162,13 @@ class NgwConnector$1 {
             }
         }
         return er;
-    }
-}
-NgwConnector$1.errors = {
-    NgwError,
-    ResourceNotFoundError,
-};
+    };
+    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