j-templates 6.0.25 → 6.0.26

package/DOM/createAssignment.d.ts

@@ -0,0 +1,3 @@
+export declare function CreateAssignment(target: any, createAssignment: {
+    (target: any, key: string): (next: any) => void;
+}): (next: any) => void;

package/DOM/createAssignment.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateAssignment = CreateAssignment;
+function CreateAssignment(target, createAssignment) {
+    let last;
+    let writeTo;
+    return function AssignNext(next) {
+        if (next === last)
+            return;
+        last = next;
+        writeTo ??= {};
+        const nextKeys = next && Object.keys(next);
+        for (let x = 0; nextKeys && x < nextKeys.length; x++) {
+            const key = nextKeys[x];
+            writeTo[key] ??= createAssignment(target, key);
+        }
+        const writeKeys = Object.keys(writeTo);
+        for (let x = 0; x < writeKeys.length; x++)
+            writeTo[writeKeys[x]](next);
+    };
+}

package/DOM/createEventAssignment.d.ts

@@ -1,3 +1 @@
-export declare function CreateEventAssignment(target: HTMLElement): (next: null | {
-    [event: string]: (event: Event) => void;
-}) => void;
+export declare function CreateEventAssignment(target: HTMLElement, event: string): (next: any) => void;

package/DOM/createEventAssignment.js

@@ -1,29 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CreateEventAssignment = CreateEventAssignment;
-function AssignEvent(target, event) {
-    let lastValue;
-    return function Assign(value) {
-        if (value !== lastValue) {
-            lastValue && target.removeEventListener(event, lastValue);
-            value && target.addEventListener(event, value);
-            lastValue = value;
-        }
-    };
-}
-function DefaultAssignment(target, writeTo, next, event) {
-    const value = next;
-    writeTo[event] ??= AssignEvent(target, event);
-    writeTo[event](value);
-}
-function CreateEventAssignment(target) {
-    let priorKeys;
-    const writeTo = {};
-    return function AssignNext(next) {
-        const nextKeys = next !== null ? Object.keys(next) : [];
-        const keys = priorKeys === undefined ? nextKeys : nextKeys.concat(priorKeys);
-        priorKeys = nextKeys;
-        for (let x = 0; x < keys.length; x++)
-            DefaultAssignment(target, writeTo, next && next[keys[x]], keys[x]);
+function CreateEventAssignment(target, event) {
+    let lastEvent;
+    return function (next) {
+        const nextEvent = next && next[event];
+        if (nextEvent === lastEvent)
+            return;
+        lastEvent && target.removeEventListener(event, lastEvent);
+        nextEvent && target.addEventListener(event, nextEvent);
+        lastEvent = nextEvent;
     };
 }

package/DOM/createPropertyAssignment.d.ts

@@ -1,4 +1,2 @@
-export declare function CreateNodeValueAssignment(target: HTMLElement): (value: {
-    nodeValue: string;
-}) => void;
-export declare function CreatePropertyAssignment(target: any, root?: boolean): (next: any) => void;
+export declare function CreateNodeValueAssignment(target: HTMLElement): (value: string) => void;
+export declare function CreatePropertyAssignment(target: any, prop: string): (next: any) => void;

package/DOM/createPropertyAssignment.js

@@ -3,85 +3,49 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CreateNodeValueAssignment = CreateNodeValueAssignment;
 exports.CreatePropertyAssignment = CreatePropertyAssignment;
 const jsonType_1 = require("../Utils/jsonType");
-function AssignProp(target, prop) {
-    let lastValue = target[prop];
-    return function Assign(value) {
-        if (value !== lastValue) {
-            target[prop] = value;
-            lastValue = value;
-        }
-    };
-}
+const createAssignment_1 = require("./createAssignment");
 function CreateNodeValueAssignment(target) {
     let lastValue = target.nodeValue;
     return function AssignNodeValue(value) {
-        if (value.nodeValue !== lastValue) {
-            target.nodeValue = value.nodeValue;
-            lastValue = value.nodeValue;
-        }
-    };
-}
-function CreateValueAssignment(target) {
-    let lastValue = target.value;
-    target.addEventListener('blur', function () {
-        target.value = lastValue;
-    });
-    return function AssignValue(value) {
         if (value !== lastValue) {
-            const start = target.selectionStart;
-            const end = target.selectionEnd;
-            target.value = value;
-            if (target.ownerDocument.activeElement === target)
-                target.setSelectionRange(start, end);
+            target.nodeValue = value;
             lastValue = value;
         }
     };
 }
-function ValueAssignment(target, writeTo, next) {
-    writeTo.value ??= target.nodeName === 'INPUT' ? CreateValueAssignment(target) : AssignProp(target, 'value');
-    writeTo.value(next.value);
-}
-function DefaultAssignment(target, writeTo, next, prop) {
-    const value = next && next[prop];
-    writeTo[prop] ??= (0, jsonType_1.JsonType)(value) === 'value' ?
-        AssignProp(target, prop) :
-        CreatePropertyAssignment(target[prop], false);
-    writeTo[prop](value);
+function AssignValue(target, value) {
+    const start = target.selectionStart;
+    const end = target.selectionEnd;
+    target.value = value;
+    if (target.ownerDocument.activeElement === target)
+        target.setSelectionRange(start, end);
 }
-function CreateAssignProp(target, prop) {
+function CreatePropertyAssignment(target, prop) {
     let lastValue;
     let childPropertyAssignment;
     return function (next) {
         const nextValue = next && next[prop];
         if (nextValue === lastValue)
             return;
+        lastValue = nextValue;
+        if (childPropertyAssignment !== undefined)
+            childPropertyAssignment(target[prop], nextValue);
         const nextValueType = (0, jsonType_1.JsonType)(nextValue);
         switch (nextValueType) {
             case "value":
-                target[prop] = nextValue;
+                switch (prop) {
+                    case "value":
+                        AssignValue(target, nextValue || "");
+                        break;
+                    default:
+                        target[prop] = nextValue;
+                        break;
+                }
+                break;
             default:
-                childPropertyAssignment ??= CreatePropertyAssignment(target[prop]);
+                childPropertyAssignment ??= (0, createAssignment_1.CreateAssignment)(target[prop], CreatePropertyAssignment);
                 childPropertyAssignment(target[prop], nextValue);
+                break;
         }
     };
 }
-function CreatePropertyAssignment(target, root = true) {
-    let last;
-    let writeTo;
-    return function AssignNext(next) {
-        if (next === last)
-            return;
-        last = next;
-        writeTo ??= {};
-        const nextKeys = next && Object.keys(next);
-        for (let x = 0; nextKeys && x < nextKeys.length; x++) {
-            const key = nextKeys[x];
-            if (writeTo[key] === undefined) {
-                writeTo[key] = CreateAssignProp(target, key);
-            }
-        }
-        const writeKeys = Object.keys(writeTo);
-        for (let x = 0; x < writeKeys.length; x++)
-            writeTo[writeKeys[x]](next);
-    };
-}

package/DOM/domNodeConfig.js

@@ -5,6 +5,7 @@ const window_1 = require("./window");
 const list_1 = require("../Utils/list");
 const createPropertyAssignment_1 = require("./createPropertyAssignment");
 const createEventAssignment_1 = require("./createEventAssignment");
+const createAssignment_1 = require("./createAssignment");
 let pendingUpdates = list_1.List.Create();
 let updateScheduled = false;
 const updateMs = 16;
@@ -70,8 +71,11 @@ exports.DOMNodeConfig = {
     remove(target) {
         target && target.parentNode && target.parentNode.removeChild(target);
     },
+    createTextAssignment(target) {
+        return (0, createPropertyAssignment_1.CreateNodeValueAssignment)(target);
+    },
     setText(target, text) {
-        target.textContent = text;
+        target.nodeValue = text;
     },
     getAttribute(target, attribute) {
         return target.getAttribute(attribute);
@@ -82,10 +86,10 @@ exports.DOMNodeConfig = {
     createPropertyAssignment(target) {
         if (target.nodeType === Node.TEXT_NODE)
             return (0, createPropertyAssignment_1.CreateNodeValueAssignment)(target);
-        return (0, createPropertyAssignment_1.CreatePropertyAssignment)(target);
+        return (0, createAssignment_1.CreateAssignment)(target, createPropertyAssignment_1.CreatePropertyAssignment);
     },
     createEventAssignment(target) {
-        return (0, createEventAssignment_1.CreateEventAssignment)(target);
+        return (0, createAssignment_1.CreateAssignment)(target, createEventAssignment_1.CreateEventAssignment);
     },
     fireEvent(target, event, data) {
         var cEvent = new CustomEvent(event, data);

package/Node/boundNode.js

@@ -5,36 +5,97 @@ const nodeConfig_1 = require("./nodeConfig");
 const observableScope_1 = require("../Store/Tree/observableScope");
 var BoundNode;
 (function (BoundNode) {
+    function WrapEventObject(node, events) {
+        const keys = Object.keys(events);
+        const ret = {};
+        for (let x = 0; x < keys.length; x++) {
+            const event = keys[x];
+            const eventFunc = events[event];
+            ret[event] = function (...args) {
+                if (node.destroyed)
+                    return;
+                return eventFunc(...args);
+            };
+        }
+        return ret;
+    }
     function Init(boundNode) {
         const nodeDef = boundNode.nodeDef;
         if (nodeDef.props) {
-            const scope = observableScope_1.ObservableScope.Create(nodeDef.props);
-            boundNode.scopes ??= [];
-            boundNode.scopes.push(scope);
             boundNode.assignProperties = nodeConfig_1.NodeConfig.createPropertyAssignment(boundNode.node);
-            observableScope_1.ObservableScope.Watch(scope, function (scope) { ScheduleSetProperties(boundNode, scope); });
-            const next = observableScope_1.ObservableScope.Value(scope);
-            boundNode.assignProperties(next);
+            if (typeof nodeDef.props === 'function') {
+                const scope = observableScope_1.ObservableScope.Create(nodeDef.props);
+                boundNode.scopes ??= [];
+                boundNode.scopes.push(scope);
+                observableScope_1.ObservableScope.Watch(scope, function (scope) { ScheduleSetProperties(boundNode, scope); });
+                const next = observableScope_1.ObservableScope.Value(scope);
+                boundNode.assignProperties(next);
+            }
+            else {
+                boundNode.assignProperties(nodeDef.props);
+                boundNode.assignProperties = null;
+            }
         }
         if (nodeDef.attrs) {
-            const scope = observableScope_1.ObservableScope.Create(nodeDef.attrs);
-            boundNode.scopes ??= [];
-            boundNode.scopes.push(scope);
-            observableScope_1.ObservableScope.Watch(scope, function (scope) { ScheduleSetAttributes(boundNode, scope); });
-            SetAttributes(boundNode, observableScope_1.ObservableScope.Value(scope));
+            if (typeof nodeDef.attrs === 'function') {
+                const scope = observableScope_1.ObservableScope.Create(nodeDef.attrs);
+                boundNode.scopes ??= [];
+                boundNode.scopes.push(scope);
+                observableScope_1.ObservableScope.Watch(scope, function (scope) { ScheduleSetAttributes(boundNode, scope); });
+                SetAttributes(boundNode, observableScope_1.ObservableScope.Value(scope));
+            }
+            else
+                SetAttributes(boundNode, nodeDef.attrs);
         }
         if (nodeDef.on) {
-            const scope = observableScope_1.ObservableScope.Create(nodeDef.on);
-            boundNode.scopes ??= [];
-            boundNode.scopes.push(scope);
             boundNode.assignEvents = nodeConfig_1.NodeConfig.createEventAssignment(boundNode.node);
-            observableScope_1.ObservableScope.Watch(scope, function (scope) { ScheduleSetEvents(boundNode, scope); });
-            const next = observableScope_1.ObservableScope.Value(scope);
-            boundNode.assignEvents(next);
+            if (typeof nodeDef.on === 'function') {
+                const scope = observableScope_1.ObservableScope.Create(nodeDef.on);
+                const eventScope = observableScope_1.ObservableScope.Create(function () {
+                    const events = observableScope_1.ObservableScope.Value(scope);
+                    return WrapEventObject(boundNode, events);
+                });
+                boundNode.scopes ??= [];
+                boundNode.scopes.push(scope, eventScope);
+                observableScope_1.ObservableScope.Watch(eventScope, function (scope) { ScheduleSetEvents(boundNode, scope); });
+                const next = observableScope_1.ObservableScope.Value(eventScope);
+                boundNode.assignEvents(next);
+            }
+            else {
+                boundNode.assignEvents(WrapEventObject(boundNode, nodeDef.on));
+                boundNode.assignEvents = null;
+            }
+        }
+        if (nodeDef.text) {
+            boundNode.assignText = nodeConfig_1.NodeConfig.createTextAssignment(boundNode.node);
+            if (typeof nodeDef.text === 'function') {
+                const scope = observableScope_1.ObservableScope.Create(nodeDef.text);
+                boundNode.scopes ??= [];
+                boundNode.scopes.push(scope);
+                observableScope_1.ObservableScope.Watch(scope, function (scope) { ScheduleSetText(boundNode, scope); });
+                const next = observableScope_1.ObservableScope.Value(scope);
+                boundNode.assignText(next);
+            }
+            else {
+                boundNode.assignText(nodeDef.text);
+                boundNode.assignText = null;
+            }
         }
     }
     BoundNode.Init = Init;
 })(BoundNode || (exports.BoundNode = BoundNode = {}));
+function ScheduleSetText(node, scope) {
+    if (node.setText)
+        return;
+    node.setText = true;
+    nodeConfig_1.NodeConfig.scheduleUpdate(function () {
+        node.setText = false;
+        if (node.destroyed)
+            return;
+        const next = observableScope_1.ObservableScope.Value(scope);
+        node.assignText(next);
+    });
+}
 function ScheduleSetProperties(node, scope) {
     if (node.setProperties)
         return;
@@ -44,7 +105,7 @@ function ScheduleSetProperties(node, scope) {
         if (node.destroyed)
             return;
         const next = observableScope_1.ObservableScope.Value(scope);
-        node.assignProperties(next);
+        node.assignProperties(next || null);
     });
 }
 function ScheduleSetAttributes(node, scope) {

package/Node/boundNode.types.d.ts

@@ -13,21 +13,23 @@ export interface NodeDefinition<T = any, E = any> {
     type: any;
     namespace: string;
     props?: FunctionOr<{
-        [name: string]: any;
+        [name: string]: unknown;
     }>;
     attrs?: FunctionOr<{
         [name: string]: string;
     }>;
     on?: FunctionOr<NodeRefEvents>;
+    text?: FunctionOr<string>;
 }
 export interface BoundNodeFunctionParam {
     props?: FunctionOr<{
-        [name: string]: any;
+        [name: string]: unknown;
     }>;
     attrs?: FunctionOr<{
         [name: string]: string;
     }>;
     on?: FunctionOr<NodeRefEvents>;
+    text?: FunctionOr<string>;
 }
 export interface IBoundNodeBase extends INodeRefBase {
     nodeDef: BoundNodeFunctionParam;
@@ -41,8 +43,12 @@ export interface IBoundNodeBase extends INodeRefBase {
             [event: string]: (event: Event) => void;
         }): void;
     };
+    assignText: {
+        (next: string): void;
+    };
     setAttributes: boolean;
     setEvents: boolean;
+    setText: boolean;
 }
 export interface IBoundNode extends IBoundNodeBase {
     type: NodeRefType.BoundNode;

package/Node/component.d.ts

@@ -12,9 +12,7 @@ export declare class Component<D = void, T = void, E = void> {
     protected get Data(): D;
     protected get NodeRef(): INodeRefBase;
     protected get Templates(): T;
-    constructor(data: D | {
-        (): D | Promise<D>;
-    }, templates: T, nodeRef: INodeRefBase, componentEvents: ComponentNodeEvents<E>);
+    constructor(data: D | (() => (D | Promise<D>)), templates: T, nodeRef: INodeRefBase, componentEvents: ComponentNodeEvents<E>);
     Template(): NodeRefTypes | NodeRefTypes[];
     Bound(): void;
     Fire<P extends keyof E>(event: P, data?: E[P]): void;

package/Node/component.js

@@ -27,7 +27,10 @@ class Component {
     constructor(data, templates, nodeRef, componentEvents) {
         this.nodeRef = nodeRef;
         this.componentEvents = componentEvents;
-        this.scope = new observableScope_1.ObservableScope(data);
+        if (typeof data === 'function')
+            this.scope = new observableScope_1.ObservableScope(data);
+        else
+            this.scope = new observableScope_1.ObservableScope(() => data);
         this.templates = templates || {};
     }
     Template() {

package/Node/elementNode.js

@@ -155,8 +155,8 @@ function CreateNodeArray(childrenFunc, value) {
     if (typeof newNodes === "string" || !newNodes) {
         const textNode = nodeRef_1.NodeRef.Create("text", null, nodeRef_1.NodeRefType.BoundNode);
         textNode.nodeDef = {
-            props: function () {
-                return { nodeValue: childrenFunc(value) };
+            text: function () {
+                return childrenFunc(value);
             }
         };
         return [textNode];

package/Node/nodeConfig.d.ts

@@ -18,6 +18,9 @@ export interface INodeConfig {
     removeChild(root: any, child: any): void;
     remove(target: any): void;
     fireEvent(target: any, event: string, data: any): void;
+    createTextAssignment(target: any): {
+        (next: string): void;
+    };
     createPropertyAssignment(target: any): {
         (next: any): void;
     };

package/Node/nodeRef.js

@@ -51,8 +51,10 @@ var NodeRef;
                     setProperties: false,
                     assignProperties: null,
                     assignEvents: null,
+                    assignText: null,
                     setAttributes: false,
                     setEvents: false,
+                    setText: false,
                     scopes: null
                 };
             case NodeRefType.ElementNode:
@@ -70,11 +72,13 @@ var NodeRef;
                     setProperties: false,
                     assignProperties: null,
                     assignEvents: null,
+                    assignText: null,
                     setAttributes: false,
                     setEvents: false,
                     childrenFunc: null,
                     nodeList: null,
                     setData: false,
+                    setText: false,
                     scopes: null
                 };
             case NodeRefType.ComponentNode:
@@ -201,9 +205,8 @@ var NodeRef;
         switch (node.type) {
             case NodeRefType.ComponentNode:
                 node.component?.Destroy();
-            case NodeRefType.ElementNode:
-                node.assignEvents?.(null);
             case NodeRefType.BoundNode:
+            case NodeRefType.ElementNode:
                 for (let x = 0; node.scopes && x < node.scopes.length; x++)
                     Store_1.ObservableScope.Destroy(node.scopes[x]);
         }

package/Store/Tree/observableScope.d.ts

@@ -20,7 +20,7 @@ export declare class ObservableScopeWrapper<T> extends ObservableScopeValue<T> i
     Destroy(): void;
 }
 export declare class ObservableScope<T> extends ObservableScopeWrapper<T> {
-    constructor(getFunction: T | {
+    constructor(getFunction: {
         (): T | Promise<T>;
     });
 }
@@ -36,11 +36,13 @@ export interface IObservableScope<T> extends IDestroyable {
     setCallback: EmitterCallback;
     destroyed: boolean;
     calc: any[] | null;
+    watchSet: Set<Emitter> | null;
+    watchCalc: any[] | null;
 }
 export declare namespace ObservableScope {
     function Create<T>(valueFunction: {
         (): T | Promise<T>;
-    } | T): IObservableScope<T>;
+    }): IObservableScope<T>;
     function Register(emitter: Emitter): void;
     function Calc<T>(value: T): T;
     function Value<T>(scope: IObservableScope<T>): T;

package/Store/Tree/observableScope.js

@@ -46,57 +46,50 @@ class ObservableScope extends ObservableScopeWrapper {
     }
 }
 exports.ObservableScope = ObservableScope;
-let currentSet = null;
-let currentCalc = null;
-let watching = false;
-function WatchAction(action) {
-    const parentSet = currentSet;
-    const parentCalc = currentCalc;
-    currentSet = null;
-    currentCalc = null;
-    const parentWatching = watching;
-    watching = true;
-    action();
-    const lastSet = currentSet;
-    const lastCalc = currentCalc;
-    currentSet = parentSet;
-    currentCalc = parentCalc;
-    watching = parentWatching;
-    return [lastSet, lastCalc];
+let currentScope = null;
+let currentWatching = false;
+function WatchScope(scope) {
+    const parentScope = currentScope;
+    const parentWatching = currentWatching;
+    currentScope = scope;
+    currentWatching = true;
+    const value = scope.getFunction();
+    currentScope = parentScope;
+    currentWatching = parentWatching;
+    return value;
 }
 (function (ObservableScope) {
     function Create(valueFunction) {
-        const hasFunction = typeof valueFunction === "function";
         const scope = {
-            getFunction: hasFunction ? valueFunction : null,
-            value: hasFunction ? null : valueFunction,
-            async: hasFunction
-                ? valueFunction[Symbol.toStringTag] === "AsyncFunction"
-                : false,
-            dirty: hasFunction,
-            emitter: hasFunction ? emitter_1.Emitter.Create() : null,
+            getFunction: valueFunction,
+            value: null,
+            async: valueFunction[Symbol.toStringTag] === "AsyncFunction",
+            dirty: true,
+            emitter: emitter_1.Emitter.Create(),
             emitters: [],
             destroyed: false,
             calc: null,
-            setCallback: hasFunction
-                ? function () {
-                    return OnSet(scope);
-                }
-                : null,
+            watchSet: null,
+            watchCalc: null,
+            setCallback: function () {
+                return OnSet(scope);
+            },
         };
         return scope;
     }
     ObservableScope.Create = Create;
     function Register(emitter) {
-        if (!watching || !emitter)
+        if (!currentWatching)
             return;
-        currentSet ??= new Set();
-        currentSet.add(emitter);
+        currentScope.watchSet ??= new Set();
+        currentScope.watchSet.add(emitter);
     }
     ObservableScope.Register = Register;
     function Calc(value) {
-        currentCalc ??= [];
-        currentCalc.push(value);
+        if (!currentWatching)
+            return;
+        currentScope.watchCalc ??= [];
+        currentScope.watchCalc.push(value);
         return value;
     }
     ObservableScope.Calc = Calc;
@@ -109,7 +102,7 @@ function WatchAction(action) {
     }
     ObservableScope.Value = Value;
     function Watching() {
-        return watching;
+        return currentWatching;
     }
     ObservableScope.Watching = Watching;
     function Touch(scope) {
@@ -150,29 +143,24 @@ function UpdateValue(scope) {
     if (!scope.dirty)
         return;
     scope.dirty = false;
-    let value = null;
-    const [emitters, calc] = scope.getFunction && WatchAction(() => (value = scope.getFunction()));
-    let diff = calc === null || (0, array_1.ArrayDiff)(scope.calc, calc);
-    scope.calc = calc;
-    if (diff && scope.async)
-        Promise.resolve(value).then((val) => {
-            scope.value = val;
-            emitter_1.Emitter.Emit(scope.emitter, scope);
-        });
-    else if (diff)
-        scope.value = value;
-    UpdateEmitters(scope, emitters);
-}
-function DestroyScope(scope) {
-    if (!scope)
-        return;
-    scope.emitters = null;
-    scope.emitter = null;
-    scope.getFunction = null;
-    scope.setCallback = null;
-    scope.destroyed = true;
+    const value = WatchScope(scope);
+    const change = scope.watchCalc === null || (0, array_1.ArrayDiff)(scope.calc, scope.watchCalc);
+    scope.calc = scope.watchCalc;
+    if (change) {
+        if (scope.async)
+            Promise.resolve(value).then((val) => {
+                scope.value = val;
+                emitter_1.Emitter.Emit(scope.emitter, scope);
+            });
+        else
+            scope.value = value;
+        UpdateEmitters(scope);
+    }
+    scope.watchCalc = null;
+    scope.watchSet?.clear();
 }
-function UpdateEmitters(scope, newEmitters) {
+function UpdateEmitters(scope) {
+    const newEmitters = scope.watchSet;
     if (newEmitters === null) {
         for (let x = 0; x < scope.emitters.length; x++)
             emitter_1.Emitter.Remove(scope.emitters[x], scope.setCallback);
@@ -193,3 +181,12 @@ function UpdateEmitters(scope, newEmitters) {
         emitter_1.Emitter.On(scope.emitters[x], scope.setCallback);
     removed && (0, array_1.RemoveNulls)(scope.emitters);
 }
+function DestroyScope(scope) {
+    if (!scope)
+        return;
+    scope.emitters = null;
+    scope.emitter = null;
+    scope.getFunction = null;
+    scope.setCallback = null;
+    scope.destroyed = true;
+}