@vived/app 2.6.0 → 2.6.4

package/lib/Entities/StateMachine.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeStateMachine = void 0;
+function makeStateMachine() {
+    return new StateMachineImp();
+}
+exports.makeStateMachine = makeStateMachine;
+class StateMachineImp {
+    constructor() {
+        this.serializedSystems = new Map();
+        this.serilizationVersion = 2;
+        this.transitionEaseFunction = (normalizedTime) => {
+            return normalizedTime; // default to a linear function
+        };
+        this.applySerializedStatesString = (state, duration = 0) => {
+            if (state === "") {
+                this.setDefaultState(duration);
+            }
+            else {
+                try {
+                    const stateObj = JSON.parse(state);
+                    this.setSerializedStates(stateObj, duration);
+                }
+                catch (e) {
+                    this.setDefaultState(duration);
+                    console.warn("[StateMachine] Failed to deserialize state string: " + e);
+                }
+            }
+        };
+        this.registerSerializedSystem = (serializedSystem) => {
+            if (this.serializedSystems.has(serializedSystem.name)) {
+                throw new Error(`[StateMachine] Duplicate stateable systems encountered: ${serializedSystem.name}`);
+            }
+            this.serializedSystems.set(serializedSystem.name, serializedSystem);
+        };
+        this.getSerializedStates = () => {
+            const systems = Array.from(this.serializedSystems.values());
+            const serializedStates = systems.map((system) => {
+                const state = system.getSystemState();
+                return {
+                    seriliziationVersion: system.seriliziationVersion,
+                    name: system.name,
+                    state,
+                };
+            });
+            return {
+                version: this.serilizationVersion,
+                systems: serializedStates,
+            };
+        };
+        this.setSerializedStates = (state, duration) => {
+            if (state.version === 2) {
+                const appliedToSystems = [];
+                state.systems.forEach((systemState) => {
+                    const seriliazableSystem = this.serializedSystems.get(systemState.name);
+                    if (seriliazableSystem) {
+                        seriliazableSystem.applySystemState(systemState.state, systemState.seriliziationVersion, duration);
+                    }
+                    else {
+                        console.warn("Unable to find seriarializedSystem " + systemState.name);
+                    }
+                    appliedToSystems.push(systemState.name);
+                });
+                this.serializedSystems.forEach((system) => {
+                    if (!appliedToSystems.includes(system.name)) {
+                        system.applyDefaultState(duration);
+                    }
+                });
+            }
+            // Here is where we will add support for future versions
+            else {
+                throw new Error(`[StateMachine] Unsupported sereialized state encountered: ${state.version}`);
+            }
+        };
+        this.setDefaultState = (duration) => {
+            this.serializedSystems.forEach((system) => {
+                system.applyDefaultState(duration);
+            });
+        };
+    }
+}

package/lib/Entities/TouchInput.d.ts

@@ -0,0 +1,20 @@
+import { Vector2 } from ".";
+export interface TouchController {
+    onTouchStart?: (e: TouchEvent) => void;
+    onTouchMove?: (e: TouchEvent) => void;
+    onTouchEnd?: (e: TouchEvent) => void;
+    onTouchCancel?: (e: TouchEvent) => void;
+}
+export interface TouchInput {
+    eventElement: HTMLElement | undefined;
+    eventElementBounds?: DOMRect;
+    setEventElement: (eventElement: HTMLElement) => void;
+    clearInputElement: () => void;
+    updateInputElementBounds: () => void;
+    getTouchOffsetPosition: (touch: Touch) => Vector2;
+    getDistatnceBetweenTouches: (touch1: Touch, touch2: Touch) => number;
+    getTouchsCenter: (touches: TouchList) => Vector2;
+    registerController: (controller: TouchController) => void;
+    removeController: (controller: TouchController) => void;
+}
+export declare function makeTouchInput(): TouchInput;

package/lib/Entities/TouchInput.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTouchInput = void 0;
+const _1 = require(".");
+function makeTouchInput() {
+    return new TouchInputImp();
+}
+exports.makeTouchInput = makeTouchInput;
+class TouchInputImp {
+    constructor() {
+        this.controllers = [];
+        this._eventElement = undefined;
+        this.updateInputElementBounds = () => {
+            if (!this._eventElement)
+                return;
+            this.eventElementBounds = this._eventElement.getBoundingClientRect(); // Expensive so we cache
+        };
+        this.getTouchOffsetPosition = (touch) => {
+            if (!this.eventElementBounds) {
+                console.warn("No target bounds");
+                return _1.Vector2.Zero();
+            }
+            const x = touch.clientX - this.eventElementBounds.x;
+            const y = touch.clientY - this.eventElementBounds.y;
+            return new _1.Vector2(x, y);
+        };
+        this.getDistatnceBetweenTouches = (touch1, touch2) => {
+            const t1 = this.getTouchOffsetPosition(touch1);
+            const t2 = this.getTouchOffsetPosition(touch2);
+            const delta = t2.subtract(t1);
+            return delta.magnitued;
+        };
+        this.getTouchsCenter = (touches) => {
+            const touchCount = touches.length;
+            if (touchCount === 0)
+                return _1.Vector2.Zero();
+            let sumX = 0;
+            let sumY = 0;
+            for (let i = 0; i < touchCount; i++) {
+                const touch = touches[i];
+                const touchPos = this.getTouchOffsetPosition(touch);
+                sumX += touchPos.x;
+                sumY += touchPos.y;
+            }
+            return new _1.Vector2(sumX / touches.length, sumY / touches.length);
+        };
+        this.setEventElement = (eventElement) => {
+            if (this._eventElement)
+                this.clearInputElement();
+            eventElement.addEventListener("touchstart", this.onTouchStart, false);
+            eventElement.addEventListener("touchmove", this.onTouchMove, false);
+            eventElement.addEventListener("touchend", this.onTouchEnd, false);
+            eventElement.addEventListener("touchcancel", this.onTouchCancel, false);
+            this.eventElementBounds = eventElement.getBoundingClientRect();
+            this._eventElement = eventElement;
+        };
+        this.onTouchStart = (e) => {
+            e.preventDefault();
+            this.controllers.forEach((c) => {
+                if (c.onTouchStart) {
+                    c.onTouchStart(e);
+                }
+            });
+        };
+        this.onTouchMove = (e) => {
+            e.preventDefault();
+            this.controllers.forEach((c) => {
+                if (c.onTouchMove) {
+                    c.onTouchMove(e);
+                }
+            });
+        };
+        this.onTouchEnd = (e) => {
+            e.preventDefault();
+            this.controllers.forEach((c) => {
+                if (c.onTouchEnd) {
+                    c.onTouchEnd(e);
+                }
+            });
+        };
+        this.onTouchCancel = (e) => {
+            e.preventDefault();
+            this.controllers.forEach((c) => {
+                if (c.onTouchCancel) {
+                    c.onTouchCancel(e);
+                }
+            });
+        };
+        this.clearInputElement = () => {
+            if (!this._eventElement)
+                return;
+            this._eventElement.removeEventListener("touchstart", this.onTouchStart);
+            this._eventElement.removeEventListener("touchmove", this.onTouchMove);
+            this._eventElement.removeEventListener("touchend", this.onTouchEnd);
+            this._eventElement.removeEventListener("touchcancel", this.onTouchCancel);
+            this._eventElement = undefined;
+        };
+        this.registerController = (controller) => {
+            this.controllers.push(controller);
+        };
+        this.removeController = (controller) => {
+            const index = this.controllers.indexOf(controller);
+            if (index >= 0) {
+                this.controllers.splice(index, 1);
+            }
+        };
+    }
+    get eventElement() {
+        return this._eventElement;
+    }
+}

package/lib/Entities/UndoRedo.d.ts

@@ -0,0 +1,22 @@
+export declare type OnUndoRedoChange = () => void;
+export interface UndoRedoer {
+    undoAction: (action: UndoRedoAction) => void;
+    redoAction: (action: UndoRedoAction) => void;
+}
+export declare type DoUndoRedoAction = (action: UndoRedoAction) => void;
+export interface UndoRedo {
+    hasUndo: boolean;
+    hasRedo: boolean;
+    submitAction: (action: UndoRedoAction) => void;
+    doUndo: () => void;
+    doRedo: () => void;
+    clearStack: () => void;
+    registerUndoRedoer: (undoRedoer: UndoRedoer) => void;
+    addObserver: (observer: OnUndoRedoChange) => void;
+    removeObserver: (observer: OnUndoRedoChange) => void;
+}
+export declare function makeUndoRedo(): UndoRedo;
+export declare type UndoRedoAction = {
+    type: string;
+    payload: object;
+};

package/lib/Entities/UndoRedo.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeUndoRedo = void 0;
+const _1 = require(".");
+function makeUndoRedo() {
+    return new UndoRedoImp();
+}
+exports.makeUndoRedo = makeUndoRedo;
+class UndoRedoImp {
+    constructor() {
+        this.observers = new _1.ObserverList();
+        this.undoRedoers = [];
+        this.undoStack = [];
+        this.redoStack = [];
+        this.doUndo = () => {
+            const action = this.undoStack.pop();
+            if (!action) {
+                console.warn("[UndoRedo] nothing to undo");
+                return;
+            }
+            this.redoStack.push(action);
+            this.undoRedoers.forEach(undoers => undoers.undoAction(action));
+            this.observers.notify();
+        };
+        this.doRedo = () => {
+            const action = this.redoStack.pop();
+            if (!action) {
+                console.warn("[UndoRedo] nothing to redo");
+                return;
+            }
+            this.undoStack.push(action);
+            this.undoRedoers.forEach(redoers => redoers.redoAction(action));
+            this.observers.notify();
+        };
+        this.submitAction = (action) => {
+            this.undoStack.push(action);
+            this.redoStack = [];
+            this.observers.notify();
+        };
+        this.clearStack = () => {
+            this.redoStack = [];
+            this.undoStack = [];
+            this.observers.notify();
+        };
+        this.registerUndoRedoer = (undoredoer) => {
+            this.undoRedoers.push(undoredoer);
+        };
+        this.addObserver = (observer) => {
+            this.observers.add(observer);
+        };
+        this.removeObserver = (observer) => {
+            this.observers.remove(observer);
+        };
+    }
+    get hasUndo() {
+        return this.undoStack.length > 0;
+    }
+    get hasRedo() {
+        return this.redoStack.length > 0;
+    }
+}

package/lib/Entities/Vector2.d.ts

@@ -0,0 +1,21 @@
+export declare class Vector2 {
+    static Zero(): Vector2;
+    static One(): Vector2;
+    x: number;
+    y: number;
+    get magnitued(): number;
+    get unit(): Vector2;
+    get theta(): number;
+    setLength: (length: number) => void;
+    add: (vector2: Vector2) => Vector2;
+    subtract: (vector2: Vector2) => Vector2;
+    equal: (a: Vector2) => boolean;
+    close: (vec: Vector2) => boolean;
+    copy: () => Vector2;
+    asArray: () => [number, number];
+    rotate: (theta: number) => Vector2;
+    dot: (vec: Vector2) => number;
+    angleTo: (vec: Vector2) => number;
+    cross: (vec: Vector2) => number;
+    constructor(x: number, y: number);
+}

package/lib/Entities/Vector2.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vector2 = void 0;
+class Vector2 {
+    constructor(x, y) {
+        this.setLength = (length) => {
+            const unit = this.unit;
+            this.x = length * unit.x;
+            this.y = length * unit.y;
+        };
+        this.add = (vector2) => {
+            return new Vector2(this.x + vector2.x, this.y + vector2.y);
+        };
+        this.subtract = (vector2) => {
+            return new Vector2(this.x - vector2.x, this.y - vector2.y);
+        };
+        this.equal = (a) => {
+            if (a.x === this.x && a.y === this.y)
+                return true;
+            else
+                return false;
+        };
+        this.close = (vec) => {
+            const diff = this.subtract(vec);
+            const diffMag = diff.magnitued;
+            if (diffMag < 0.01)
+                return true;
+            else
+                return false;
+        };
+        this.copy = () => {
+            return new Vector2(this.x, this.y);
+        };
+        this.asArray = () => {
+            return [this.x, this.y];
+        };
+        this.rotate = (theta) => {
+            const thetaRadians = theta * Math.PI / 180;
+            const x = this.x * Math.cos(thetaRadians) - this.y * Math.sin(thetaRadians);
+            const y = this.x * Math.sin(thetaRadians) + this.y * Math.cos(thetaRadians);
+            return new Vector2(x, y);
+        };
+        this.dot = (vec) => {
+            return this.x * vec.x + this.y * vec.y;
+        };
+        this.angleTo = (vec) => {
+            const dot = this.dot(vec);
+            const magnitues = vec.magnitued * this.magnitued;
+            const angRadians = Math.acos(dot / magnitues);
+            return angRadians * 180 / Math.PI;
+        };
+        this.cross = (vec) => {
+            return (this.x * vec.y) - (this.y * vec.x);
+        };
+        this.x = x;
+        this.y = y;
+    }
+    static Zero() {
+        return new Vector2(0, 0);
+    }
+    static One() {
+        return new Vector2(1, 1);
+    }
+    get magnitued() {
+        const xSqr = this.x * this.x;
+        const ySqr = this.y * this.y;
+        const magnitude = Math.sqrt(xSqr + ySqr);
+        return magnitude;
+    }
+    get unit() {
+        const mag = this.magnitued;
+        if (mag === 0) {
+            return Vector2.Zero();
+        }
+        const unitX = this.x / mag;
+        const unitY = this.y / mag;
+        return new Vector2(unitX, unitY);
+    }
+    get theta() {
+        return (Math.atan2(this.y, this.x) * 180) / Math.PI;
+    }
+}
+exports.Vector2 = Vector2;

package/lib/Entities/Vector3.d.ts

@@ -0,0 +1,19 @@
+export declare class Vector3 {
+    static Zero(): Vector3;
+    static One(): Vector3;
+    x: number;
+    y: number;
+    z: number;
+    get magnitued(): number;
+    get unit(): Vector3;
+    setLength: (length: number) => void;
+    add: (a: Vector3) => Vector3;
+    subtract: (vector2: Vector3) => Vector3;
+    copy: () => Vector3;
+    equals: (vec: Vector3) => boolean;
+    close: (vec: Vector3) => boolean;
+    cross: (vec: Vector3) => Vector3;
+    dot: (vec: Vector3) => number;
+    asArray: () => [number, number, number];
+    constructor(x: number, y: number, z: number);
+}

package/lib/Entities/Vector3.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vector3 = void 0;
+class Vector3 {
+    constructor(x, y, z) {
+        this.setLength = (length) => {
+            const unit = this.unit;
+            this.x = length * unit.x;
+            this.y = length * unit.y;
+            this.z = length * unit.z;
+        };
+        this.add = (a) => {
+            return new Vector3(this.x + a.x, this.y + a.y, this.z + a.z);
+        };
+        this.subtract = (vector2) => {
+            return new Vector3(this.x - vector2.x, this.y - vector2.y, this.z - vector2.z);
+        };
+        this.copy = () => {
+            return new Vector3(this.x, this.y, this.z);
+        };
+        this.equals = (vec) => {
+            if (vec.x === this.x && vec.y === this.y && vec.z === this.z)
+                return true;
+            else
+                return false;
+        };
+        this.close = (vec) => {
+            const diff = this.subtract(vec);
+            const diffMag = diff.magnitued;
+            if (diffMag < 0.01)
+                return true;
+            else
+                return false;
+        };
+        this.cross = (vec) => {
+            const x = this.y * vec.z - this.z * vec.y;
+            const y = this.z * vec.x - this.x * vec.z;
+            const z = this.x * vec.y - this.y * vec.x;
+            return new Vector3(x, y, z);
+        };
+        this.dot = (vec) => {
+            return this.x * vec.x + this.y * vec.y + this.z * vec.z;
+        };
+        this.asArray = () => {
+            return [this.x, this.y, this.z];
+        };
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+    static Zero() {
+        return new Vector3(0, 0, 0);
+    }
+    static One() {
+        return new Vector3(1, 1, 1);
+    }
+    get magnitued() {
+        const xSqr = this.x * this.x;
+        const ySqr = this.y * this.y;
+        const zSqr = this.z * this.z;
+        const magnitude = Math.sqrt(xSqr + ySqr + zSqr);
+        return magnitude;
+    }
+    get unit() {
+        const mag = this.magnitued;
+        if (mag === 0) {
+            return Vector3.Zero();
+        }
+        const unitX = this.x / mag;
+        const unitY = this.y / mag;
+        const unitZ = this.z / mag;
+        return new Vector3(unitX, unitY, unitZ);
+    }
+}
+exports.Vector3 = Vector3;

package/lib/Entities/index.d.ts

@@ -0,0 +1,21 @@
+export * from "./Babylon";
+export * from "./BaseApp";
+export * from "./Color";
+export * from "./DevicePreview";
+export * from "./KeyboardInput";
+export * from "./LineSegment2D";
+export * from "./MemoizedBoolean";
+export * from "./MemoizedNumber";
+export * from "./MemoizedString";
+export * from "./MemoizedVector2";
+export * from "./MemoizedVector3";
+export * from "./ObserverList";
+export * from "./OrbitCamera";
+export * from "./ParametricLine";
+export * from "./ParametricPlane";
+export * from "./StateMachine";
+export * from "./UndoRedo";
+export * from "./Vector2";
+export * from "./Vector3";
+export * from "./MouseInput";
+export * from "./TouchInput";

package/lib/Entities/index.js

@@ -0,0 +1,33 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Babylon"), exports);
+__exportStar(require("./BaseApp"), exports);
+__exportStar(require("./Color"), exports);
+__exportStar(require("./DevicePreview"), exports);
+__exportStar(require("./KeyboardInput"), exports);
+__exportStar(require("./LineSegment2D"), exports);
+__exportStar(require("./MemoizedBoolean"), exports);
+__exportStar(require("./MemoizedNumber"), exports);
+__exportStar(require("./MemoizedString"), exports);
+__exportStar(require("./MemoizedVector2"), exports);
+__exportStar(require("./MemoizedVector3"), exports);
+__exportStar(require("./ObserverList"), exports);
+__exportStar(require("./OrbitCamera"), exports);
+__exportStar(require("./ParametricLine"), exports);
+__exportStar(require("./ParametricPlane"), exports);
+__exportStar(require("./StateMachine"), exports);
+__exportStar(require("./UndoRedo"), exports);
+__exportStar(require("./Vector2"), exports);
+__exportStar(require("./Vector3"), exports);
+__exportStar(require("./MouseInput"), exports);
+__exportStar(require("./TouchInput"), exports);

package/lib/Interface/Controllers/makeAppHandler.d.ts

@@ -9,4 +9,4 @@ export interface AppHandlerFunctions {
     setState: (finalState: string, duration?: number) => void;
     setDevicePreview: (x: number, y: number) => void;
 }
-export declare function makeAppHandler(functions: AppHandlerFunctions): Handler;
+export declare function makeAppHandler(functions: AppHandlerFunctions, verbose?: boolean): Handler;

package/lib/Interface/Controllers/makeAppHandler.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeAppHandler = exports.appPayloadVersions = void 0;
 const app_host_boundary_1 = require("@vived/app-host-boundary");
-const verbose = false;
 exports.appPayloadVersions = {
     disposeApp: 1,
     setDevicePreview: 1,
@@ -12,10 +11,13 @@ exports.appPayloadVersions = {
     stopApp: 1,
     setState: 2,
 };
-function makeAppHandler(functions) {
+function makeAppHandler(functions, verbose = false) {
     const handler = (request) => {
+        if (verbose) {
+            console.log(request);
+        }
         switch (request.type) {
-            case app_host_boundary_1.SHOW_BABYLON_INSPECTOR:
+            case 'SHOW_BABYLON_INSPECTOR':
                 if (request.version === exports.appPayloadVersions.showBabylonInspector) {
                     const payload = request.payload;
                     functions.showBabylonInspector(payload.showBabylonInspector);
@@ -24,7 +26,7 @@ function makeAppHandler(functions) {
                     throw new app_host_boundary_1.UnsupportedRequestVerion(request.type, request.version);
                 }
                 break;
-            case app_host_boundary_1.SET_IS_AUTHORING:
+            case 'SET_IS_AUTHORING':
                 if (request.version === exports.appPayloadVersions.setIsAuthoring) {
                     const payload = request.payload;
                     functions.setIsAuthoring(payload.isAuthoring);
@@ -33,7 +35,7 @@ function makeAppHandler(functions) {
                     throw new app_host_boundary_1.UnsupportedRequestVerion(request.type, request.version);
                 }
                 break;
-            case app_host_boundary_1.DISPOSE_APP:
+            case 'DISPOSE_APP':
                 if (request.version === exports.appPayloadVersions.disposeApp) {
                     functions.disposeApp();
                 }
@@ -41,7 +43,7 @@ function makeAppHandler(functions) {
                     throw new app_host_boundary_1.UnsupportedRequestVerion(request.type, request.version);
                 }
                 break;
-            case app_host_boundary_1.STOP_APP:
+            case 'STOP_APP':
                 if (request.version === exports.appPayloadVersions.stopApp) {
                     functions.stopApp();
                 }
@@ -49,7 +51,7 @@ function makeAppHandler(functions) {
                     throw new app_host_boundary_1.UnsupportedRequestVerion(request.type, request.version);
                 }
                 break;
-            case app_host_boundary_1.SET_DEVICE_PREVIEW:
+            case 'SET_DEVICE_PREVIEW':
                 if (request.version === exports.appPayloadVersions.setDevicePreview) {
                     const payload = request.payload;
                     functions.setDevicePreview(payload.x, payload.y);
@@ -58,7 +60,7 @@ function makeAppHandler(functions) {
                     throw new app_host_boundary_1.UnsupportedRequestVerion(request.type, request.version);
                 }
                 break;
-            case app_host_boundary_1.START_APP:
+            case 'START_APP':
                 if (request.version === exports.appPayloadVersions.startApp) {
                     const payload = request.payload;
                     functions.startApp(payload.container);
@@ -67,7 +69,7 @@ function makeAppHandler(functions) {
                     throw new app_host_boundary_1.UnsupportedRequestVerion(request.type, request.version);
                 }
                 break;
-            case app_host_boundary_1.SET_APP_STATE:
+            case 'SET_APP_STATE':
                 if (request.version === exports.appPayloadVersions.setState) {
                     const payload = request.payload;
                     functions.setState(payload.finalState, payload.duration);
@@ -76,7 +78,7 @@ function makeAppHandler(functions) {
                     throw new app_host_boundary_1.UnsupportedRequestVerion(request.type, request.version);
                 }
                 break;
-            case app_host_boundary_1.GET_APP_PAYLOAD_VERSIONS:
+            case 'GET_APP_PAYLOAD_VERSION':
                 if (request.version === 1) {
                     const payload = request.payload;
                     payload.callback(exports.appPayloadVersions);

package/lib/PresentationManagers/DevicePreviewPM.d.ts

@@ -0,0 +1,13 @@
+import { DevicePreview } from "../Entities";
+export interface DevicePreviewVM {
+    x: number;
+    y: number;
+    useDevicePreview: boolean;
+}
+export declare class DevicePreviewPM {
+    devicePreview: DevicePreview;
+    updateView: (vm: DevicePreviewVM) => void;
+    doUpdateView: () => void;
+    dispose(): void;
+    constructor(devicePreview: DevicePreview, updateView: (vm: DevicePreviewVM) => void);
+}