@flashist/appframework 0.0.50 → 0.0.52

package/preloader-page/data/PreloaderPageId.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PreloaderPageId.js","sourceRoot":"","sources":["../../../src/preloader-page/data/PreloaderPageId.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,IAAM,eAAe,GAAG,eAAe,CAAC"}

package/sounds/managers/SoundsStorageManager.d.ts

@@ -1,9 +1,9 @@
 import { BaseObject } from "@flashist/fcore";
 import { SoundsManager } from "@flashist/flibs";
-import { StorageManager } from "../../storage/managers/StorageManager";
+import { LocalStorageManager } from "../../local-storage/managers/LocalStorageManager";
 export declare class SoundsStorageManager extends BaseObject {
     protected soundsManager: SoundsManager;
-    protected storageManager: StorageManager;
+    protected storageManager: LocalStorageManager;
     protected construction(...args: any[]): void;
     protected addListeners(): void;
     protected onSoundsDataChange(): void;

package/sounds/managers/SoundsStorageManager.js

@@ -15,7 +15,7 @@ var __extends = (this && this.__extends) || (function () {
 })();
 import { BaseObject } from "@flashist/fcore";
 import { getInstance, SoundsManager, SoundsManagerEvent } from "@flashist/flibs";
-import { StorageManager } from "../../storage/managers/StorageManager";
+import { LocalStorageManager } from "../../local-storage/managers/LocalStorageManager";
 import { SoundsSettings } from "../SoundsSettings";
 var SoundsStorageManager = /** @class */ (function (_super) {
     __extends(SoundsStorageManager, _super);
@@ -28,7 +28,7 @@ var SoundsStorageManager = /** @class */ (function (_super) {
             args[_i] = arguments[_i];
         }
         this.soundsManager = getInstance(SoundsManager);
-        this.storageManager = getInstance(StorageManager);
+        this.storageManager = getInstance(LocalStorageManager);
         _super.prototype.construction.apply(this, args);
     };
     SoundsStorageManager.prototype.addListeners = function () {

package/sounds/managers/SoundsStorageManager.js.map

@@ -1 +1 @@
-{"version":3,"file":"SoundsStorageManager.js","sourceRoot":"","sources":["../../../src/sounds/managers/SoundsStorageManager.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,OAAO,EAAC,UAAU,EAAC,MAAM,iBAAiB,CAAC;AAC3C,OAAO,EAAC,WAAW,EAAE,aAAa,EAAE,kBAAkB,EAAC,MAAM,iBAAiB,CAAC;AAE/E,OAAO,EAAC,cAAc,EAAC,MAAM,uCAAuC,CAAC;AACrE,OAAO,EAAC,cAAc,EAAC,MAAM,mBAAmB,CAAC;AAEjD;IAA0C,wCAAU;IAApD;;IAsCA,CAAC;IAjCa,2CAAY,GAAtB;QAAuB,cAAO;aAAP,UAAO,EAAP,qBAAO,EAAP,IAAO;YAAP,yBAAO;;QAC1B,IAAI,CAAC,aAAa,GAAG,WAAW,CAAC,aAAa,CAAC,CAAC;QAChD,IAAI,CAAC,cAAc,GAAG,WAAW,CAAC,cAAc,CAAC,CAAC;QAElD,iBAAM,YAAY,aAAI,IAAI,EAAE;IAChC,CAAC;IAES,2CAAY,GAAtB;QACI,iBAAM,YAAY,WAAE,CAAC;QAErB,IAAI,CAAC,mBAAmB,CAAC,gBAAgB,CACrC,IAAI,CAAC,aAAa,EAClB,kBAAkB,CAAC,eAAe,EAClC,IAAI,CAAC,kBAAkB,CAC1B,CAAC;IACN,CAAC;IAES,iDAAkB,GAA5B;QACI,IAAI,CAAC,gBAAgB,EAAE,CAAC;IAC5B,CAAC;IAEM,mDAAoB,GAA3B;QACI,IAAM,OAAO,GAAY,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAU,cAAc,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;QACtG,IAAI,OAAO,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,EAAE;YACvC,IAAI,CAAC,aAAa,CAAC,OAAO,GAAG,OAAO,CAAC;SACxC;QAED,IAAI,CAAC,gBAAgB,EAAE,CAAC;IAC5B,CAAC;IAES,+CAAgB,GAA1B;QACI,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,cAAc,CAAC,OAAO,CAAC,cAAc,EAAE,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;IACpG,CAAC;IACL,2BAAC;AAAD,CAAC,AAtCD,CAA0C,UAAU,GAsCnD"}
+{"version":3,"file":"SoundsStorageManager.js","sourceRoot":"","sources":["../../../src/sounds/managers/SoundsStorageManager.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,OAAO,EAAC,UAAU,EAAC,MAAM,iBAAiB,CAAC;AAC3C,OAAO,EAAC,WAAW,EAAE,aAAa,EAAE,kBAAkB,EAAC,MAAM,iBAAiB,CAAC;AAE/E,OAAO,EAAC,mBAAmB,EAAC,MAAM,kDAAkD,CAAC;AACrF,OAAO,EAAC,cAAc,EAAC,MAAM,mBAAmB,CAAC;AAEjD;IAA0C,wCAAU;IAApD;;IAsCA,CAAC;IAjCa,2CAAY,GAAtB;QAAuB,cAAO;aAAP,UAAO,EAAP,qBAAO,EAAP,IAAO;YAAP,yBAAO;;QAC1B,IAAI,CAAC,aAAa,GAAG,WAAW,CAAC,aAAa,CAAC,CAAC;QAChD,IAAI,CAAC,cAAc,GAAG,WAAW,CAAC,mBAAmB,CAAC,CAAC;QAEvD,iBAAM,YAAY,aAAI,IAAI,EAAE;IAChC,CAAC;IAES,2CAAY,GAAtB;QACI,iBAAM,YAAY,WAAE,CAAC;QAErB,IAAI,CAAC,mBAAmB,CAAC,gBAAgB,CACrC,IAAI,CAAC,aAAa,EAClB,kBAAkB,CAAC,eAAe,EAClC,IAAI,CAAC,kBAAkB,CAC1B,CAAC;IACN,CAAC;IAES,iDAAkB,GAA5B;QACI,IAAI,CAAC,gBAAgB,EAAE,CAAC;IAC5B,CAAC;IAEM,mDAAoB,GAA3B;QACI,IAAM,OAAO,GAAY,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAU,cAAc,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;QACtG,IAAI,OAAO,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,EAAE;YACvC,IAAI,CAAC,aAAa,CAAC,OAAO,GAAG,OAAO,CAAC;SACxC;QAED,IAAI,CAAC,gBAAgB,EAAE,CAAC;IAC5B,CAAC;IAES,+CAAgB,GAA1B;QACI,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,cAAc,CAAC,OAAO,CAAC,cAAc,EAAE,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;IACpG,CAAC;IACL,2BAAC;AAAD,CAAC,AAtCD,CAA0C,UAAU,GAsCnD"}

package/state/AppStateModule.d.ts

@@ -0,0 +1,46 @@
+import { BaseAppModule } from "../base/modules/BaseAppModule";
+import { AppStateStorage } from "./data/AppStateStorage";
+import { Flatten } from "./data/DeepKeyTypings";
+export declare class AppStateModule extends BaseAppModule {
+    init(): void;
+    initCompleteHook(): void;
+}
+export declare const appStorage: () => AppStateStorage;
+export declare const appStateChangeEvent: <StateType extends object>() => <DeepKeyType extends keyof Flatten<StateType, never>>(deepKey: DeepKeyType) => string;
+/**
+//
+export const getAppStateStorage = (): AppStateStorage => {
+    return getInstance(AppStateStorage);
+};
+export const getAppState = getAppStateStorage().getState.bind;
+// export const appStateInitializeWith = getAppStateStorage().initializeWith;
+
+export const getAppStateChangeEventName = <StateType extends object>() => {
+    return <DeepKeyType extends keyof Flatten<StateType>>(deepKey: DeepKeyType): string => {
+        return AppStateEventChangeTools.getChangeEvent(deepKey)
+    }
+}
+
+// MODIFICATIONS
+
+// export const appStateChange = getInstance(AppStateStorage).change;
+export const appStateChange = <StateType extends object>() => {
+    return <DeepKeyType extends keyof Flatten<StateType>>(key: DeepKeyType, value: Flatten<StateType>[DeepKeyType]): void => {
+        const appStateStorage: AppStateStorage = getAppStateStorage();
+        appStateStorage.change({} as StateType, key, value);
+    }
+}
+
+// export const appStateDelete = <StateType extends object>(nestedPaths: ObjectNestedPathsType<StateType>) => {
+//     getInstance(AppStateStorage).delete<StateType>(nestedPaths);
+// }
+
+// export const appStateAddElements = <StateType extends object, ElementType>(nestedPaths: ObjectNestedPathsType<StateType>, ...elements: ElementType[]) => {
+//     getInstance(AppStateStorage).addElements<StateType, ElementType>(nestedPaths, ...elements);
+// }
+
+// export const appStateRemoveElements = <StateType extends object, ElementType>(nestedPaths: ObjectNestedPathsType<StateType>, ...elements: ElementType[]) => {
+//     getInstance(AppStateStorage).removeElements<StateType, ElementType>(nestedPaths, ...elements);
+// }
+
+**/ 

package/state/AppStateModule.js

@@ -0,0 +1,81 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { getInstance, serviceLocatorAdd } from "@flashist/flibs";
+import { BaseAppModule } from "../base/modules/BaseAppModule";
+import { AppStateStorage } from "./data/AppStateStorage";
+import { AppStateEventChangeTools } from "./tools/AppStateEventChangeTools";
+var AppStateModule = /** @class */ (function (_super) {
+    __extends(AppStateModule, _super);
+    function AppStateModule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    AppStateModule.prototype.init = function () {
+        _super.prototype.init.call(this);
+        serviceLocatorAdd(AppStateStorage, { isSingleton: true });
+    };
+    AppStateModule.prototype.initCompleteHook = function () {
+        _super.prototype.initCompleteHook.call(this);
+        getInstance(AppStateStorage).initializeComplete();
+    };
+    return AppStateModule;
+}(BaseAppModule));
+export { AppStateModule };
+export var appStorage = function () {
+    return getInstance(AppStateStorage);
+};
+export var appStateChangeEvent = function () {
+    return function (deepKey) {
+        return AppStateEventChangeTools.getChangeEvent(deepKey);
+    };
+};
+/**
+//
+export const getAppStateStorage = (): AppStateStorage => {
+    return getInstance(AppStateStorage);
+};
+export const getAppState = getAppStateStorage().getState.bind;
+// export const appStateInitializeWith = getAppStateStorage().initializeWith;
+
+export const getAppStateChangeEventName = <StateType extends object>() => {
+    return <DeepKeyType extends keyof Flatten<StateType>>(deepKey: DeepKeyType): string => {
+        return AppStateEventChangeTools.getChangeEvent(deepKey)
+    }
+}
+
+// MODIFICATIONS
+
+// export const appStateChange = getInstance(AppStateStorage).change;
+export const appStateChange = <StateType extends object>() => {
+    return <DeepKeyType extends keyof Flatten<StateType>>(key: DeepKeyType, value: Flatten<StateType>[DeepKeyType]): void => {
+        const appStateStorage: AppStateStorage = getAppStateStorage();
+        appStateStorage.change({} as StateType, key, value);
+    }
+}
+
+// export const appStateDelete = <StateType extends object>(nestedPaths: ObjectNestedPathsType<StateType>) => {
+//     getInstance(AppStateStorage).delete<StateType>(nestedPaths);
+// }
+
+// export const appStateAddElements = <StateType extends object, ElementType>(nestedPaths: ObjectNestedPathsType<StateType>, ...elements: ElementType[]) => {
+//     getInstance(AppStateStorage).addElements<StateType, ElementType>(nestedPaths, ...elements);
+// }
+
+// export const appStateRemoveElements = <StateType extends object, ElementType>(nestedPaths: ObjectNestedPathsType<StateType>, ...elements: ElementType[]) => {
+//     getInstance(AppStateStorage).removeElements<StateType, ElementType>(nestedPaths, ...elements);
+// }
+
+**/ 
+//# sourceMappingURL=AppStateModule.js.map

package/state/AppStateModule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AppStateModule.js","sourceRoot":"","sources":["../../src/state/AppStateModule.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACjE,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAA;AAC7D,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAEzD,OAAO,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAE5E;IAAoC,kCAAa;IAAjD;;IAaA,CAAC;IAXG,6BAAI,GAAJ;QACI,iBAAM,IAAI,WAAE,CAAC;QAEb,iBAAiB,CAAC,eAAe,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE,CAAC,CAAC;IAC9D,CAAC;IAED,yCAAgB,GAAhB;QACI,iBAAM,gBAAgB,WAAE,CAAC;QAEzB,WAAW,CAAC,eAAe,CAAC,CAAC,kBAAkB,EAAE,CAAC;IACtD,CAAC;IACL,qBAAC;AAAD,CAAC,AAbD,CAAoC,aAAa,GAahD;;AAED,MAAM,CAAC,IAAM,UAAU,GAAG;IACtB,OAAO,WAAW,CAAC,eAAe,CAAC,CAAC;AACxC,CAAC,CAAA;AAED,MAAM,CAAC,IAAM,mBAAmB,GAAG;IAC/B,OAAO,UAA+C,OAAoB;QACtE,OAAO,wBAAwB,CAAC,cAAc,CAAC,OAAO,CAAC,CAAA;IAC3D,CAAC,CAAA;AACL,CAAC,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG"}

package/state/data/AppStateStorage.d.ts

@@ -0,0 +1,20 @@
+import { Flatten } from "./DeepKeyTypings";
+import { BaseObjectWithGlobalDispatcher } from "../../base/BaseObjectWithGlobalDispatcher";
+import { IDeepKeyHelperVO } from "../tools/INestedPathHelperVO";
+import { DeepReadonly } from "./DeepReadableTypings";
+import { IPreChangeHook } from "./IPreChangeHook";
+export declare class AppStateStorage extends BaseObjectWithGlobalDispatcher {
+    protected isInitialized: boolean;
+    protected state: object;
+    protected pathsHelperDataCache: {
+        [pathJsonText: string]: IDeepKeyHelperVO;
+    };
+    protected preChangeHooks: IPreChangeHook[];
+    initializeWith<StateType extends object>(initState: StateType): void;
+    initializeComplete(): void;
+    getState<StateType extends object>(): DeepReadonly<StateType>;
+    protected dispatchChangeEvents(helperData: IDeepKeyHelperVO): void;
+    protected getPathsHelperData(deepKey: string): IDeepKeyHelperVO;
+    change<StateType extends object>(): <DeepKeyType extends keyof Flatten<StateType, never>>(key: DeepKeyType, value: Partial<Flatten<StateType, never>[DeepKeyType]>) => void;
+    protected innerChange<StateType, DeepKeyType extends keyof Flatten<StateType>, ValueType extends Flatten<StateType>[DeepKeyType]>(stateForTypings: StateType, deepKey: DeepKeyType, value: Partial<ValueType>): void;
+}

package/state/data/AppStateStorage.js

@@ -0,0 +1,143 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { ObjectTools } from "@flashist/fcore";
+import { BaseObjectWithGlobalDispatcher } from "../../base/BaseObjectWithGlobalDispatcher";
+import { AppStateEventChangeTools } from "../tools/AppStateEventChangeTools";
+import { AppStateDeepKeyTools } from "../tools/AppStateDeepKeyTools";
+var AppStateStorage = /** @class */ (function (_super) {
+    __extends(AppStateStorage, _super);
+    function AppStateStorage() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.isInitialized = false;
+        _this.state = {};
+        _this.pathsHelperDataCache = {};
+        _this.preChangeHooks = [];
+        return _this;
+        // // public change<StateType extends object, ChangeType>(nestedPaths: ObjectNestedPathsType<StateType>, value: ChangeType): void {
+        // public change<StateType, DeepKeyType extends keyof Flatten<StateType>>(obj: StateType, key: DeepKeyType, value: Flatten<StateType>[DeepKeyType]): void {
+        //     // AS ANY needed to calm compiler and autocomplete
+        //     let tempObject: StateType = this.state as any;
+        //     const pathsHelperData: IDeepKeyHelperVO = this.getPathsHelperData(nestedPaths as any);
+        //     let nestedPathsCount: number = pathsHelperData.splitDeepKeyParts.length;
+        //     for (let nestedPathIndex: number = 0; nestedPathIndex < nestedPathsCount; nestedPathIndex++) {
+        //         const singlePath: string | number = pathsHelperData.splitDeepKeyParts[nestedPathIndex];
+        //         if (nestedPathIndex === (nestedPathsCount - 1)) {
+        //             // tempObject[singlePath] = value;
+        //             ObjectTools.copySinglePropFromValue(tempObject, singlePath as string, value);
+        //         } else {
+        //             tempObject = tempObject[singlePath];
+        //         }
+        //     }
+        //     this.dispatchChangeEvents(pathsHelperData);
+        // }
+        // public delete<StateType extends object>(nestedPaths: ObjectNestedPathsType<StateType>): void {
+        //     // AS ANY needed to calm compiler and autocomplete
+        //     let tempObject: StateType = this.state as any;
+        //     const pathsHelperData: IDeepKeyHelperVO = this.getPathsHelperData(nestedPaths as any);
+        //     let nestedPathsCount: number = pathsHelperData.splitDeepKeyParts.length;
+        //     for (let nestedPathIndex: number = 0; nestedPathIndex < nestedPathsCount; nestedPathIndex++) {
+        //         const singlePath: string | number = pathsHelperData.splitDeepKeyParts[nestedPathIndex];
+        //         if (nestedPathIndex === (nestedPathsCount - 1)) {
+        //             delete tempObject[singlePath];
+        //         } else {
+        //             tempObject = tempObject[singlePath];
+        //         }
+        //     }
+        //     this.dispatchChangeEvents(pathsHelperData);
+        // }
+        // public addElements<StateType extends object, ElementType>(nestedPaths: ObjectNestedPathsType<StateType>, ...elements: ElementType[]): void {
+        //     // AS ANY needed to calm compiler and autocomplete
+        //     let tempObject: StateType = this.state as any;
+        //     const pathsHelperData: IDeepKeyHelperVO = this.getPathsHelperData(nestedPaths as any);
+        //     let nestedPathsCount: number = pathsHelperData.splitDeepKeyParts.length;
+        //     for (let nestedPathIndex: number = 0; nestedPathIndex < nestedPathsCount; nestedPathIndex++) {
+        //         const singlePath: string | number = pathsHelperData.splitDeepKeyParts[nestedPathIndex];
+        //         tempObject = tempObject[singlePath];
+        //     }
+        //     (tempObject as Array<ElementType>).push(...elements);
+        //     this.dispatchChangeEvents(pathsHelperData);
+        // }
+        // public removeElements<StateType extends object, ElementType>(nestedPaths: ObjectNestedPathsType<StateType>, ...elements: ElementType[]): void {
+        //     // AS ANY needed to calm compiler and autocomplete
+        //     let tempObject: StateType = this.state as any;
+        //     const pathsHelperData: IDeepKeyHelperVO = this.getPathsHelperData(nestedPaths as any);
+        //     let nestedPathsCount: number = pathsHelperData.splitDeepKeyParts.length;
+        //     for (let nestedPathIndex: number = 0; nestedPathIndex < nestedPathsCount; nestedPathIndex++) {
+        //         const singlePath: string | number = pathsHelperData.splitDeepKeyParts[nestedPathIndex];
+        //         tempObject = tempObject[singlePath];
+        //     }
+        //     ArrayTools.removeItems((tempObject as Array<ElementType>), elements);
+        //     this.dispatchChangeEvents(pathsHelperData);
+        // }
+    }
+    AppStateStorage.prototype.initializeWith = function (initState) {
+        if (this.isInitialized) {
+            return;
+        }
+        ObjectTools.copyProps(this.state, initState);
+    };
+    AppStateStorage.prototype.initializeComplete = function () {
+        this.isInitialized = true;
+    };
+    AppStateStorage.prototype.getState = function () {
+        return this.state;
+    };
+    AppStateStorage.prototype.dispatchChangeEvents = function (helperData) {
+        for (var _i = 0, _a = helperData.dispatchingChangePaths; _i < _a.length; _i++) {
+            var singleDispatchingChangePath = _a[_i];
+            var eventName = AppStateEventChangeTools.getChangeEvent(singleDispatchingChangePath);
+            this.dispatchEvent(eventName);
+        }
+    };
+    AppStateStorage.prototype.getPathsHelperData = function (deepKey) {
+        var result = this.pathsHelperDataCache[deepKey];
+        if (!result) {
+            result = AppStateDeepKeyTools.prepareDeepKeyHelperData(deepKey);
+            this.pathsHelperDataCache[deepKey] = result;
+        }
+        return result;
+    };
+    AppStateStorage.prototype.change = function () {
+        var _this = this;
+        return function (key, value) {
+            _this.innerChange({}, key, value);
+        };
+    };
+    AppStateStorage.prototype.innerChange = function (stateForTypings, deepKey, value) {
+        // Pre Change Hooks: execute pre-change-hooks on every element: e.g. ecs module hooks might change prepare the new ecs components to sort their container-type-keys to make sure they are always the same q
+        if (this.preChangeHooks.length > 0) {
+            this.preChangeHooks.forEach(function (item) {
+                item(stateForTypings, deepKey, value);
+            });
+        }
+        var pathsHelperData = this.getPathsHelperData(deepKey);
+        var tempObject = this.state;
+        var nestedPathsCount = pathsHelperData.splitDeepKeyParts.length;
+        for (var nestedPathIndex = 0; nestedPathIndex < nestedPathsCount; nestedPathIndex++) {
+            var singlePath = pathsHelperData.splitDeepKeyParts[nestedPathIndex];
+            if (nestedPathIndex === (nestedPathsCount - 1)) {
+                ObjectTools.copySinglePropFromValue(tempObject, singlePath, value);
+            }
+            else {
+                tempObject = tempObject[singlePath];
+            }
+        }
+        this.dispatchChangeEvents(pathsHelperData);
+    };
+    return AppStateStorage;
+}(BaseObjectWithGlobalDispatcher));
+export { AppStateStorage };
+//# sourceMappingURL=AppStateStorage.js.map

package/state/data/AppStateStorage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AppStateStorage.js","sourceRoot":"","sources":["../../../src/state/data/AppStateStorage.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAE9C,OAAO,EAAE,8BAA8B,EAAE,MAAM,2CAA2C,CAAC;AAC3F,OAAO,EAAE,wBAAwB,EAAE,MAAM,mCAAmC,CAAC;AAC7E,OAAO,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AAKrE;IAAqC,mCAA8B;IAAnE;QAAA,qEAyJC;QAvJa,mBAAa,GAAY,KAAK,CAAC;QAE/B,WAAK,GAAW,EAAE,CAAC;QAEnB,0BAAoB,GAAiD,EAAE,CAAC;QAExE,oBAAc,GAAqB,EAAE,CAAC;;QAwEhD,mIAAmI;QACnI,2JAA2J;QAC3J,yDAAyD;QACzD,qDAAqD;QACrD,6FAA6F;QAE7F,+EAA+E;QAC/E,qGAAqG;QACrG,kGAAkG;QAElG,4DAA4D;QAC5D,iDAAiD;QACjD,4FAA4F;QAE5F,mBAAmB;QACnB,mDAAmD;QACnD,YAAY;QACZ,QAAQ;QAER,kDAAkD;QAClD,IAAI;QAEJ,iGAAiG;QACjG,yDAAyD;QACzD,qDAAqD;QACrD,6FAA6F;QAE7F,+EAA+E;QAC/E,qGAAqG;QACrG,kGAAkG;QAElG,4DAA4D;QAC5D,6CAA6C;QAE7C,mBAAmB;QACnB,mDAAmD;QACnD,YAAY;QACZ,QAAQ;QAER,kDAAkD;QAClD,IAAI;QAEJ,+IAA+I;QAC/I,yDAAyD;QACzD,qDAAqD;QACrD,6FAA6F;QAE7F,+EAA+E;QAC/E,qGAAqG;QACrG,kGAAkG;QAClG,+CAA+C;QAC/C,QAAQ;QAER,4DAA4D;QAE5D,kDAAkD;QAClD,IAAI;QAEJ,kJAAkJ;QAClJ,yDAAyD;QACzD,qDAAqD;QACrD,6FAA6F;QAE7F,+EAA+E;QAC/E,qGAAqG;QACrG,kGAAkG;QAClG,+CAA+C;QAC/C,QAAQ;QAER,4EAA4E;QAE5E,kDAAkD;QAClD,IAAI;IACR,CAAC;IA/IU,wCAAc,GAArB,UAAgD,SAAoB;QAChE,IAAI,IAAI,CAAC,aAAa,EAAE;YACpB,OAAO;SACV;QAED,WAAW,CAAC,SAAS,CACjB,IAAI,CAAC,KAAK,EACV,SAAS,CACZ,CAAC;IACN,CAAC;IAEM,4CAAkB,GAAzB;QACI,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;IAC9B,CAAC;IAEM,kCAAQ,GAAf;QACI,OAAO,IAAI,CAAC,KAAY,CAAC;IAC7B,CAAC;IAES,8CAAoB,GAA9B,UAA+B,UAA4B;QACvD,KAAwC,UAAiC,EAAjC,KAAA,UAAU,CAAC,sBAAsB,EAAjC,cAAiC,EAAjC,IAAiC,EAAE;YAAtE,IAAI,2BAA2B,SAAA;YAChC,IAAM,SAAS,GAAW,wBAAwB,CAAC,cAAc,CAAC,2BAA2B,CAAC,CAAC;YAC/F,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC;SACjC;IACL,CAAC;IAES,4CAAkB,GAA5B,UAA6B,OAAe;QACxC,IAAI,MAAM,GAAqB,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC;QAClE,IAAI,CAAC,MAAM,EAAE;YACT,MAAM,GAAG,oBAAoB,CAAC,wBAAwB,CAAC,OAAO,CAAC,CAAC;YAChE,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC,GAAG,MAAM,CAAC;SAC/C;QAED,OAAO,MAAM,CAAC;IAClB,CAAC;IAEM,gCAAM,GAAb;QAAA,iBAIC;QAHG,OAAO,UAA+C,GAAgB,EAAE,KAA+C;YACnH,KAAI,CAAC,WAAW,CAAC,EAAe,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;QAClD,CAAC,CAAA;IACL,CAAC;IAES,qCAAW,GAArB,UAAkI,eAA0B,EAAE,OAAoB,EAAE,KAAyB;QACzM,2MAA2M;QAC3M,IAAI,IAAI,CAAC,cAAc,CAAC,MAAM,GAAG,CAAC,EAAE;YAChC,IAAI,CAAC,cAAc,CAAC,OAAO,CACvB,UAAC,IAAoB;gBACjB,IAAI,CAAoC,eAAe,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC;YAC7E,CAAC,CACJ,CAAC;SACL;QAED,IAAM,eAAe,GAAqB,IAAI,CAAC,kBAAkB,CAAC,OAAiB,CAAC,CAAC;QAErF,IAAI,UAAU,GAAQ,IAAI,CAAC,KAAK,CAAC;QACjC,IAAI,gBAAgB,GAAW,eAAe,CAAC,iBAAiB,CAAC,MAAM,CAAC;QACxE,KAAK,IAAI,eAAe,GAAW,CAAC,EAAE,eAAe,GAAG,gBAAgB,EAAE,eAAe,EAAE,EAAE;YACzF,IAAM,UAAU,GAAoB,eAAe,CAAC,iBAAiB,CAAC,eAAe,CAAC,CAAC;YAEvF,IAAI,eAAe,KAAK,CAAC,gBAAgB,GAAG,CAAC,CAAC,EAAE;gBAC5C,WAAW,CAAC,uBAAuB,CAAC,UAAU,EAAE,UAAoB,EAAE,KAAK,CAAC,CAAC;aAEhF;iBAAM;gBACH,UAAU,GAAG,UAAU,CAAC,UAAU,CAAC,CAAC;aACvC;SACJ;QAED,IAAI,CAAC,oBAAoB,CAAC,eAAe,CAAC,CAAC;IAC/C,CAAC;IA2EL,sBAAC;AAAD,CAAC,AAzJD,CAAqC,8BAA8B,GAyJlE"}

package/state/data/DeepKeyTypings.d.ts

@@ -0,0 +1,25 @@
+declare type Writable<T, O> = T extends O ? T : {
+    [P in keyof T as IfEquals<{
+        [Q in P]: T[P];
+    }, {
+        -readonly [Q in P]: T[P];
+    }, P>]: T[P];
+};
+declare type IfEquals<X, Y, A = X, B = never> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? A : B;
+declare type Cleanup<T> = 0 extends (1 & T) ? unknown : T extends readonly any[] ? (Exclude<keyof T, keyof any[]> extends never ? {
+    [k: `${number}`]: T[number];
+} : Omit<T, keyof any[]>) : T;
+declare type PrefixKeys<V, K extends PropertyKey, O> = V extends O ? {
+    [P in K]: V;
+} : V extends object ? {
+    [P in keyof V as `${Extract<K, string | number>}.${Extract<P, string | number>}`]: V[P];
+} : {
+    [P in K]: V;
+};
+declare type ValueOf<T> = T[keyof T];
+export declare type Flatten<T, O = never> = Writable<Cleanup<T>, O> extends infer U ? U extends O ? U : U extends object ? ValueOf<{
+    [K in keyof U]-?: (x: PrefixKeys<Flatten<U[K], O>, K, O>) => void;
+}> | ((x: U) => void) extends (x: infer I) => void ? {
+    [K in keyof I]: I[K];
+} : never : U : never;
+export {};

package/state/data/DeepKeyTypings.js

@@ -0,0 +1,144 @@
+export {};
+// function lookup<T, K extends keyof Flatten<T>>(obj: T, key: K): Flatten<T>[K];
+// function lookup(obj: any, key: string) {
+//     const i = key.indexOf(".");
+//     return (i < 0) ? obj[key] : (lookup as any)(obj[key.substring(0, i)], key.substring(i + 1));
+// }
+/*
+// TRY #2: EXAMPLES OF USING
+
+// function shortLookup<ObjectType, DeepKeyType extends keyof Flatten<ObjectType>, ValueType extends Flatten<ObjectType>[DeepKeyType]>(obj: ObjectType, key: DeepKeyType, value: ValueType): void {
+function shortLookup<ObjectType, DeepKeyType extends keyof Flatten<ObjectType>>(obj: ObjectType = {} as any, key: DeepKeyType, value: Flatten<ObjectType>[DeepKeyType]): void {
+    // const i = key.indexOf(".");
+    // return (i < 0) ? obj[key] : (lookup as any)(obj[key.substring(0, i)], key.substring(i + 1));
+}
+
+function myLookup<ObjectType, DeepKeyType extends keyof Flatten<ObjectType>, ValueType extends Flatten<ObjectType>[DeepKeyType]>(obj: ObjectType, deepKey: DeepKeyType, value: ValueType): void;
+function myLookup(obj: any, deepKey: string, value: any) {
+}
+
+function myLookupOneInstance<ObjectType, DeepKeyType extends keyof Flatten<ObjectType>, ValueType extends Flatten<ObjectType>[DeepKeyType]>(obj: ObjectType, deepKey: DeepKeyType, value: ValueType): void {
+}
+
+// function myLookup2<ObjectType, DeepKeyType extends keyof Flatten<ObjectType>, ValueType extends Flatten<ObjectType>[DeepKeyType]>(deepKey: DeepKeyType, value: ValueType, obj: ObjectType): void;
+function myLookup2<ObjectType, DeepKeyType extends keyof Flatten<ObjectType>, ValueType extends Flatten<ObjectType>[DeepKeyType]>(deepKey: DeepKeyType, value: ValueType, obj: ObjectType = {} as ObjectType) {
+}
+
+// function myLookupWithoutObj<ObjectType extends object, DeepKeyType extends keyof Flatten<ObjectType> = keyof Flatten<ObjectType>, ValueType extends Flatten<ObjectType>[DeepKeyType] = Flatten<ObjectType>[DeepKeyType]>(deepKey: DeepKeyType, value: ValueType): void;
+function myLookupWithoutObj<ObjectType extends object, DeepKeyType extends keyof Flatten<ObjectType> = keyof Flatten<ObjectType>, ValueType extends Flatten<ObjectType>[DeepKeyType] = Flatten<ObjectType>[DeepKeyType]>(deepKey: DeepKeyType, value: ValueType) {
+}
+
+// type FooType = {
+//     a: [number, { b: string }, number]
+//     c: {
+//         d: {
+//             e: number
+//         }
+//     }
+// }
+const foo = {
+    a: [1, { b: "two" }, 3] as [number, { b: string }, number],
+    c: { d: { e: 1 } }
+}
+type FooType = typeof foo;
+
+lookup(foo, "a.1.b").toUpperCase() // TWO
+myLookup(foo, "a.1.b", 20).toUpperCase() // TWO
+myLookup(foo, "a.0", 20);
+myLookup(foo, "a.0", "20");
+
+myLookupOneInstance(foo, "c", 20);
+myLookupOneInstance(null as FooType, "a.0", 20);
+
+shortLookup({} as FooType, "a.0", "20");
+shortLookup({} as FooType, "a.0", 20);
+
+myLookup2("a.0", "2", foo);
+myLookup2<FooType, keyof Flatten<FooType>, Flatten<FooType>[keyof Flatten<FooType>]>("a.0", "20");
+myLookup2("a.0", 20);
+myLookup2<FooType>(foo, "a", "20");
+myLookup2<FooType>(foo, "a.0", 20);
+myLookupWithoutObj<FooType>("c.e", 20);
+myLookupWithoutObj<FooType, keyof Flatten<FooType>, Flatten<FooType>[keyof Flatten<FooType>]>("a.0", 20);
+myLookupWithoutObj<FooType, keyof Flatten<FooType>, Flatten<FooType>[keyof Flatten<FooType>]>("a.0", "20");
+myLookupWithoutObj<FooType>("a.0", "20");
+myLookupWithoutObj<FooType>("a.1", "20");
+
+*/
+// function lookupWithReturn<ValueType>(obj: any, key: string, value: ValueType): typeof value {
+//     const i = key.indexOf(".");
+//     return (i < 0) ? obj[key] : (lookup as any)(obj[key.substring(0, i)], key.substring(i + 1));
+// }
+// lookupWithReturn(foo, "a.0", 20)
+// lookupWithReturn(foo, "a.0", "20")
+// // lookupWithReturn(foo, "a.0", false)
+// try {
+//     console.log(lookup(foo, "c.d.e")) // oops, error, can't necessarily look that up
+// } catch (e) {
+//     console.log(e); // maybe obj is undefined
+// }
+/*
+==== FIRST DRAFT: works, but not perfect, cuz gets list of split properties and can't get a.0 as an index for array elements ====
+
+type Join<K, P> = K extends string | number ?
+    P extends string | number ?
+    `${K}${"" extends P ? "" : "."}${P}`
+    : never : never;
+
+
+type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
+    11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...0[]]
+
+type Paths<T, D extends number = 10> = [D] extends [never] ? never : T extends object ?
+    { [K in keyof T]-?: K extends string | number ?
+        `${K}` | Join<K, Paths<T[K], Prev[D]>>
+        : never
+    }[keyof T] : ""
+
+type Leaves<T, D extends number = 10> = [D] extends [never] ? never : T extends object ?
+    { [K in keyof T]-?: Join<K, Leaves<T[K], Prev[D]>> }[keyof T] : "";
+
+
+// type NestedObjectType = {
+//     a: string;
+//     b: string;
+//     nest: {
+//         c: string;
+//     };
+//     otherNest: {
+//         otherNest: {
+//             c: string;
+//         }
+//     };
+// };
+
+interface Tree {
+    left: Tree,
+    right: Tree,
+    data: string
+}
+
+// type TreeLeaves = Leaves<Tree>; // sorry, compiler 💻⌛😫
+// type TreeLeaves = "data" | "left.data" | "right.data" | "left.left.data" |
+// "left.right.data" | "right.left.data" | "right.right.data" | "left.left.left.data" |
+// "left.left.right.data" | "left.right.left.data" | ... 1012 more ... |
+// "right.right.right.right.right.right.right.right.right.data"
+
+type TreeLeaves = Leaves<Tree, 100>;
+// type TreeLeaves =  "data" | "left.data" | "right.data" | "left.left.data" |
+// "left.right.data" | "right.left.data" | "right.right.data"
+
+// type NestedObjectPaths = Paths<NestedObjectType>;
+// type NestedObjectPaths = "a" | "b" | "nest" | "otherNest" | "nest.c" | "otherNest.c"
+// type NestedObjectLeaves = Leaves<NestedObjectType>
+// type NestedObjectLeaves = "a" | "b" | "nest.c" | "otherNest.c"
+
+export type ObjectSingleNestedPathType<T extends object> = Paths<T>;
+export type ObjectNestedPathsType<T extends object> = Array<Paths<T>>
+
+// const test: MyGenericType<NestedObjectType> = {
+//     keys: ["a", "nest.c", "otherNest.otherNest"]
+// }
+
+*/ 
+//# sourceMappingURL=DeepKeyTypings.js.map

package/state/data/DeepKeyTypings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeepKeyTypings.js","sourceRoot":"","sources":["../../../src/state/data/DeepKeyTypings.ts"],"names":[],"mappings":";AA4BA,iFAAiF;AACjF,2CAA2C;AAC3C,kCAAkC;AAClC,mGAAmG;AACnG,IAAI;AAGJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4DE;AAGF,gGAAgG;AAChG,kCAAkC;AAClC,mGAAmG;AACnG,IAAI;AACJ,mCAAmC;AACnC,qCAAqC;AACrC,yCAAyC;AAEzC,QAAQ;AACR,uFAAuF;AACvF,gBAAgB;AAChB,gDAAgD;AAChD,IAAI;AAEJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+DE"}

package/state/data/DeepReadableTypings.d.ts

@@ -0,0 +1,7 @@
+export declare type DeepReadonly<T> = T extends (infer R)[] ? DeepReadonlyArray<R> : T extends Function ? T : T extends object ? DeepReadonlyObject<T> : T;
+interface DeepReadonlyArray<T> extends ReadonlyArray<DeepReadonly<T>> {
+}
+declare type DeepReadonlyObject<T> = {
+    readonly [P in keyof T]: DeepReadonly<T[P]>;
+};
+export {};

package/state/data/DeepReadableTypings.js

@@ -0,0 +1,3 @@
+;
+export {};
+//# sourceMappingURL=DeepReadableTypings.js.map

package/state/data/DeepReadableTypings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeepReadableTypings.js","sourceRoot":"","sources":["../../../src/state/data/DeepReadableTypings.ts"],"names":[],"mappings":"AAMwE,CAAC"}

package/state/data/IPreChangeHook.d.ts

@@ -0,0 +1,4 @@
+import { Flatten } from "./DeepKeyTypings";
+export interface IPreChangeHook extends Function {
+    <StateType, DeepKeyType extends keyof Flatten<StateType>, ValueType extends Flatten<StateType>[DeepKeyType]>(stateForTypings: StateType, deepKey: DeepKeyType, value: Partial<ValueType>): void;
+}

package/state/data/IPreChangeHook.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IPreChangeHook.js.map

package/state/data/IPreChangeHook.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IPreChangeHook.js","sourceRoot":"","sources":["../../../src/state/data/IPreChangeHook.ts"],"names":[],"mappings":""}

package/state/tools/AppStateDeepKeyTools.d.ts

@@ -0,0 +1,4 @@
+import { IDeepKeyHelperVO } from "./INestedPathHelperVO";
+export declare class AppStateDeepKeyTools {
+    static prepareDeepKeyHelperData(deepKey: string): IDeepKeyHelperVO;
+}

package/state/tools/AppStateDeepKeyTools.js

@@ -0,0 +1,25 @@
+var AppStateDeepKeyTools = /** @class */ (function () {
+    function AppStateDeepKeyTools() {
+    }
+    AppStateDeepKeyTools.prepareDeepKeyHelperData = function (deepKey) {
+        var result = {
+            splitDeepKeyParts: [],
+            dispatchingChangePaths: []
+        };
+        var tempTotalPath = "";
+        var splitPaths = deepKey.split(".");
+        for (var _i = 0, splitPaths_1 = splitPaths; _i < splitPaths_1.length; _i++) {
+            var singleSplitPath = splitPaths_1[_i];
+            result.splitDeepKeyParts.push(singleSplitPath);
+            if (tempTotalPath) {
+                tempTotalPath += ".";
+            }
+            tempTotalPath += singleSplitPath;
+            result.dispatchingChangePaths.push(tempTotalPath);
+        }
+        return result;
+    };
+    return AppStateDeepKeyTools;
+}());
+export { AppStateDeepKeyTools };
+//# sourceMappingURL=AppStateDeepKeyTools.js.map

package/state/tools/AppStateDeepKeyTools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AppStateDeepKeyTools.js","sourceRoot":"","sources":["../../../src/state/tools/AppStateDeepKeyTools.ts"],"names":[],"mappings":"AAEA;IAAA;IAqBA,CAAC;IApBU,6CAAwB,GAA/B,UAAgC,OAAe;QAC3C,IAAM,MAAM,GAAqB;YAC7B,iBAAiB,EAAE,EAAE;YACrB,sBAAsB,EAAE,EAAE;SAC7B,CAAC;QAEF,IAAI,aAAa,GAAW,EAAE,CAAC;QAC/B,IAAM,UAAU,GAAa,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAChD,KAA4B,UAAU,EAAV,yBAAU,EAAV,wBAAU,EAAV,IAAU,EAAE;YAAnC,IAAI,eAAe,mBAAA;YACpB,MAAM,CAAC,iBAAiB,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;YAE/C,IAAI,aAAa,EAAE;gBACf,aAAa,IAAI,GAAG,CAAC;aACxB;YACD,aAAa,IAAI,eAAe,CAAC;YACjC,MAAM,CAAC,sBAAsB,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;SACrD;QAED,OAAO,MAAM,CAAC;IAClB,CAAC;IACL,2BAAC;AAAD,CAAC,AArBD,IAqBC"}

package/state/tools/AppStateEventChangeTools.d.ts

@@ -0,0 +1,3 @@
+export declare class AppStateEventChangeTools {
+    static getChangeEvent(path: string | number | symbol): string;
+}

package/state/tools/AppStateEventChangeTools.js

@@ -0,0 +1,13 @@
+var AppStateEventChangeTools = /** @class */ (function () {
+    function AppStateEventChangeTools() {
+    }
+    // static getAppStateChangeEventName(deepKey: string): string {
+    //     return AppStateEventChangeTools.getChangeEvent(deepKey);
+    // }
+    AppStateEventChangeTools.getChangeEvent = function (path) {
+        return "appStateChange:".concat(path.toString());
+    };
+    return AppStateEventChangeTools;
+}());
+export { AppStateEventChangeTools };
+//# sourceMappingURL=AppStateEventChangeTools.js.map

package/state/tools/AppStateEventChangeTools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AppStateEventChangeTools.js","sourceRoot":"","sources":["../../../src/state/tools/AppStateEventChangeTools.ts"],"names":[],"mappings":"AAGA;IAAA;IAQA,CAAC;IAPG,+DAA+D;IAC/D,+DAA+D;IAC/D,IAAI;IAEG,uCAAc,GAArB,UAAsB,IAA8B;QAChD,OAAO,yBAAkB,IAAI,CAAC,QAAQ,EAAE,CAAE,CAAC;IAC/C,CAAC;IACL,+BAAC;AAAD,CAAC,AARD,IAQC"}

package/state/tools/INestedPathHelperVO.d.ts

@@ -0,0 +1,4 @@
+export interface IDeepKeyHelperVO {
+    splitDeepKeyParts: string[];
+    dispatchingChangePaths: string[];
+}

package/state/tools/INestedPathHelperVO.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=INestedPathHelperVO.js.map

package/state/tools/INestedPathHelperVO.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"INestedPathHelperVO.js","sourceRoot":"","sources":["../../../src/state/tools/INestedPathHelperVO.ts"],"names":[],"mappings":""}