@balancy/utils 1.0.34

package/dist/index.umd.js

@@ -0,0 +1,3230 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["@balancy/utils"] = {}));
+})(this, (function (exports) { 'use strict';
+
+  // Временный импорт для типизации - будет заменен на динамическую инъекцию
+  // import {DataObjectsManager} from "@balancy/core";
+  function asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, key, arg) {
+      try {
+          var info = gen[key](arg);
+          var value = info.value;
+      } catch (error) {
+          reject(error);
+          return;
+      }
+      if (info.done) {
+          resolve(value);
+      } else {
+          Promise.resolve(value).then(_next, _throw);
+      }
+  }
+  function _async_to_generator$2(fn) {
+      return function() {
+          var self = this, args = arguments;
+          return new Promise(function(resolve, reject) {
+              var gen = fn.apply(self, args);
+              function _next(value) {
+                  asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "next", value);
+              }
+              function _throw(err) {
+                  asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "throw", err);
+              }
+              _next(undefined);
+          });
+      };
+  }
+  function _class_call_check$1(instance, Constructor) {
+      if (!(instance instanceof Constructor)) {
+          throw new TypeError("Cannot call a class as a function");
+      }
+  }
+  function _defineProperties$1(target, props) {
+      for(var i = 0; i < props.length; i++){
+          var descriptor = props[i];
+          descriptor.enumerable = descriptor.enumerable || false;
+          descriptor.configurable = true;
+          if ("value" in descriptor) descriptor.writable = true;
+          Object.defineProperty(target, descriptor.key, descriptor);
+      }
+  }
+  function _create_class$1(Constructor, protoProps, staticProps) {
+      if (protoProps) _defineProperties$1(Constructor.prototype, protoProps);
+      return Constructor;
+  }
+  function _define_property$1(obj, key, value) {
+      if (key in obj) {
+          Object.defineProperty(obj, key, {
+              value: value,
+              enumerable: true,
+              configurable: true,
+              writable: true
+          });
+      } else {
+          obj[key] = value;
+      }
+      return obj;
+  }
+  function _instanceof$2(left, right) {
+      if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+          return !!right[Symbol.hasInstance](left);
+      } else {
+          return left instanceof right;
+      }
+  }
+  function _ts_generator$2(thisArg, body) {
+      var f, y, t, g, _ = {
+          label: 0,
+          sent: function() {
+              if (t[0] & 1) throw t[1];
+              return t[1];
+          },
+          trys: [],
+          ops: []
+      };
+      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 _ts_values(o) {
+      var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+      if (m) return m.call(o);
+      if (o && typeof o.length === "number") return {
+          next: function() {
+              if (o && i >= o.length) o = void 0;
+              return {
+                  value: o && o[i++],
+                  done: !o
+              };
+          }
+      };
+      throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+  }
+  var IndexedDBFileHelper = /*#__PURE__*/ function() {
+      function IndexedDBFileHelper(paths) {
+          _class_call_check$1(this, IndexedDBFileHelper);
+          _define_property$1(this, "cacheDir", void 0);
+          _define_property$1(this, "codeDir", void 0);
+          _define_property$1(this, "resourcesDir", void 0);
+          _define_property$1(this, "db", null);
+          _define_property$1(this, "isInitialized", false);
+          _define_property$1(this, "isTempActive", false);
+          _define_property$1(this, "spriteLoader", void 0);
+          _define_property$1(this, "DB_NAME", 'BalancyFileStorage');
+          _define_property$1(this, "DB_VERSION", 1);
+          _define_property$1(this, "STORES", {
+              FILES: 'files',
+              DIRECTORIES: 'directories'
+          });
+          this.cacheDir = paths.cachePath;
+          this.codeDir = paths.codePath;
+          this.resourcesDir = paths.resourcesPath;
+      }
+      _create_class$1(IndexedDBFileHelper, [
+          {
+              key: "getCachedDirectory",
+              value: function getCachedDirectory() {
+                  return this.cacheDir;
+              }
+          },
+          {
+              key: "ensureInitialized",
+              value: function ensureInitialized() {
+                  var _this = this;
+                  return _async_to_generator$2(function() {
+                      return _ts_generator$2(this, function(_state) {
+                          switch(_state.label){
+                              case 0:
+                                  if (!!_this.isInitialized) return [
+                                      3,
+                                      2
+                                  ];
+                                  return [
+                                      4,
+                                      _this.initIndexedDB()
+                                  ];
+                              case 1:
+                                  _state.sent();
+                                  _this.isInitialized = true;
+                                  _state.label = 2;
+                              case 2:
+                                  return [
+                                      2
+                                  ];
+                          }
+                      });
+                  })();
+              }
+          },
+          {
+              key: "initIndexedDB",
+              value: function initIndexedDB() {
+                  var _this = this;
+                  return _async_to_generator$2(function() {
+                      return _ts_generator$2(this, function(_state) {
+                          return [
+                              2,
+                              new Promise(function(resolve, reject) {
+                                  var request = indexedDB.open(_this.DB_NAME, _this.DB_VERSION);
+                                  request.onerror = function() {
+                                      return reject(request.error);
+                                  };
+                                  request.onsuccess = function() {
+                                      _this.db = request.result;
+                                      resolve();
+                                  };
+                                  request.onupgradeneeded = function(event) {
+                                      var db = event.target.result;
+                                      // Хранилище файлов
+                                      if (!db.objectStoreNames.contains(_this.STORES.FILES)) {
+                                          var filesStore = db.createObjectStore(_this.STORES.FILES, {
+                                              keyPath: 'fileName'
+                                          });
+                                          filesStore.createIndex('directory', 'directory', {
+                                              unique: false
+                                          });
+                                          filesStore.createIndex('fileType', 'fileType', {
+                                              unique: false
+                                          });
+                                      }
+                                      // Хранилище директорий
+                                      if (!db.objectStoreNames.contains(_this.STORES.DIRECTORIES)) {
+                                          var dirsStore = db.createObjectStore(_this.STORES.DIRECTORIES, {
+                                              keyPath: 'path'
+                                          });
+                                          dirsStore.createIndex('parentPath', 'parentPath', {
+                                              unique: false
+                                          });
+                                      }
+                                  };
+                              })
+                          ];
+                      });
+                  })();
+              }
+          },
+          {
+              key: "getFullPath",
+              value: function getFullPath(directory, fileName) {
+                  return "".concat(directory, "/").concat(fileName);
+              }
+          },
+          {
+              key: "getTempPath",
+              value: function getTempPath(directory) {
+                  return "".concat(directory, "/temp");
+              }
+          },
+          {
+              key: "normalizeData",
+              value: function normalizeData(data) {
+                  if (typeof data === 'string') {
+                      return {
+                          data: data,
+                          fileType: 'text'
+                      };
+                  } else if (_instanceof$2(data, Uint8Array)) {
+                      return {
+                          data: data.buffer,
+                          fileType: 'binary'
+                      };
+                  } else {
+                      return {
+                          data: data,
+                          fileType: 'binary'
+                      };
+                  }
+              }
+          },
+          {
+              key: "saveFile",
+              value: function saveFile(directory, fileName, data) {
+                  var _this = this;
+                  return _async_to_generator$2(function() {
+                      var actualDirectory, fullPath, _this_normalizeData, normalizedData, fileType, fileRecord, transaction;
+                      return _ts_generator$2(this, function(_state) {
+                          switch(_state.label){
+                              case 0:
+                                  return [
+                                      4,
+                                      _this.ensureInitialized()
+                                  ];
+                              case 1:
+                                  _state.sent();
+                                  actualDirectory = _this.isTempActive ? _this.getTempPath(directory) : directory;
+                                  fullPath = _this.getFullPath(actualDirectory, fileName);
+                                  _this_normalizeData = _this.normalizeData(data), normalizedData = _this_normalizeData.data, fileType = _this_normalizeData.fileType;
+                                  fileRecord = {
+                                      fileName: fullPath,
+                                      directory: actualDirectory,
+                                      data: normalizedData,
+                                      fileType: fileType,
+                                      size: typeof normalizedData === 'string' ? normalizedData.length : normalizedData.byteLength,
+                                      lastModified: Date.now()
+                                  };
+                                  transaction = _this.db.transaction([
+                                      _this.STORES.FILES
+                                  ], 'readwrite');
+                                  return [
+                                      4,
+                                      new Promise(function(resolve, reject) {
+                                          var request = transaction.objectStore(_this.STORES.FILES).put(fileRecord);
+                                          request.onsuccess = function() {
+                                              return resolve();
+                                          };
+                                          request.onerror = function() {
+                                              return reject(request.error);
+                                          };
+                                      })
+                                  ];
+                              case 2:
+                                  _state.sent();
+                                  return [
+                                      2
+                                  ];
+                          }
+                      });
+                  })();
+              }
+          },
+          {
+              key: "loadFile",
+              value: function loadFile(directory, fileName) {
+                  var _this = this;
+                  return _async_to_generator$2(function() {
+                      var fullPath;
+                      return _ts_generator$2(this, function(_state) {
+                          switch(_state.label){
+                              case 0:
+                                  return [
+                                      4,
+                                      _this.ensureInitialized()
+                                  ];
+                              case 1:
+                                  _state.sent();
+                                  fullPath = _this.getFullPath(directory, fileName);
+                                  return [
+                                      2,
+                                      new Promise(function(resolve, reject) {
+                                          var transaction = _this.db.transaction([
+                                              _this.STORES.FILES
+                                          ], 'readonly');
+                                          var request = transaction.objectStore(_this.STORES.FILES).get(fullPath);
+                                          request.onsuccess = function() {
+                                              var result = request.result;
+                                              resolve(result ? result.data : null);
+                                          };
+                                          request.onerror = function() {
+                                              return reject(request.error);
+                                          };
+                                      })
+                                  ];
+                          }
+                      });
+                  })();
+              }
+          },
+          {
+              key: "fileExists",
+              value: function fileExists(directory, fileName) {
+                  var _this = this;
+                  return _async_to_generator$2(function() {
+                      var fullPath;
+                      return _ts_generator$2(this, function(_state) {
+                          switch(_state.label){
+                              case 0:
+                                  return [
+                                      4,
+                                      _this.ensureInitialized()
+                                  ];
+                              case 1:
+                                  _state.sent();
+                                  fullPath = _this.getFullPath(directory, fileName);
+                                  return [
+                                      2,
+                                      new Promise(function(resolve, reject) {
+                                          var transaction = _this.db.transaction([
+                                              _this.STORES.FILES
+                                          ], 'readonly');
+                                          var request = transaction.objectStore(_this.STORES.FILES).get(fullPath);
+                                          request.onsuccess = function() {
+                                              return resolve(!!request.result);
+                                          };
+                                          request.onerror = function() {
+                                              return reject(request.error);
+                                          };
+                                      })
+                                  ];
+                          }
+                      });
+                  })();
+              }
+          },
+          {
+              key: "deleteFile",
+              value: function deleteFile(directory, fileName) {
+                  var _this = this;
+                  return _async_to_generator$2(function() {
+                      var fullPath, transaction;
+                      return _ts_generator$2(this, function(_state) {
+                          switch(_state.label){
+                              case 0:
+                                  return [
+                                      4,
+                                      _this.ensureInitialized()
+                                  ];
+                              case 1:
+                                  _state.sent();
+                                  fullPath = _this.getFullPath(directory, fileName);
+                                  transaction = _this.db.transaction([
+                                      _this.STORES.FILES
+                                  ], 'readwrite');
+                                  return [
+                                      4,
+                                      new Promise(function(resolve, reject) {
+                                          var request = transaction.objectStore(_this.STORES.FILES).delete(fullPath);
+                                          request.onsuccess = function() {
+                                              return resolve();
+                                          };
+                                          request.onerror = function() {
+                                              return reject(request.error);
+                                          };
+                                      })
+                                  ];
+                              case 2:
+                                  _state.sent();
+                                  return [
+                                      2
+                                  ];
+                          }
+                      });
+                  })();
+              }
+          },
+          {
+              key: "clearDirectory",
+              value: function clearDirectory(directory) {
+                  var _this = this;
+                  return _async_to_generator$2(function() {
+                      var transaction, store, index;
+                      return _ts_generator$2(this, function(_state) {
+                          switch(_state.label){
+                              case 0:
+                                  return [
+                                      4,
+                                      _this.ensureInitialized()
+                                  ];
+                              case 1:
+                                  _state.sent();
+                                  transaction = _this.db.transaction([
+                                      _this.STORES.FILES
+                                  ], 'readwrite');
+                                  store = transaction.objectStore(_this.STORES.FILES);
+                                  index = store.index('directory');
+                                  return [
+                                      4,
+                                      new Promise(function(resolve, reject) {
+                                          var request = index.openCursor(IDBKeyRange.only(directory));
+                                          request.onsuccess = function(event) {
+                                              var cursor = event.target.result;
+                                              if (cursor) {
+                                                  cursor.delete();
+                                                  cursor.continue();
+                                              } else {
+                                                  resolve();
+                                              }
+                                          };
+                                          request.onerror = function() {
+                                              return reject(request.error);
+                                          };
+                                      })
+                                  ];
+                              case 2:
+                                  _state.sent();
+                                  return [
+                                      2
+                                  ];
+                          }
+                      });
+                  })();
+              }
+          },
+          {
+              key: "getFilesInDirectory",
+              value: function getFilesInDirectory(directory) {
+                  var _this = this;
+                  return _async_to_generator$2(function() {
+                      return _ts_generator$2(this, function(_state) {
+                          switch(_state.label){
+                              case 0:
+                                  return [
+                                      4,
+                                      _this.ensureInitialized()
+                                  ];
+                              case 1:
+                                  _state.sent();
+                                  return [
+                                      2,
+                                      new Promise(function(resolve, reject) {
+                                          var transaction = _this.db.transaction([
+                                              _this.STORES.FILES
+                                          ], 'readonly');
+                                          var store = transaction.objectStore(_this.STORES.FILES);
+                                          var index = store.index('directory');
+                                          var files = [];
+                                          var request = index.openCursor(IDBKeyRange.only(directory));
+                                          request.onsuccess = function(event) {
+                                              var cursor = event.target.result;
+                                              if (cursor) {
+                                                  var record = cursor.value;
+                                                  // Извлекаем только имя файла без пути к директории
+                                                  var fileName = record.fileName.substring(directory.length + 1);
+                                                  // Проверяем что это файл в этой директории, а не в поддиректории
+                                                  if (fileName && !fileName.includes('/')) {
+                                                      files.push(fileName);
+                                                  }
+                                                  cursor.continue();
+                                              } else {
+                                                  resolve(files);
+                                              }
+                                          };
+                                          request.onerror = function() {
+                                              return reject(request.error);
+                                          };
+                                      })
+                                  ];
+                          }
+                      });
+                  })();
+              }
+          },
+          {
+              key: "arrayBufferToBase64",
+              value: function arrayBufferToBase64(buffer) {
+                  var bytes = new Uint8Array(buffer);
+                  var binary = '';
+                  for(var i = 0; i < bytes.byteLength; i++){
+                      binary += String.fromCharCode(bytes[i]);
+                  }
+                  return btoa(binary);
+              }
+          },
+          {
+              key: "createSubDirectoryInCacheCallback",
+              value: // Реализация интерфейса JSFileHelper
+              function createSubDirectoryInCacheCallback(fileName) {
+                  var _this = this;
+                  return _async_to_generator$2(function() {
+                      var actualDirectory, dirPath, dirRecord, transaction;
+                      return _ts_generator$2(this, function(_state) {
+                          switch(_state.label){
+                              case 0:
+                                  return [
+                                      4,
+                                      _this.ensureInitialized()
+                                  ];
+                              case 1:
+                                  _state.sent();
+                                  actualDirectory = _this.isTempActive ? _this.getTempPath(_this.cacheDir) : _this.cacheDir;
+                                  dirPath = _this.getFullPath(actualDirectory, fileName);
+                                  dirRecord = {
+                                      path: dirPath,
+                                      parentPath: actualDirectory,
+                                      name: fileName,
+                                      created: Date.now()
+                                  };
+                                  transaction = _this.db.transaction([
+                                      _this.STORES.DIRECTORIES
+                                  ], 'readwrite');
+                                  return [
+                                      4,
+                                      new Promise(function(resolve, reject) {
+                                          var request = transaction.objectStore(_this.STORES.DIRECTORIES).put(dirRecord);
+                                          request.onsuccess = function() {
+                                              return resolve();
+                                          };
+                                          request.onerror = function() {
+                                              return reject(request.error);
+                                          };
+                                      })
+                                  ];
+                              case 2:
+                                  _state.sent();
+                                  return [
+                                      2
+                                  ];
+                          }
+                      });
+                  })();
+              }
+          },
+          {
+              key: "saveFileInCacheCallback",
+              value: function saveFileInCacheCallback(fileName, data) {
+                  var _this = this;
+                  return _async_to_generator$2(function() {
+                      return _ts_generator$2(this, function(_state) {
+                          switch(_state.label){
+                              case 0:
+                                  return [
+                                      4,
+                                      _this.saveFile(_this.cacheDir, fileName, data)
+                                  ];
+                              case 1:
+                                  _state.sent();
+                                  return [
+                                      2
+                                  ];
+                          }
+                      });
+                  })();
+              }
+          },
+          {
+              key: "saveFileInCacheBinaryCallback",
+              value: function saveFileInCacheBinaryCallback(fileName, data) {
+                  var _this = this;
+                  return _async_to_generator$2(function() {
+                      return _ts_generator$2(this, function(_state) {
+                          switch(_state.label){
+                              case 0:
+                                  return [
+                                      4,
+                                      _this.saveFile(_this.cacheDir, fileName, data)
+                                  ];
+                              case 1:
+                                  _state.sent();
+                                  return [
+                                      2
+                                  ];
+                          }
+                      });
+                  })();
+              }
+          },
+          {
+              key: "saveFileInResourcesCallback",
+              value: function saveFileInResourcesCallback(fileName, data) {
+                  var _this = this;
+                  return _async_to_generator$2(function() {
+                      return _ts_generator$2(this, function(_state) {
+                          switch(_state.label){
+                              case 0:
+                                  if (!_this.resourcesDir) throw new Error('Resources directory not configured');
+                                  return [
+                                      4,
+                                      _this.saveFile(_this.resourcesDir, fileName, data)
+                                  ];
+                              case 1:
+                                  _state.sent();
+                                  return [
+                                      2
+                                  ];
+                          }
+                      });
+                  })();
+              }
+          },
+          {
+              key: "saveFileInResourcesBinaryCallback",
+              value: function saveFileInResourcesBinaryCallback(fileName, data) {
+                  var _this = this;
+                  return _async_to_generator$2(function() {
+                      return _ts_generator$2(this, function(_state) {
+                          switch(_state.label){
+                              case 0:
+                                  if (!_this.resourcesDir) throw new Error('Resources directory not configured');
+                                  return [
+                                      4,
+                                      _this.saveFile(_this.resourcesDir, fileName, data)
+                                  ];
+                              case 1:
+                                  _state.sent();
+                                  return [
+                                      2
+                                  ];
+                          }
+                      });
+                  })();
+              }
+          },
+          {
+              key: "cleanUpResourcesFolderCallback",
+              value: function cleanUpResourcesFolderCallback() {
+                  var _this = this;
+                  return _async_to_generator$2(function() {
+                      return _ts_generator$2(this, function(_state) {
+                          switch(_state.label){
+                              case 0:
+                                  if (!_this.resourcesDir) return [
+                                      2
+                                  ];
+                                  return [
+                                      4,
+                                      _this.clearDirectory(_this.resourcesDir)
+                                  ];
+                              case 1:
+                                  _state.sent();
+                                  return [
+                                      2
+                                  ];
+                          }
+                      });
+                  })();
+              }
+          },
+          {
+              key: "cleanGeneratedCodeFolderCallback",
+              value: function cleanGeneratedCodeFolderCallback() {
+                  var _this = this;
+                  return _async_to_generator$2(function() {
+                      return _ts_generator$2(this, function(_state) {
+                          switch(_state.label){
+                              case 0:
+                                  if (!_this.codeDir) return [
+                                      2
+                                  ];
+                                  return [
+                                      4,
+                                      _this.clearDirectory(_this.codeDir)
+                                  ];
+                              case 1:
+                                  _state.sent();
+                                  return [
+                                      2
+                                  ];
+                          }
+                      });
+                  })();
+              }
+          },
+          {
+              key: "saveGeneratedCodeCallback",
+              value: function saveGeneratedCodeCallback(fileName, data) {
+                  var _this = this;
+                  return _async_to_generator$2(function() {
+                      return _ts_generator$2(this, function(_state) {
+                          switch(_state.label){
+                              case 0:
+                                  if (!_this.codeDir) throw new Error('Code directory not configured');
+                                  return [
+                                      4,
+                                      _this.saveFile(_this.codeDir, fileName, data)
+                                  ];
+                              case 1:
+                                  _state.sent();
+                                  return [
+                                      2
+                                  ];
+                          }
+                      });
+                  })();
+              }
+          },
+          {
+              key: "loadFileFromCacheCallback",
+              value: function loadFileFromCacheCallback(fileName) {
+                  var _this = this;
+                  return _async_to_generator$2(function() {
+                      var data;
+                      return _ts_generator$2(this, function(_state) {
+                          switch(_state.label){
+                              case 0:
+                                  return [
+                                      4,
+                                      _this.loadFile(_this.cacheDir, fileName)
+                                  ];
+                              case 1:
+                                  data = _state.sent();
+                                  return [
+                                      2,
+                                      typeof data === 'string' ? data : ''
+                                  ];
+                          }
+                      });
+                  })();
+              }
+          },
+          {
+              key: "loadFileFromResourcesCallback",
+              value: function loadFileFromResourcesCallback(fileName) {
+                  var _this = this;
+                  return _async_to_generator$2(function() {
+                      var data;
+                      return _ts_generator$2(this, function(_state) {
+                          switch(_state.label){
+                              case 0:
+                                  if (!_this.resourcesDir) return [
+                                      2,
+                                      ''
+                                  ];
+                                  return [
+                                      4,
+                                      _this.loadFile(_this.resourcesDir, fileName)
+                                  ];
+                              case 1:
+                                  data = _state.sent();
+                                  return [
+                                      2,
+                                      typeof data === 'string' ? data : ''
+                                  ];
+                          }
+                      });
+                  })();
+              }
+          },
+          {
+              key: "loadFileFromResourcesAsBase64Callback",
+              value: function loadFileFromResourcesAsBase64Callback(fileName) {
+                  var _this = this;
+                  return _async_to_generator$2(function() {
+                      var data;
+                      return _ts_generator$2(this, function(_state) {
+                          switch(_state.label){
+                              case 0:
+                                  if (!_this.resourcesDir) return [
+                                      2,
+                                      ''
+                                  ];
+                                  return [
+                                      4,
+                                      _this.loadFile(_this.resourcesDir, fileName)
+                                  ];
+                              case 1:
+                                  data = _state.sent();
+                                  if (typeof data === 'string') {
+                                      return [
+                                          2,
+                                          btoa(data)
+                                      ];
+                                  } else if (_instanceof$2(data, ArrayBuffer)) {
+                                      return [
+                                          2,
+                                          _this.arrayBufferToBase64(data)
+                                      ];
+                                  }
+                                  return [
+                                      2,
+                                      ''
+                                  ];
+                          }
+                      });
+                  })();
+              }
+          },
+          {
+              key: "deleteCachedFolderCallback",
+              value: function deleteCachedFolderCallback(path) {
+                  var _this = this;
+                  return _async_to_generator$2(function() {
+                      var folderPath;
+                      return _ts_generator$2(this, function(_state) {
+                          switch(_state.label){
+                              case 0:
+                                  folderPath = _this.getFullPath(_this.cacheDir, path);
+                                  return [
+                                      4,
+                                      _this.clearDirectory(folderPath)
+                                  ];
+                              case 1:
+                                  _state.sent();
+                                  return [
+                                      2
+                                  ];
+                          }
+                      });
+                  })();
+              }
+          },
+          {
+              key: "deleteCachedFileCallback",
+              value: function deleteCachedFileCallback(path) {
+                  var _this = this;
+                  return _async_to_generator$2(function() {
+                      return _ts_generator$2(this, function(_state) {
+                          switch(_state.label){
+                              case 0:
+                                  return [
+                                      4,
+                                      _this.deleteFile(_this.cacheDir, path)
+                                  ];
+                              case 1:
+                                  _state.sent();
+                                  return [
+                                      2
+                                  ];
+                          }
+                      });
+                  })();
+              }
+          },
+          {
+              key: "fileExistsInCacheCallback",
+              value: function fileExistsInCacheCallback(fileName) {
+                  var _this = this;
+                  return _async_to_generator$2(function() {
+                      return _ts_generator$2(this, function(_state) {
+                          switch(_state.label){
+                              case 0:
+                                  return [
+                                      4,
+                                      _this.fileExists(_this.cacheDir, fileName)
+                                  ];
+                              case 1:
+                                  return [
+                                      2,
+                                      _state.sent()
+                                  ];
+                          }
+                      });
+                  })();
+              }
+          },
+          {
+              key: "fileExistsInResourcesCallback",
+              value: function fileExistsInResourcesCallback(fileName) {
+                  var _this = this;
+                  return _async_to_generator$2(function() {
+                      return _ts_generator$2(this, function(_state) {
+                          switch(_state.label){
+                              case 0:
+                                  if (!_this.resourcesDir) return [
+                                      2,
+                                      false
+                                  ];
+                                  return [
+                                      4,
+                                      _this.fileExists(_this.resourcesDir, fileName)
+                                  ];
+                              case 1:
+                                  return [
+                                      2,
+                                      _state.sent()
+                                  ];
+                          }
+                      });
+                  })();
+              }
+          },
+          {
+              key: "getUrlCachePathCallback",
+              value: function getUrlCachePathCallback(id, fileName) {
+                  if (this.spriteLoader) {
+                      this.spriteLoader(id, function(path) {});
+                  } else {
+                      console.warn('No sprite loader configured. Call setSpriteLoader() to set DataObjectsManager integration.');
+                  }
+              }
+          },
+          {
+              /**
+     * Устанавливает функцию для загрузки спрайтов
+     * Должна быть вызвана из приложения для интеграции с DataObjectsManager
+     */ key: "setSpriteLoader",
+              value: function setSpriteLoader(loader) {
+                  this.spriteLoader = loader;
+              }
+          },
+          {
+              key: "getCachePathCallback",
+              value: function getCachePathCallback(fileName) {
+                  return this.getFullPath(this.cacheDir, fileName);
+              }
+          },
+          {
+              key: "getResourcesPathCallback",
+              value: function getResourcesPathCallback(fileName) {
+                  if (!this.resourcesDir) return '';
+                  return this.getFullPath(this.resourcesDir, fileName);
+              }
+          },
+          {
+              key: "getFilesInCachedFolderCallback",
+              value: function getFilesInCachedFolderCallback(path) {
+                  var _this = this;
+                  return _async_to_generator$2(function() {
+                      var folderPath;
+                      return _ts_generator$2(this, function(_state) {
+                          switch(_state.label){
+                              case 0:
+                                  folderPath = path === '' ? _this.cacheDir : _this.getFullPath(_this.cacheDir, path);
+                                  return [
+                                      4,
+                                      _this.getFilesInDirectory(folderPath)
+                                  ];
+                              case 1:
+                                  return [
+                                      2,
+                                      _state.sent()
+                                  ];
+                          }
+                      });
+                  })();
+              }
+          },
+          {
+              key: "getFoldersInCachedFolderCallback",
+              value: function getFoldersInCachedFolderCallback(path) {
+                  var _this = this;
+                  return _async_to_generator$2(function() {
+                      var folderPath;
+                      return _ts_generator$2(this, function(_state) {
+                          switch(_state.label){
+                              case 0:
+                                  return [
+                                      4,
+                                      _this.ensureInitialized()
+                                  ];
+                              case 1:
+                                  _state.sent();
+                                  folderPath = path === '' ? _this.cacheDir : _this.getFullPath(_this.cacheDir, path);
+                                  return [
+                                      2,
+                                      new Promise(function(resolve, reject) {
+                                          var transaction = _this.db.transaction([
+                                              _this.STORES.DIRECTORIES
+                                          ], 'readonly');
+                                          var store = transaction.objectStore(_this.STORES.DIRECTORIES);
+                                          var index = store.index('parentPath');
+                                          var folders = [];
+                                          var request = index.openCursor(IDBKeyRange.only(folderPath));
+                                          request.onsuccess = function(event) {
+                                              var cursor = event.target.result;
+                                              if (cursor) {
+                                                  var record = cursor.value;
+                                                  folders.push(record.name);
+                                                  cursor.continue();
+                                              } else {
+                                                  resolve(folders);
+                                              }
+                                          };
+                                          request.onerror = function() {
+                                              return reject(request.error);
+                                          };
+                                      })
+                                  ];
+                          }
+                      });
+                  })();
+              }
+          },
+          {
+              key: "getFilesInResourcesFolderCallback",
+              value: // Метод для получения всех файлов из resources директории
+              function getFilesInResourcesFolderCallback() {
+                  var path = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : '';
+                  var _this = this;
+                  return _async_to_generator$2(function() {
+                      var folderPath;
+                      return _ts_generator$2(this, function(_state) {
+                          switch(_state.label){
+                              case 0:
+                                  if (!_this.resourcesDir) return [
+                                      2,
+                                      []
+                                  ];
+                                  folderPath = path === '' ? _this.resourcesDir : _this.getFullPath(_this.resourcesDir, path);
+                                  return [
+                                      4,
+                                      _this.getFilesInDirectory(folderPath)
+                                  ];
+                              case 1:
+                                  return [
+                                      2,
+                                      _state.sent()
+                                  ];
+                          }
+                      });
+                  })();
+              }
+          },
+          {
+              key: "getFilesInCodeFolderCallback",
+              value: // Метод для получения всех файлов из code директории
+              function getFilesInCodeFolderCallback() {
+                  var path = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : '';
+                  var _this = this;
+                  return _async_to_generator$2(function() {
+                      var folderPath;
+                      return _ts_generator$2(this, function(_state) {
+                          switch(_state.label){
+                              case 0:
+                                  if (!_this.codeDir) return [
+                                      2,
+                                      []
+                                  ];
+                                  folderPath = path === '' ? _this.codeDir : _this.getFullPath(_this.codeDir, path);
+                                  return [
+                                      4,
+                                      _this.getFilesInDirectory(folderPath)
+                                  ];
+                              case 1:
+                                  return [
+                                      2,
+                                      _state.sent()
+                                  ];
+                          }
+                      });
+                  })();
+              }
+          },
+          {
+              key: "activateTempFolderCallback",
+              value: function activateTempFolderCallback() {
+                  this.isTempActive = true;
+              }
+          },
+          {
+              key: "deactivateTempFolderCallback",
+              value: function deactivateTempFolderCallback() {
+                  this.isTempActive = false;
+              }
+          },
+          {
+              key: "applyTempFolderCallback",
+              value: function applyTempFolderCallback(tempFolder) {
+                  var _this = this;
+                  return _async_to_generator$2(function() {
+                      var tempPath, tempFolderPath, tempFiles, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _loop, _iterator, _step, err;
+                      return _ts_generator$2(this, function(_state) {
+                          switch(_state.label){
+                              case 0:
+                                  tempPath = _this.getTempPath(_this.cacheDir);
+                                  tempFolderPath = _this.getFullPath(tempPath, tempFolder);
+                                  return [
+                                      4,
+                                      _this.getFilesInDirectory(tempFolderPath)
+                                  ];
+                              case 1:
+                                  tempFiles = _state.sent();
+                                  _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                  _state.label = 2;
+                              case 2:
+                                  _state.trys.push([
+                                      2,
+                                      7,
+                                      8,
+                                      9
+                                  ]);
+                                  _loop = function() {
+                                      var fileName, cacheFilePath, data, _this_normalizeData, normalizedData, fileType, fileRecord, transaction;
+                                      return _ts_generator$2(this, function(_state) {
+                                          switch(_state.label){
+                                              case 0:
+                                                  fileName = _step.value;
+                                                  _this.getFullPath(tempFolderPath, fileName);
+                                                  cacheFilePath = _this.getFullPath(_this.cacheDir, fileName);
+                                                  return [
+                                                      4,
+                                                      _this.loadFile(tempFolderPath, fileName)
+                                                  ];
+                                              case 1:
+                                                  data = _state.sent();
+                                                  if (!data) return [
+                                                      3,
+                                                      4
+                                                  ];
+                                                  // Сохраняем в основную папку
+                                                  _this_normalizeData = _this.normalizeData(data), normalizedData = _this_normalizeData.data, fileType = _this_normalizeData.fileType;
+                                                  fileRecord = {
+                                                      fileName: cacheFilePath,
+                                                      directory: _this.cacheDir,
+                                                      data: normalizedData,
+                                                      fileType: fileType,
+                                                      size: typeof normalizedData === 'string' ? normalizedData.length : normalizedData.byteLength,
+                                                      lastModified: Date.now()
+                                                  };
+                                                  transaction = _this.db.transaction([
+                                                      _this.STORES.FILES
+                                                  ], 'readwrite');
+                                                  return [
+                                                      4,
+                                                      new Promise(function(resolve, reject) {
+                                                          var request = transaction.objectStore(_this.STORES.FILES).put(fileRecord);
+                                                          request.onsuccess = function() {
+                                                              return resolve();
+                                                          };
+                                                          request.onerror = function() {
+                                                              return reject(request.error);
+                                                          };
+                                                      })
+                                                  ];
+                                              case 2:
+                                                  _state.sent();
+                                                  // Удаляем из временной папки
+                                                  return [
+                                                      4,
+                                                      _this.deleteFile(tempFolderPath, fileName)
+                                                  ];
+                                              case 3:
+                                                  _state.sent();
+                                                  _state.label = 4;
+                                              case 4:
+                                                  return [
+                                                      2
+                                                  ];
+                                          }
+                                      });
+                                  };
+                                  _iterator = tempFiles[Symbol.iterator]();
+                                  _state.label = 3;
+                              case 3:
+                                  if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                                      3,
+                                      6
+                                  ];
+                                  return [
+                                      5,
+                                      _ts_values(_loop())
+                                  ];
+                              case 4:
+                                  _state.sent();
+                                  _state.label = 5;
+                              case 5:
+                                  _iteratorNormalCompletion = true;
+                                  return [
+                                      3,
+                                      3
+                                  ];
+                              case 6:
+                                  return [
+                                      3,
+                                      9
+                                  ];
+                              case 7:
+                                  err = _state.sent();
+                                  _didIteratorError = true;
+                                  _iteratorError = err;
+                                  return [
+                                      3,
+                                      9
+                                  ];
+                              case 8:
+                                  try {
+                                      if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                          _iterator.return();
+                                      }
+                                  } finally{
+                                      if (_didIteratorError) {
+                                          throw _iteratorError;
+                                      }
+                                  }
+                                  return [
+                                      7
+                                  ];
+                              case 9:
+                                  // Очищаем временную папку
+                                  return [
+                                      4,
+                                      _this.clearDirectory(tempFolderPath)
+                                  ];
+                              case 10:
+                                  _state.sent();
+                                  _this.isTempActive = false;
+                                  return [
+                                      2
+                                  ];
+                          }
+                      });
+                  })();
+              }
+          },
+          {
+              key: "isTempFolderActiveCallback",
+              value: function isTempFolderActiveCallback() {
+                  return this.isTempActive;
+              }
+          },
+          {
+              key: "createObjectUrl",
+              value: // Дополнительные методы для работы с Object URL (бонус)
+              function createObjectUrl(directory, fileName) {
+                  var _this = this;
+                  return _async_to_generator$2(function() {
+                      var data, blob;
+                      return _ts_generator$2(this, function(_state) {
+                          switch(_state.label){
+                              case 0:
+                                  return [
+                                      4,
+                                      _this.loadFile(directory, fileName)
+                                  ];
+                              case 1:
+                                  data = _state.sent();
+                                  if (!data || typeof data === 'string') return [
+                                      2,
+                                      null
+                                  ];
+                                  blob = new Blob([
+                                      data
+                                  ]);
+                                  return [
+                                      2,
+                                      URL.createObjectURL(blob)
+                                  ];
+                          }
+                      });
+                  })();
+              }
+          },
+          {
+              // Получение доступа к базе данных (для расширенных операций)
+              key: "getDatabase",
+              value: function getDatabase() {
+                  return this.db;
+              }
+          },
+          {
+              // Очистка ресурсов
+              key: "close",
+              value: function close() {
+                  if (this.db) {
+                      this.db.close();
+                      this.db = null;
+                      this.isInitialized = false;
+                  }
+              }
+          }
+      ]);
+      return IndexedDBFileHelper;
+  }();
+
+  function _array_like_to_array(arr, len) {
+      if (len == null || len > arr.length) len = arr.length;
+      for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+      return arr2;
+  }
+  function _array_with_holes(arr) {
+      if (Array.isArray(arr)) return arr;
+  }
+  function asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, key, arg) {
+      try {
+          var info = gen[key](arg);
+          var value = info.value;
+      } catch (error) {
+          reject(error);
+          return;
+      }
+      if (info.done) {
+          resolve(value);
+      } else {
+          Promise.resolve(value).then(_next, _throw);
+      }
+  }
+  function _async_to_generator$1(fn) {
+      return function() {
+          var self = this, args = arguments;
+          return new Promise(function(resolve, reject) {
+              var gen = fn.apply(self, args);
+              function _next(value) {
+                  asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "next", value);
+              }
+              function _throw(err) {
+                  asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "throw", err);
+              }
+              _next(undefined);
+          });
+      };
+  }
+  function _class_call_check(instance, Constructor) {
+      if (!(instance instanceof Constructor)) {
+          throw new TypeError("Cannot call a class as a function");
+      }
+  }
+  function _defineProperties(target, props) {
+      for(var i = 0; i < props.length; i++){
+          var descriptor = props[i];
+          descriptor.enumerable = descriptor.enumerable || false;
+          descriptor.configurable = true;
+          if ("value" in descriptor) descriptor.writable = true;
+          Object.defineProperty(target, descriptor.key, descriptor);
+      }
+  }
+  function _create_class(Constructor, protoProps, staticProps) {
+      if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+      if (staticProps) _defineProperties(Constructor, staticProps);
+      return Constructor;
+  }
+  function _define_property(obj, key, value) {
+      if (key in obj) {
+          Object.defineProperty(obj, key, {
+              value: value,
+              enumerable: true,
+              configurable: true,
+              writable: true
+          });
+      } else {
+          obj[key] = value;
+      }
+      return obj;
+  }
+  function _instanceof$1(left, right) {
+      if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+          return !!right[Symbol.hasInstance](left);
+      } else {
+          return left instanceof right;
+      }
+  }
+  function _iterable_to_array_limit(arr, i) {
+      var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+      if (_i == null) return;
+      var _arr = [];
+      var _n = true;
+      var _d = false;
+      var _s, _e;
+      try {
+          for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+              _arr.push(_s.value);
+              if (i && _arr.length === i) break;
+          }
+      } catch (err) {
+          _d = true;
+          _e = err;
+      } finally{
+          try {
+              if (!_n && _i["return"] != null) _i["return"]();
+          } finally{
+              if (_d) throw _e;
+          }
+      }
+      return _arr;
+  }
+  function _non_iterable_rest() {
+      throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  function _sliced_to_array(arr, i) {
+      return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+  }
+  function _unsupported_iterable_to_array(o, minLen) {
+      if (!o) return;
+      if (typeof o === "string") return _array_like_to_array(o, minLen);
+      var n = Object.prototype.toString.call(o).slice(8, -1);
+      if (n === "Object" && o.constructor) n = o.constructor.name;
+      if (n === "Map" || n === "Set") return Array.from(n);
+      if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+  }
+  function _ts_generator$1(thisArg, body) {
+      var f, y, t, g, _ = {
+          label: 0,
+          sent: function() {
+              if (t[0] & 1) throw t[1];
+              return t[1];
+          },
+          trys: [],
+          ops: []
+      };
+      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
+          };
+      }
+  }
+  var IndexedDBFileHelperAdapter = /*#__PURE__*/ function() {
+      function IndexedDBFileHelperAdapter(paths) {
+          _class_call_check(this, IndexedDBFileHelperAdapter);
+          _define_property(this, "indexedDBHelper", void 0);
+          _define_property(this, "initPromise", void 0);
+          _define_property(this, "isReady", false);
+          // Кэш для синхронных операций чтения
+          _define_property(this, "fileCache", new Map());
+          _define_property(this, "existsCache", new Map());
+          this.indexedDBHelper = new IndexedDBFileHelper(paths);
+          this.initPromise = this.initialize();
+      }
+      _create_class(IndexedDBFileHelperAdapter, [
+          {
+              key: "initialize",
+              value: function initialize() {
+                  var _this = this;
+                  return _async_to_generator$1(function() {
+                      var error;
+                      return _ts_generator$1(this, function(_state) {
+                          switch(_state.label){
+                              case 0:
+                                  _state.trys.push([
+                                      0,
+                                      2,
+                                      ,
+                                      3
+                                  ]);
+                                  return [
+                                      4,
+                                      _this.indexedDBHelper.createSubDirectoryInCacheCallback('init')
+                                  ];
+                              case 1:
+                                  _state.sent();
+                                  _this.isReady = true;
+                                  return [
+                                      3,
+                                      3
+                                  ];
+                              case 2:
+                                  error = _state.sent();
+                                  console.error('Failed to initialize IndexedDB FileHelper:', error);
+                                  throw error;
+                              case 3:
+                                  return [
+                                      2
+                                  ];
+                          }
+                      });
+                  })();
+              }
+          },
+          {
+              key: "waitForReady",
+              value: function waitForReady() {
+                  var _this = this;
+                  return _async_to_generator$1(function() {
+                      return _ts_generator$1(this, function(_state) {
+                          switch(_state.label){
+                              case 0:
+                                  return [
+                                      4,
+                                      _this.initPromise
+                                  ];
+                              case 1:
+                                  _state.sent();
+                                  return [
+                                      2
+                                  ];
+                          }
+                      });
+                  })();
+              }
+          },
+          {
+              key: "stringToArrayBuffer",
+              value: // Преобразование string в ArrayBuffer для бинарных данных
+              function stringToArrayBuffer(str) {
+                  // Предполагаем, что это base64 или бинарные данные как строка
+                  try {
+                      // Попробуем декодировать как base64
+                      var binaryString = atob(str);
+                      var bytes = new Uint8Array(binaryString.length);
+                      for(var i = 0; i < binaryString.length; i++){
+                          bytes[i] = binaryString.charCodeAt(i);
+                      }
+                      return bytes.buffer;
+                  } catch (e) {
+                      // Если не base64, конвертируем строку в UTF-8 байты
+                      var encoder = new TextEncoder();
+                      return encoder.encode(str).buffer;
+                  }
+              }
+          },
+          {
+              // Реализация старого синхронного интерфейса
+              key: "createSubDirectoryInCacheCallback",
+              value: function createSubDirectoryInCacheCallback(fileName) {
+                  var _this = this;
+                  if (!this.isReady) {
+                      console.warn('IndexedDB not ready yet, queuing operation');
+                      this.initPromise.then(function() {
+                          _this.indexedDBHelper.createSubDirectoryInCacheCallback(fileName);
+                      });
+                      return;
+                  }
+                  // Асинхронно выполняем операцию
+                  this.indexedDBHelper.createSubDirectoryInCacheCallback(fileName).catch(function(error) {
+                      console.error('Error creating subdirectory:', error);
+                  });
+              }
+          },
+          {
+              key: "fileExistsInCacheCallback",
+              value: function fileExistsInCacheCallback(path) {
+                  var _this = this;
+                  // console.log("fileExistsInCacheCallback " + path);
+                  var cacheKey = "".concat(path);
+                  if (this.existsCache.has(cacheKey)) {
+                      // console.log("cache hit for existsCache: " + cacheKey + " => " + this.existsCache.get(cacheKey));
+                      return this.existsCache.get(cacheKey);
+                  }
+                  // Если нет в кэше, проверяем IndexedDB
+                  if (this.isReady) {
+                      this.indexedDBHelper.fileExistsInCacheCallback(path).then(function(exists) {
+                          // console.log("DB for existsCache: " + cacheKey + " => " + this.existsCache.get(cacheKey));
+                          _this.existsCache.set(cacheKey, exists);
+                      }).catch(function(error) {
+                          console.error('Error checking file existence in cache:', error);
+                          _this.existsCache.set(cacheKey, false);
+                      });
+                  }
+                  // console.warn(`File ${path} not found in cache, returning false: this.isReady = ${this.isReady}`);
+                  return false;
+              }
+          },
+          {
+              key: "getUrlCachePathCallback",
+              value: function getUrlCachePathCallback(id, path) {
+                  if (!this.isReady) {
+                      console.warn('IndexedDB not ready yet, returning empty path');
+                      return;
+                  }
+                  // Возвращаем путь к кэшу
+                  this.indexedDBHelper.getUrlCachePathCallback(id, path);
+              }
+          },
+          {
+              key: "getCachePathCallback",
+              value: function getCachePathCallback(path) {
+                  if (!this.isReady) {
+                      console.warn('IndexedDB not ready yet, returning empty path');
+                      return '';
+                  }
+                  // Возвращаем путь к кэшу
+                  return this.indexedDBHelper.getCachePathCallback(path);
+              }
+          },
+          {
+              key: "getResourcesPathCallback",
+              value: function getResourcesPathCallback(path) {
+                  if (!this.isReady) {
+                      console.warn('IndexedDB not ready yet, returning empty path');
+                      return '';
+                  }
+                  // Возвращаем путь к ресурсам
+                  return this.indexedDBHelper.getResourcesPathCallback(path);
+              }
+          },
+          {
+              key: "fileExistsInResourcesCallback",
+              value: function fileExistsInResourcesCallback(path) {
+                  return false;
+              }
+          },
+          {
+              key: "saveFileInCacheCallback",
+              value: function saveFileInCacheCallback(fileName, data) {
+                  var _this = this;
+                  if (!this.isReady) {
+                      console.warn('IndexedDB not ready yet, queuing operation');
+                      this.initPromise.then(function() {
+                          _this.indexedDBHelper.saveFileInCacheCallback(fileName, data);
+                      });
+                      return;
+                  }
+                  this.fileCache.set(fileName, data);
+                  this.existsCache.set(fileName, true);
+                  // console.log("saveFileInCacheCallback... " + fileName + " data: " + data.length + " bytes == " + data);
+                  // Асинхронно сохраняем в IndexedDB
+                  this.indexedDBHelper.saveFileInCacheCallback(fileName, data).catch(function(error) {
+                      console.error('Error saving file to cache:', error);
+                      // Удаляем из кэша при ошибке
+                      _this.fileCache.delete(fileName);
+                      _this.existsCache.set(fileName, false);
+                  });
+              }
+          },
+          {
+              key: "saveFileInCacheBinaryCallback",
+              value: function saveFileInCacheBinaryCallback(fileName, memoryView) {
+                  var _this = this;
+                  // console.log('saveFileInCacheBinaryCallback... ' + fileName + ' data: ' + memoryView.length + ' bytes');
+                  if (!this.isReady) {
+                      console.warn('IndexedDB not ready yet, queuing operation');
+                      this.initPromise.then(function() {
+                          // memoryView уже Uint8Array, создаем копию для безопасности
+                          var dataCopy = new Uint8Array(memoryView);
+                          _this.indexedDBHelper.saveFileInCacheBinaryCallback(fileName, dataCopy.buffer);
+                      });
+                      return;
+                  }
+                  // Создаем копию данных для безопасности (так как memoryView может быть invalidated)
+                  var dataCopy = new Uint8Array(memoryView);
+                  var arrayBuffer = dataCopy.buffer.slice(dataCopy.byteOffset, dataCopy.byteOffset + dataCopy.byteLength);
+                  // Сохраняем как Uint8Array в память для быстрого доступа
+                  this.fileCache.set(fileName, dataCopy);
+                  this.existsCache.set(fileName, true);
+                  // console.log('=>DONE saveFileInCacheBinaryCallback... ' + fileName + ' data: ' + memoryView.length + ' bytes');
+                  // Асинхронно сохраняем в IndexedDB
+                  this.indexedDBHelper.saveFileInCacheBinaryCallback(fileName, arrayBuffer).then(function() {
+                  // console.log('ALL Saved!!');
+                  }).catch(function(error) {
+                      console.error('Error saving binary file to cache:', error);
+                      _this.fileCache.delete(fileName);
+                      _this.existsCache.set(fileName, false);
+                  });
+              }
+          },
+          {
+              key: "saveFileInResourcesCallback",
+              value: function saveFileInResourcesCallback(fileName, data) {
+                  var _this = this;
+                  if (!this.isReady) {
+                      console.warn('IndexedDB not ready yet, queuing operation');
+                      this.initPromise.then(function() {
+                          _this.indexedDBHelper.saveFileInResourcesCallback(fileName, data);
+                      });
+                      return;
+                  }
+                  var cacheKey = "resources/".concat(fileName);
+                  this.fileCache.set(cacheKey, data);
+                  this.existsCache.set(cacheKey, true);
+                  this.indexedDBHelper.saveFileInResourcesCallback(fileName, data).catch(function(error) {
+                      console.error('Error saving file to resources:', error);
+                      _this.fileCache.delete(cacheKey);
+                      _this.existsCache.set(cacheKey, false);
+                  });
+              }
+          },
+          {
+              key: "cleanUpResourcesFolderCallback",
+              value: function cleanUpResourcesFolderCallback() {
+                  var _this = this;
+                  if (!this.isReady) {
+                      console.warn('IndexedDB not ready yet, queuing operation');
+                      this.initPromise.then(function() {
+                          _this.indexedDBHelper.cleanUpResourcesFolderCallback();
+                      });
+                      return;
+                  }
+                  var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                  try {
+                      // Очищаем кэш ресурсов
+                      for(var _iterator = this.fileCache[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                          var _step_value = _sliced_to_array(_step.value, 1), key = _step_value[0];
+                          if (key.startsWith('resources/')) {
+                              this.fileCache.delete(key);
+                              this.existsCache.set(key, false);
+                          }
+                      }
+                  } catch (err) {
+                      _didIteratorError = true;
+                      _iteratorError = err;
+                  } finally{
+                      try {
+                          if (!_iteratorNormalCompletion && _iterator.return != null) {
+                              _iterator.return();
+                          }
+                      } finally{
+                          if (_didIteratorError) {
+                              throw _iteratorError;
+                          }
+                      }
+                  }
+                  this.indexedDBHelper.cleanUpResourcesFolderCallback().catch(function(error) {
+                      console.error('Error cleaning resources folder:', error);
+                  });
+              }
+          },
+          {
+              key: "cleanGeneratedCodeFolderCallback",
+              value: function cleanGeneratedCodeFolderCallback() {
+                  var _this = this;
+                  if (!this.isReady) {
+                      console.warn('IndexedDB not ready yet, queuing operation');
+                      this.initPromise.then(function() {
+                          _this.indexedDBHelper.cleanGeneratedCodeFolderCallback();
+                      });
+                      return;
+                  }
+                  this.indexedDBHelper.cleanGeneratedCodeFolderCallback().catch(function(error) {
+                      console.error('Error cleaning code folder:', error);
+                  });
+              }
+          },
+          {
+              key: "saveGeneratedCodeCallback",
+              value: function saveGeneratedCodeCallback(fileName, data) {
+                  var _this = this;
+                  if (!this.isReady) {
+                      console.warn('IndexedDB not ready yet, queuing operation');
+                      this.initPromise.then(function() {
+                          _this.indexedDBHelper.saveGeneratedCodeCallback(fileName, data);
+                      });
+                      return;
+                  }
+                  this.indexedDBHelper.saveGeneratedCodeCallback(fileName, data).catch(function(error) {
+                      console.error('Error saving generated code:', error);
+                  });
+              }
+          },
+          {
+              key: "loadFileFromCacheCallback",
+              value: function loadFileFromCacheCallback(fileName) {
+                  var _this = this;
+                  var directory = this.indexedDBHelper.getCachedDirectory();
+                  if (fileName.startsWith(directory)) fileName = fileName.substring(directory.length + 1); // Убираем префикс директории
+                  if (this.fileCache.has(fileName)) {
+                      var cachedData = this.fileCache.get(fileName);
+                      // Если это бинарные данные (Uint8Array), конвертируем в строку
+                      if (_instanceof$1(cachedData, Uint8Array)) {
+                          return new TextDecoder().decode(cachedData);
+                      }
+                      // Если это строка, возвращаем как есть
+                      return cachedData;
+                  }
+                  // Если нет в кэше и IndexedDB готов, пытаемся загрузить асинхронно
+                  if (this.isReady) {
+                      // Запускаем асинхронную загрузку для будущих вызовов
+                      this.indexedDBHelper.loadFileFromCacheCallback(fileName).then(function(data) {
+                          if (data) {
+                              _this.fileCache.set(fileName, data);
+                              _this.existsCache.set(fileName, true);
+                          }
+                      }).catch(function(error) {
+                          console.error('Error loading file from cache:', error);
+                          _this.existsCache.set(fileName, false);
+                      });
+                  }
+                  // console.warn(`File ${fileName} not found in cache, returning empty string`);
+                  return '';
+              }
+          },
+          {
+              key: "loadFileFromResourcesCallback",
+              value: function loadFileFromResourcesCallback(fileName) {
+                  var _this = this;
+                  var cacheKey = "resources/".concat(fileName);
+                  if (this.fileCache.has(cacheKey)) {
+                      var cachedData = this.fileCache.get(cacheKey);
+                      // Если это бинарные данные (Uint8Array), конвертируем в строку
+                      if (_instanceof$1(cachedData, Uint8Array)) {
+                          return new TextDecoder().decode(cachedData);
+                      }
+                      // Если это строка, возвращаем как есть
+                      return cachedData;
+                  }
+                  if (this.isReady) {
+                      this.indexedDBHelper.loadFileFromResourcesCallback(fileName).then(function(data) {
+                          if (data) {
+                              _this.fileCache.set(cacheKey, data);
+                              _this.existsCache.set(cacheKey, true);
+                          }
+                      }).catch(function(error) {
+                          console.error('Error loading file from resources:', error);
+                          _this.existsCache.set(cacheKey, false);
+                      });
+                  }
+                  // console.warn(`Resource ${fileName} not found in cache, returning empty string`);
+                  return '';
+              }
+          },
+          {
+              key: "deleteCachedFolderCallback",
+              value: function deleteCachedFolderCallback(path) {
+                  var _this = this;
+                  if (!this.isReady) {
+                      console.warn('IndexedDB not ready yet, queuing operation');
+                      this.initPromise.then(function() {
+                          _this.indexedDBHelper.deleteCachedFolderCallback(path);
+                      });
+                      return;
+                  }
+                  var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                  try {
+                      // Очищаем кэш для этой папки
+                      for(var _iterator = this.fileCache[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                          var _step_value = _sliced_to_array(_step.value, 1), key = _step_value[0];
+                          if (key.startsWith(path)) {
+                              this.fileCache.delete(key);
+                              this.existsCache.set(key, false);
+                          }
+                      }
+                  } catch (err) {
+                      _didIteratorError = true;
+                      _iteratorError = err;
+                  } finally{
+                      try {
+                          if (!_iteratorNormalCompletion && _iterator.return != null) {
+                              _iterator.return();
+                          }
+                      } finally{
+                          if (_didIteratorError) {
+                              throw _iteratorError;
+                          }
+                      }
+                  }
+                  this.indexedDBHelper.deleteCachedFolderCallback(path).catch(function(error) {
+                      console.error('Error deleting cached folder:', error);
+                  });
+              }
+          },
+          {
+              key: "deleteCachedFileCallback",
+              value: function deleteCachedFileCallback(path) {
+                  var _this = this;
+                  if (!this.isReady) {
+                      console.warn('IndexedDB not ready yet, queuing operation');
+                      this.initPromise.then(function() {
+                          _this.indexedDBHelper.deleteCachedFileCallback(path);
+                      });
+                      return;
+                  }
+                  this.fileCache.delete(path);
+                  this.existsCache.set(path, false);
+                  this.indexedDBHelper.deleteCachedFileCallback(path).catch(function(error) {
+                      console.error('Error deleting cached file:', error);
+                  });
+              }
+          },
+          {
+              key: "getFilesInCachedFolderCallback",
+              value: function getFilesInCachedFolderCallback(path) {
+                  var _this = this;
+                  if (!this.isReady) {
+                      console.warn('IndexedDB not ready yet, returning empty array');
+                      return [];
+                  }
+                  // Пытаемся получить из кэша
+                  var cachedFiles = [];
+                  var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                  try {
+                      for(var _iterator = this.fileCache[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                          var _step_value = _sliced_to_array(_step.value, 1), key = _step_value[0];
+                          if (key.startsWith(path)) {
+                              var fileName = key.substring(path.length + 1);
+                              cachedFiles.push(fileName);
+                          }
+                      }
+                  } catch (err) {
+                      _didIteratorError = true;
+                      _iteratorError = err;
+                  } finally{
+                      try {
+                          if (!_iteratorNormalCompletion && _iterator.return != null) {
+                              _iterator.return();
+                          }
+                      } finally{
+                          if (_didIteratorError) {
+                              throw _iteratorError;
+                          }
+                      }
+                  }
+                  // Асинхронно обновляем кэш
+                  this.indexedDBHelper.getFilesInCachedFolderCallback(path).then(function(files) {
+                      // Обновляем информацию о существующих файлах
+                      files.forEach(function(fileName) {
+                          var cacheKey = "".concat(path, "/").concat(fileName);
+                          _this.existsCache.set(cacheKey, true);
+                      });
+                  }).catch(function(error) {
+                      console.error('Error getting files in cached folder:', error);
+                  });
+                  return cachedFiles;
+              }
+          },
+          {
+              key: "applyTempFolderCallback",
+              value: function applyTempFolderCallback(tempFolder) {
+                  var _this = this;
+                  if (!this.isReady) {
+                      console.warn('IndexedDB not ready yet, queuing operation');
+                      this.initPromise.then(function() {
+                          _this.indexedDBHelper.applyTempFolderCallback(tempFolder);
+                      });
+                      return;
+                  }
+                  this.indexedDBHelper.applyTempFolderCallback(tempFolder).catch(function(error) {
+                      console.error('Error applying temp folder:', error);
+                  });
+              }
+          },
+          {
+              key: "preloadCache",
+              value: function preloadCache() {
+                  var _this = this;
+                  return _async_to_generator$1(function() {
+                      var cacheFiles, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, fileName, data, error, err, error1;
+                      return _ts_generator$1(this, function(_state) {
+                          switch(_state.label){
+                              case 0:
+                                  return [
+                                      4,
+                                      _this.waitForReady()
+                                  ];
+                              case 1:
+                                  _state.sent();
+                                  _state.label = 2;
+                              case 2:
+                                  _state.trys.push([
+                                      2,
+                                      14,
+                                      ,
+                                      15
+                                  ]);
+                                  return [
+                                      4,
+                                      _this.indexedDBHelper.getFilesInCachedFolderCallback('')
+                                  ];
+                              case 3:
+                                  cacheFiles = _state.sent();
+                                  _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                  _state.label = 4;
+                              case 4:
+                                  _state.trys.push([
+                                      4,
+                                      11,
+                                      12,
+                                      13
+                                  ]);
+                                  _iterator = cacheFiles[Symbol.iterator]();
+                                  _state.label = 5;
+                              case 5:
+                                  if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                                      3,
+                                      10
+                                  ];
+                                  fileName = _step.value;
+                                  _state.label = 6;
+                              case 6:
+                                  _state.trys.push([
+                                      6,
+                                      8,
+                                      ,
+                                      9
+                                  ]);
+                                  return [
+                                      4,
+                                      _this.indexedDBHelper.loadFileFromCacheCallback(fileName)
+                                  ];
+                              case 7:
+                                  data = _state.sent();
+                                  if (data) {
+                                      _this.fileCache.set(fileName, data);
+                                      _this.existsCache.set(fileName, true);
+                                  }
+                                  return [
+                                      3,
+                                      9
+                                  ];
+                              case 8:
+                                  error = _state.sent();
+                                  console.error("Error preloading file ".concat(fileName, ":"), error);
+                                  return [
+                                      3,
+                                      9
+                                  ];
+                              case 9:
+                                  _iteratorNormalCompletion = true;
+                                  return [
+                                      3,
+                                      5
+                                  ];
+                              case 10:
+                                  return [
+                                      3,
+                                      13
+                                  ];
+                              case 11:
+                                  err = _state.sent();
+                                  _didIteratorError = true;
+                                  _iteratorError = err;
+                                  return [
+                                      3,
+                                      13
+                                  ];
+                              case 12:
+                                  try {
+                                      if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                          _iterator.return();
+                                      }
+                                  } finally{
+                                      if (_didIteratorError) {
+                                          throw _iteratorError;
+                                      }
+                                  }
+                                  return [
+                                      7
+                                  ];
+                              case 13:
+                                  console.log("Preloaded ".concat(cacheFiles.length, " files into memory cache"));
+                                  return [
+                                      3,
+                                      15
+                                  ];
+                              case 14:
+                                  error1 = _state.sent();
+                                  console.error('Error during cache preload:', error1);
+                                  return [
+                                      3,
+                                      15
+                                  ];
+                              case 15:
+                                  return [
+                                      2
+                                  ];
+                          }
+                      });
+                  })();
+              }
+          },
+          {
+              key: "preloadEverything",
+              value: function preloadEverything() {
+                  var _this = this;
+                  return _async_to_generator$1(function() {
+                      var totalFiles, totalSize, allFiles, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, fileInfo, data, cacheKey, uint8Array, error, err, sampleKeys, error1;
+                      return _ts_generator$1(this, function(_state) {
+                          switch(_state.label){
+                              case 0:
+                                  return [
+                                      4,
+                                      _this.waitForReady()
+                                  ];
+                              case 1:
+                                  _state.sent();
+                                  console.log('🚀 Starting full preload of all files...');
+                                  totalFiles = 0;
+                                  totalSize = 0;
+                                  _state.label = 2;
+                              case 2:
+                                  _state.trys.push([
+                                      2,
+                                      14,
+                                      ,
+                                      15
+                                  ]);
+                                  return [
+                                      4,
+                                      _this.getAllFilesFromIndexedDB()
+                                  ];
+                              case 3:
+                                  allFiles = _state.sent();
+                                  console.log('🗂️ All files in IndexedDB:', allFiles.length);
+                                  _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                  _state.label = 4;
+                              case 4:
+                                  _state.trys.push([
+                                      4,
+                                      11,
+                                      12,
+                                      13
+                                  ]);
+                                  _iterator = allFiles[Symbol.iterator]();
+                                  _state.label = 5;
+                              case 5:
+                                  if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                                      3,
+                                      10
+                                  ];
+                                  fileInfo = _step.value;
+                                  _state.label = 6;
+                              case 6:
+                                  _state.trys.push([
+                                      6,
+                                      8,
+                                      ,
+                                      9
+                                  ]);
+                                  data = null;
+                                  cacheKey = '';
+                                  return [
+                                      4,
+                                      _this.indexedDBHelper.loadFile(fileInfo.directory, fileInfo.fileName)
+                                  ];
+                              case 7:
+                                  // Определяем как загружать файл в зависимости от директории
+                                  // if (fileInfo.directory.includes('cache') || fileInfo.directory === '.balancy') {
+                                  //   data = await this.indexedDBHelper.loadFileFromCacheCallback(fileInfo.fileName);
+                                  //   console.log("*** " + fileInfo.fileName + " :: " + data.length + " == " + data);
+                                  //   cacheKey = `${fileInfo.fileName}`;
+                                  // } else if (fileInfo.directory.includes('resources')) {
+                                  //   data = await this.indexedDBHelper.loadFileFromResourcesCallback(fileInfo.fileName);
+                                  //   cacheKey = `resources/${fileInfo.fileName}`;
+                                  // } else {
+                                  // Используем общий метод loadFile для всех остальных директорий
+                                  data = _state.sent();
+                                  cacheKey = fileInfo.fileName;
+                                  // }
+                                  if (data) {
+                                      // Для ВСЕХ файлов (включая бинарные) сохраняем как есть
+                                      if (_instanceof$1(data, ArrayBuffer)) {
+                                          // Сохраняем бинарные данные как Uint8Array для прямого доступа
+                                          uint8Array = new Uint8Array(data);
+                                          _this.fileCache.set(cacheKey, uint8Array);
+                                          totalSize += uint8Array.byteLength;
+                                      // console.log(`✅ Loaded BINARY: ${cacheKey} (${uint8Array.byteLength} bytes)`);
+                                      } else {
+                                          // Текстовые файлы сохраняем как строки
+                                          _this.fileCache.set(cacheKey, data);
+                                          totalSize += data.length;
+                                      // console.log(`✅ Loaded TEXT: ${cacheKey} (${data.length} chars)`);
+                                      }
+                                      _this.existsCache.set(cacheKey, true);
+                                      totalFiles++;
+                                  }
+                                  return [
+                                      3,
+                                      9
+                                  ];
+                              case 8:
+                                  error = _state.sent();
+                                  console.error("❌ Error preloading file ".concat(fileInfo.directory, "/").concat(fileInfo.fileName, ":"), error);
+                                  return [
+                                      3,
+                                      9
+                                  ];
+                              case 9:
+                                  _iteratorNormalCompletion = true;
+                                  return [
+                                      3,
+                                      5
+                                  ];
+                              case 10:
+                                  return [
+                                      3,
+                                      13
+                                  ];
+                              case 11:
+                                  err = _state.sent();
+                                  _didIteratorError = true;
+                                  _iteratorError = err;
+                                  return [
+                                      3,
+                                      13
+                                  ];
+                              case 12:
+                                  try {
+                                      if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                          _iterator.return();
+                                      }
+                                  } finally{
+                                      if (_didIteratorError) {
+                                          throw _iteratorError;
+                                      }
+                                  }
+                                  return [
+                                      7
+                                  ];
+                              case 13:
+                                  console.log("✅ Full preload completed: ".concat(totalFiles, " files (").concat(_this.formatBytes(totalSize), ") loaded into memory"));
+                                  console.log("\uD83D\uDCCA Memory cache size: ".concat(_this.fileCache.size, " files, exists cache: ").concat(_this.existsCache.size, " entries"));
+                                  // Показываем примеры ключей в кэше
+                                  sampleKeys = Array.from(_this.fileCache.keys()).slice(0, 5);
+                                  console.log('🔍 Sample cached keys:', sampleKeys);
+                                  return [
+                                      3,
+                                      15
+                                  ];
+                              case 14:
+                                  error1 = _state.sent();
+                                  console.error('❌ Error during full preload:', error1);
+                                  throw error1;
+                              case 15:
+                                  return [
+                                      2
+                                  ];
+                          }
+                      });
+                  })();
+              }
+          },
+          {
+              key: "getAllFilesFromIndexedDB",
+              value: function getAllFilesFromIndexedDB() {
+                  var _this = this;
+                  return _async_to_generator$1(function() {
+                      var db;
+                      return _ts_generator$1(this, function(_state) {
+                          switch(_state.label){
+                              case 0:
+                                  return [
+                                      4,
+                                      _this.waitForReady()
+                                  ];
+                              case 1:
+                                  _state.sent();
+                                  db = _this.indexedDBHelper.getDatabase();
+                                  if (!db) {
+                                      console.warn('Database not available for file enumeration');
+                                      return [
+                                          2,
+                                          []
+                                      ];
+                                  }
+                                  return [
+                                      2,
+                                      new Promise(function(resolve, reject) {
+                                          var transaction = db.transaction([
+                                              'files'
+                                          ], 'readonly');
+                                          var store = transaction.objectStore('files');
+                                          var files = [];
+                                          var request = store.openCursor();
+                                          request.onsuccess = function(event) {
+                                              var target = event.target;
+                                              var cursor = target.result;
+                                              if (cursor) {
+                                                  var record = cursor.value;
+                                                  record.fileName.split('/');
+                                                  files.push({
+                                                      // fileName: record.fileName.split('/').pop() || record.fileName,
+                                                      fileName: record.fileName.substring(record.directory.length + 1),
+                                                      directory: record.directory,
+                                                      fileType: record.fileType || 'text'
+                                                  });
+                                                  cursor.continue();
+                                              } else {
+                                                  resolve(files);
+                                              }
+                                          };
+                                          request.onerror = function() {
+                                              console.error('Error reading files from IndexedDB');
+                                              reject(request.error);
+                                          };
+                                      })
+                                  ];
+                          }
+                      });
+                  })();
+              }
+          },
+          {
+              key: "arrayBufferToBase64",
+              value: function arrayBufferToBase64(buffer) {
+                  var bytes = new Uint8Array(buffer);
+                  var binary = '';
+                  for(var i = 0; i < bytes.byteLength; i++){
+                      binary += String.fromCharCode(bytes[i]);
+                  }
+                  return btoa(binary);
+              }
+          },
+          {
+              key: "formatBytes",
+              value: function formatBytes(bytes) {
+                  if (bytes === 0) return '0 Bytes';
+                  var k = 1024;
+                  var sizes = [
+                      'Bytes',
+                      'KB',
+                      'MB',
+                      'GB'
+                  ];
+                  var i = Math.floor(Math.log(bytes) / Math.log(k));
+                  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+              }
+          },
+          {
+              key: "getCacheStats",
+              value: function getCacheStats() {
+                  var totalSize = 0;
+                  var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                  try {
+                      for(var _iterator = this.fileCache[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                          var _step_value = _sliced_to_array(_step.value, 2), data = _step_value[1];
+                          if (typeof data === 'string') {
+                              totalSize += data.length;
+                          } else if (_instanceof$1(data, Uint8Array)) {
+                              totalSize += data.byteLength;
+                          }
+                      }
+                  } catch (err) {
+                      _didIteratorError = true;
+                      _iteratorError = err;
+                  } finally{
+                      try {
+                          if (!_iteratorNormalCompletion && _iterator.return != null) {
+                              _iterator.return();
+                          }
+                      } finally{
+                          if (_didIteratorError) {
+                              throw _iteratorError;
+                          }
+                      }
+                  }
+                  return {
+                      fileCount: this.fileCache.size,
+                      memoryUsage: this.formatBytes(totalSize)
+                  };
+              }
+          },
+          {
+              key: "clearMemoryCache",
+              value: function clearMemoryCache() {
+                  this.fileCache.clear();
+                  this.existsCache.clear();
+                  console.log('Memory cache cleared');
+              }
+          },
+          {
+              key: "close",
+              value: function close() {
+                  this.fileCache.clear();
+                  this.existsCache.clear();
+                  this.indexedDBHelper.close();
+              }
+          },
+          {
+              key: "loadFile",
+              value: function loadFile(directory, fileName) {
+                  var _this = this;
+                  return _async_to_generator$1(function() {
+                      return _ts_generator$1(this, function(_state) {
+                          switch(_state.label){
+                              case 0:
+                                  return [
+                                      4,
+                                      _this.indexedDBHelper.loadFile(directory, fileName)
+                                  ];
+                              case 1:
+                                  return [
+                                      2,
+                                      _state.sent()
+                                  ];
+                          }
+                      });
+                  })();
+              }
+          },
+          {
+              key: "getIndexedDBHelper",
+              value: function getIndexedDBHelper() {
+                  return this.indexedDBHelper;
+              }
+          },
+          {
+              key: "setSpriteLoader",
+              value: function setSpriteLoader(loader) {
+                  this.indexedDBHelper.setSpriteLoader(loader);
+              }
+          },
+          {
+              key: "getBinaryFile",
+              value: function getBinaryFile(key) {
+                  var _this = this;
+                  return _async_to_generator$1(function() {
+                      var cacheKey, cachedData, data, binaryData, error;
+                      return _ts_generator$1(this, function(_state) {
+                          switch(_state.label){
+                              case 0:
+                                  // console.log("==>> getBinaryFile:", key);
+                                  return [
+                                      4,
+                                      _this.waitForReady()
+                                  ];
+                              case 1:
+                                  _state.sent();
+                                  // Проверяем кэш в памяти
+                                  cacheKey = "".concat(key);
+                                  if (_this.fileCache.has(cacheKey)) {
+                                      cachedData = _this.fileCache.get(cacheKey);
+                                      // console.log("==>> Found in memory cache");
+                                      if (_instanceof$1(cachedData, Uint8Array)) {
+                                          return [
+                                              2,
+                                              cachedData
+                                          ];
+                                      } else if (typeof cachedData === 'string') {
+                                          // Попытка декодировать base64
+                                          try {
+                                              return [
+                                                  2,
+                                                  _this.base64ToUint8Array(cachedData)
+                                              ];
+                                          } catch (error) {
+                                              console.warn('Failed to decode base64, trying as text:', error);
+                                              return [
+                                                  2,
+                                                  new TextEncoder().encode(cachedData)
+                                              ];
+                                          }
+                                      }
+                                  }
+                                  _state.label = 2;
+                              case 2:
+                                  _state.trys.push([
+                                      2,
+                                      4,
+                                      ,
+                                      5
+                                  ]);
+                                  return [
+                                      4,
+                                      _this.indexedDBHelper.loadFile('.balancy', key)
+                                  ];
+                              case 3:
+                                  data = _state.sent();
+                                  if (data) {
+                                      if (_instanceof$1(data, ArrayBuffer)) {
+                                          binaryData = new Uint8Array(data);
+                                      } else {
+                                          // Если это строка, пробуем декодировать как base64
+                                          try {
+                                              binaryData = _this.base64ToUint8Array(data);
+                                          } catch (e) {
+                                              binaryData = new TextEncoder().encode(data);
+                                          }
+                                      }
+                                      // Кэшируем для будущих вызов
+                                      _this.fileCache.set(cacheKey, binaryData);
+                                      _this.existsCache.set(cacheKey, true);
+                                      // console.log("==>> Successfully loaded binary data:", binaryData.length, "bytes");
+                                      return [
+                                          2,
+                                          binaryData
+                                      ];
+                                  }
+                                  return [
+                                      3,
+                                      5
+                                  ];
+                              case 4:
+                                  error = _state.sent();
+                                  console.error('Error loading binary file:', error);
+                                  return [
+                                      3,
+                                      5
+                                  ];
+                              case 5:
+                                  console.log("==>> Binary file not found");
+                                  return [
+                                      2,
+                                      null
+                                  ];
+                          }
+                      });
+                  })();
+              }
+          },
+          {
+              key: "base64ToUint8Array",
+              value: function base64ToUint8Array(base64) {
+                  var binaryString = atob(base64);
+                  var bytes = new Uint8Array(binaryString.length);
+                  for(var i = 0; i < binaryString.length; i++){
+                      bytes[i] = binaryString.charCodeAt(i);
+                  }
+                  return bytes;
+              }
+          },
+          {
+              key: "saveBinaryFile",
+              value: function saveBinaryFile(key, data) {
+                  var _this = this;
+                  return _async_to_generator$1(function() {
+                      var cacheKey, arrayBuffer, error;
+                      return _ts_generator$1(this, function(_state) {
+                          switch(_state.label){
+                              case 0:
+                                  _state.trys.push([
+                                      0,
+                                      3,
+                                      ,
+                                      4
+                                  ]);
+                                  return [
+                                      4,
+                                      _this.waitForReady()
+                                  ];
+                              case 1:
+                                  _state.sent();
+                                  // Кэшируем в памяти
+                                  cacheKey = "".concat(key);
+                                  _this.fileCache.set(cacheKey, new Uint8Array(data)); // Создаем копию
+                                  _this.existsCache.set(cacheKey, true);
+                                  // console.log("Saving:: " + key);
+                                  // Сохраняем в IndexedDB
+                                  arrayBuffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+                                  return [
+                                      4,
+                                      _this.indexedDBHelper.saveFileInCacheBinaryCallback(key, arrayBuffer)
+                                  ];
+                              case 2:
+                                  _state.sent();
+                                  return [
+                                      2,
+                                      true
+                                  ];
+                              case 3:
+                                  error = _state.sent();
+                                  console.error('Error saving binary file:', error);
+                                  return [
+                                      2,
+                                      false
+                                  ];
+                              case 4:
+                                  return [
+                                      2
+                                  ];
+                          }
+                      });
+                  })();
+              }
+          },
+          {
+              key: "hasFile",
+              value: function hasFile(key) {
+                  var _this = this;
+                  return _async_to_generator$1(function() {
+                      var cacheKey, exists, error;
+                      return _ts_generator$1(this, function(_state) {
+                          switch(_state.label){
+                              case 0:
+                                  cacheKey = "".concat(key);
+                                  // Проверяем кэш в памяти
+                                  if (_this.existsCache.has(cacheKey)) {
+                                      return [
+                                          2,
+                                          _this.existsCache.get(cacheKey)
+                                      ];
+                                  }
+                                  if (!_this.isReady) return [
+                                      3,
+                                      4
+                                  ];
+                                  _state.label = 1;
+                              case 1:
+                                  _state.trys.push([
+                                      1,
+                                      3,
+                                      ,
+                                      4
+                                  ]);
+                                  return [
+                                      4,
+                                      _this.indexedDBHelper.fileExistsInCacheCallback(key)
+                                  ];
+                              case 2:
+                                  exists = _state.sent();
+                                  _this.existsCache.set(cacheKey, exists);
+                                  return [
+                                      2,
+                                      exists
+                                  ];
+                              case 3:
+                                  error = _state.sent();
+                                  console.error('Error checking file existence:', error);
+                                  return [
+                                      2,
+                                      false
+                                  ];
+                              case 4:
+                                  return [
+                                      2,
+                                      false
+                                  ];
+                          }
+                      });
+                  })();
+              }
+          },
+          {
+              key: "deleteFile",
+              value: function deleteFile(key) {
+                  var _this = this;
+                  return _async_to_generator$1(function() {
+                      var cacheKey, error;
+                      return _ts_generator$1(this, function(_state) {
+                          switch(_state.label){
+                              case 0:
+                                  _state.trys.push([
+                                      0,
+                                      3,
+                                      ,
+                                      4
+                                  ]);
+                                  return [
+                                      4,
+                                      _this.waitForReady()
+                                  ];
+                              case 1:
+                                  _state.sent();
+                                  cacheKey = "".concat(key);
+                                  _this.fileCache.delete(cacheKey);
+                                  _this.existsCache.set(cacheKey, false);
+                                  return [
+                                      4,
+                                      _this.indexedDBHelper.deleteCachedFileCallback(key)
+                                  ];
+                              case 2:
+                                  _state.sent();
+                                  return [
+                                      2,
+                                      true
+                                  ];
+                              case 3:
+                                  error = _state.sent();
+                                  console.error('Error deleting file:', error);
+                                  return [
+                                      2,
+                                      false
+                                  ];
+                              case 4:
+                                  return [
+                                      2
+                                  ];
+                          }
+                      });
+                  })();
+              }
+          },
+          {
+              key: "clearCache",
+              value: function clearCache() {
+                  var _this = this;
+                  return _async_to_generator$1(function() {
+                      var error;
+                      return _ts_generator$1(this, function(_state) {
+                          switch(_state.label){
+                              case 0:
+                                  _state.trys.push([
+                                      0,
+                                      2,
+                                      ,
+                                      3
+                                  ]);
+                                  return [
+                                      4,
+                                      _this.waitForReady()
+                                  ];
+                              case 1:
+                                  _state.sent();
+                                  // Очищаем кэш в памяти
+                                  _this.fileCache.clear();
+                                  _this.existsCache.clear();
+                                  // Очищаем IndexedDB (здесь нужно добавить метод в IndexedDBFileHelper)
+                                  // Пока просто очищаем кэш в памяти
+                                  return [
+                                      2,
+                                      true
+                                  ];
+                              case 2:
+                                  error = _state.sent();
+                                  console.error('Error clearing cache:', error);
+                                  return [
+                                      2,
+                                      false
+                                  ];
+                              case 3:
+                                  return [
+                                      2
+                                  ];
+                          }
+                      });
+                  })();
+              }
+          }
+      ], [
+          {
+              key: "create",
+              value: function create(paths) {
+                  var fullPreload = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
+                  return _async_to_generator$1(function() {
+                      var adapter;
+                      return _ts_generator$1(this, function(_state) {
+                          switch(_state.label){
+                              case 0:
+                                  adapter = new IndexedDBFileHelperAdapter(paths);
+                                  return [
+                                      4,
+                                      adapter.waitForReady()
+                                  ];
+                              case 1:
+                                  _state.sent();
+                                  if (!fullPreload) return [
+                                      3,
+                                      3
+                                  ];
+                                  return [
+                                      4,
+                                      adapter.preloadEverything()
+                                  ];
+                              case 2:
+                                  _state.sent(); // ПОЛНАЯ предзагрузка
+                                  _state.label = 3;
+                              case 3:
+                                  return [
+                                      2,
+                                      adapter
+                                  ];
+                          }
+                      });
+                  })();
+              }
+          },
+          {
+              key: "createFast",
+              value: function createFast(paths) {
+                  return _async_to_generator$1(function() {
+                      return _ts_generator$1(this, function(_state) {
+                          switch(_state.label){
+                              case 0:
+                                  return [
+                                      4,
+                                      IndexedDBFileHelperAdapter.create(paths, false)
+                                  ];
+                              case 1:
+                                  return [
+                                      2,
+                                      _state.sent()
+                                  ];
+                          }
+                      });
+                  })();
+              }
+          },
+          {
+              key: "createWithPartialPreload",
+              value: function createWithPartialPreload(paths) {
+                  return _async_to_generator$1(function() {
+                      var adapter;
+                      return _ts_generator$1(this, function(_state) {
+                          switch(_state.label){
+                              case 0:
+                                  adapter = new IndexedDBFileHelperAdapter(paths);
+                                  return [
+                                      4,
+                                      adapter.waitForReady()
+                                  ];
+                              case 1:
+                                  _state.sent();
+                                  return [
+                                      4,
+                                      adapter.preloadCache()
+                                  ];
+                              case 2:
+                                  _state.sent(); // Только cache, не все
+                                  return [
+                                      2,
+                                      adapter
+                                  ];
+                          }
+                      });
+                  })();
+              }
+          }
+      ]);
+      return IndexedDBFileHelperAdapter;
+  }();
+
+  // @balancy/utils - Utility functions and helpers for Balancy
+  // ============================================
+  // IndexedDB File Helper (основной функционал)
+  // ============================================
+  function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+      try {
+          var info = gen[key](arg);
+          var value = info.value;
+      } catch (error) {
+          reject(error);
+          return;
+      }
+      if (info.done) {
+          resolve(value);
+      } else {
+          Promise.resolve(value).then(_next, _throw);
+      }
+  }
+  function _async_to_generator(fn) {
+      return function() {
+          var self = this, args = arguments;
+          return new Promise(function(resolve, reject) {
+              var gen = fn.apply(self, args);
+              function _next(value) {
+                  asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+              }
+              function _throw(err) {
+                  asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+              }
+              _next(undefined);
+          });
+      };
+  }
+  function _instanceof(left, right) {
+      if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+          return !!right[Symbol.hasInstance](left);
+      } else {
+          return left instanceof right;
+      }
+  }
+  function _type_of(obj) {
+      "@swc/helpers - typeof";
+      return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+  }
+  function _ts_generator(thisArg, body) {
+      var f, y, t, g, _ = {
+          label: 0,
+          sent: function() {
+              if (t[0] & 1) throw t[1];
+              return t[1];
+          },
+          trys: [],
+          ops: []
+      };
+      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
+          };
+      }
+  }
+  // ============================================
+  // General Utility Functions
+  // ============================================
+  /**
+   * Проверяет, является ли значение пустым (null, undefined, пустая строка, пустой массив, пустой объект)
+   */ function isEmpty(value) {
+      if (value == null) return true;
+      if (typeof value === 'string') return value.trim().length === 0;
+      if (Array.isArray(value)) return value.length === 0;
+      if ((typeof value === "undefined" ? "undefined" : _type_of(value)) === 'object') return Object.keys(value).length === 0;
+      return false;
+  }
+  /**
+   * Глубокое клонирование объекта
+   */ function deepClone(obj) {
+      if (obj === null || (typeof obj === "undefined" ? "undefined" : _type_of(obj)) !== 'object') return obj;
+      if (_instanceof(obj, Date)) return new Date(obj.getTime());
+      if (_instanceof(obj, Array)) {
+          return obj.map(function(item) {
+              return deepClone(item);
+          });
+      }
+      if ((typeof obj === "undefined" ? "undefined" : _type_of(obj)) === 'object') {
+          var copy = {};
+          Object.keys(obj).forEach(function(key) {
+              copy[key] = deepClone(obj[key]);
+          });
+          return copy;
+      }
+      return obj;
+  }
+  /**
+   * Форматирование чисел с разделителями тысяч
+   */ function formatNumber(num) {
+      var locale = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 'en-US';
+      return new Intl.NumberFormat(locale).format(num);
+  }
+  /**
+   * Генерация случайного ID
+   */ function generateId() {
+      var length = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 8;
+      var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+      var result = '';
+      for(var i = 0; i < length; i++){
+          result += chars.charAt(Math.floor(Math.random() * chars.length));
+      }
+      return result;
+  }
+  /**
+   * Задержка выполнения (Promise-based sleep)
+   */ function delay(ms) {
+      return new Promise(function(resolve) {
+          return setTimeout(resolve, ms);
+      });
+  }
+  /**
+   * Retry функция с экспоненциальной задержкой
+   */ function retry(fn) {
+      return _retry.apply(this, arguments);
+  }
+  function _retry() {
+      _retry = _async_to_generator(function(fn) {
+          var maxAttempts, baseDelay, attempt, error, delayMs;
+          var _arguments = arguments;
+          return _ts_generator(this, function(_state) {
+              switch(_state.label){
+                  case 0:
+                      maxAttempts = _arguments.length > 1 && _arguments[1] !== void 0 ? _arguments[1] : 3, baseDelay = _arguments.length > 2 && _arguments[2] !== void 0 ? _arguments[2] : 1000;
+                      attempt = 0;
+                      _state.label = 1;
+                  case 1:
+                      if (!(attempt < maxAttempts)) return [
+                          3,
+                          7
+                      ];
+                      _state.label = 2;
+                  case 2:
+                      _state.trys.push([
+                          2,
+                          4,
+                          ,
+                          6
+                      ]);
+                      return [
+                          4,
+                          fn()
+                      ];
+                  case 3:
+                      return [
+                          2,
+                          _state.sent()
+                      ];
+                  case 4:
+                      error = _state.sent();
+                      attempt++;
+                      if (attempt >= maxAttempts) {
+                          throw error;
+                      }
+                      delayMs = baseDelay * Math.pow(2, attempt - 1);
+                      return [
+                          4,
+                          delay(delayMs)
+                      ];
+                  case 5:
+                      _state.sent();
+                      return [
+                          3,
+                          6
+                      ];
+                  case 6:
+                      return [
+                          3,
+                          1
+                      ];
+                  case 7:
+                      throw new Error('Max attempts reached');
+              }
+          });
+      });
+      return _retry.apply(this, arguments);
+  }
+  // Версия пакета
+  var VERSION = '1.0.0-rc.24';
+
+  exports.IndexedDBFileHelper = IndexedDBFileHelper;
+  exports.IndexedDBFileHelperAdapter = IndexedDBFileHelperAdapter;
+  exports.VERSION = VERSION;
+  exports.deepClone = deepClone;
+  exports.delay = delay;
+  exports.formatNumber = formatNumber;
+  exports.generateId = generateId;
+  exports.isEmpty = isEmpty;
+  exports.retry = retry;
+
+  Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+}));