j-templates 7.0.52 → 7.0.54

package/DOM/createAssignment.js

@@ -8,13 +8,14 @@ function CreateAssignment(target, createAssignment) {
         if (next === last)
             return;
         last = next;
-        const nextKeys = next && Object.keys(next);
-        for (let x = 0; nextKeys && x < nextKeys.length; x++) {
-            const key = nextKeys[x];
-            writeTo[key] ??= createAssignment(target, key);
+        for (const key in writeTo) {
+            writeTo[key](next);
+        }
+        for (const key in next) {
+            if (!Object.hasOwn(writeTo, key)) {
+                writeTo[key] = createAssignment(target, key);
+                writeTo[key](next);
+            }
         }
-        const writeFunctions = Object.values(writeTo);
-        for (let x = 0; x < writeFunctions.length; x++)
-            writeFunctions[x](next);
     };
 }

package/DOM/createEventAssignment.d.ts

@@ -1,4 +1 @@
 export declare function CreateEventAssignment(target: HTMLElement, event: string): (next: any) => void;
-export declare function AssignEvents(target: HTMLElement, eventMap: {
-    [event: string]: any;
-}): void;

package/DOM/createEventAssignment.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CreateEventAssignment = CreateEventAssignment;
-exports.AssignEvents = AssignEvents;
 function CreateEventAssignment(target, event) {
     let lastEvent;
     return function (next) {
@@ -13,8 +12,3 @@ function CreateEventAssignment(target, event) {
         lastEvent = nextEvent;
     };
 }
-function AssignEvents(target, eventMap) {
-    const entries = Object.entries(eventMap);
-    for (let x = 0; x < entries.length; x++)
-        target.addEventListener(entries[x][0], entries[x][1]);
-}

package/DOM/createPropertyAssignment.d.ts

@@ -1,7 +1 @@
-export declare function CreateNodeValueAssignment(target: HTMLElement): (value: string) => void;
-export declare function CreatePropertyAssignment(target: any): ((next: {
-    nodeValue: string;
-}) => void) | ((next: {
-    [prop: string]: any;
-}) => void);
-export declare function AssignProperties(target: any, next: any): void;
+export declare function CreateRootPropertyAssignment(target: HTMLElement, property: string): (next: any) => void;

package/DOM/createPropertyAssignment.js

@@ -1,34 +1,65 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CreateNodeValueAssignment = CreateNodeValueAssignment;
-exports.CreatePropertyAssignment = CreatePropertyAssignment;
-exports.AssignProperties = AssignProperties;
+exports.CreateRootPropertyAssignment = CreateRootPropertyAssignment;
 const json_1 = require("../Utils/json");
-function CreateNodeValueAssignment(target) {
-    let lastValue = target.nodeValue;
-    return function AssignNodeValue(value) {
-        if (value !== lastValue) {
-            target.nodeValue = value;
-            lastValue = value;
+const createAssignment_1 = require("./createAssignment");
+function CreatePropertyAssignment(target, property) {
+    let lastValue;
+    let jsonType;
+    let childAssignment;
+    return function (next) {
+        const nextValue = next && next[property];
+        if (nextValue === lastValue)
+            return;
+        jsonType ??= (0, json_1.JsonType)(nextValue);
+        switch (jsonType) {
+            case "value":
+                target[property] = nextValue;
+                break;
+            default: {
+                const childTarget = target[property];
+                childAssignment ??= (0, createAssignment_1.CreateAssignment)(childTarget, CreateRootPropertyAssignment);
+                childAssignment(nextValue);
+            }
         }
     };
 }
-function WalkValue(next, callback, index = 0, parent = "") {
-    const entries = Object.entries(next);
-    for (let x = 0; x < entries.length; x++) {
-        const [key, value] = entries[x];
-        const type = (0, json_1.JsonType)(value);
-        switch (type) {
-            case "object":
-                index = WalkValue(value, callback, index, `${parent}${key}.`);
+function CreateRootPropertyAssignment(target, property) {
+    let lastValue;
+    let jsonType;
+    let childAssignment;
+    return function (next) {
+        const nextValue = next && next[property];
+        if (nextValue === lastValue)
+            return;
+        switch (property) {
+            case "nodeValue": {
+                AssignNodeValue(target, nextValue);
+                break;
+            }
+            case "className": {
+                AssignClassName(target, nextValue);
                 break;
-            default:
-                callback(`${parent}${key}`, value, index);
-                index++;
+            }
+            case "value": {
+                AssignValue(target, nextValue);
                 break;
+            }
+            default: {
+                jsonType ??= (0, json_1.JsonType)(nextValue);
+                switch (jsonType) {
+                    case "value":
+                        target[property] = nextValue;
+                        break;
+                    default: {
+                        const childTarget = target[property];
+                        childAssignment ??= (0, createAssignment_1.CreateAssignment)(childTarget, CreatePropertyAssignment);
+                        childAssignment(nextValue);
+                    }
+                }
+            }
         }
-    }
-    return index;
+    };
 }
 function AssignNodeValue(target, value) {
     target.nodeValue = value;
@@ -43,53 +74,3 @@ function AssignValue(target, value) {
 function AssignClassName(target, value) {
     target.className = value;
 }
-function GetAssignmentFunction(path) {
-    switch (path) {
-        case "nodeValue":
-            return AssignNodeValue;
-        case "value":
-            return AssignValue;
-        case "className":
-            return AssignClassName;
-        default:
-            return new Function("t", "v", `t.${path} = v;`);
-    }
-}
-function CreatePropertyAssignment(target) {
-    if (target.nodeType === Node.TEXT_NODE) {
-        return function (next) {
-            AssignNodeValue(target, next.nodeValue);
-        };
-    }
-    const last = [
-        ["", null, null],
-    ];
-    function WalkCallback(path, value, index) {
-        if (index >= last.length || last[index][0] !== path) {
-            last[index] = [path, value, GetAssignmentFunction(path)];
-            last[index][2](target, value);
-        }
-        else if (last[index][1] !== value) {
-            last[index][1] = value;
-            last[index][2](target, value);
-        }
-    }
-    return function AssignProperty(next) {
-        if (next === null) {
-            for (let x = 0; x < last.length; x++)
-                last[x][2] !== null && last[x][2](target, null);
-            if (last.length > 0)
-                last.splice(0);
-            return;
-        }
-        const endIndex = WalkValue(next, WalkCallback);
-        if (endIndex < last.length)
-            last.splice(endIndex);
-    };
-}
-function AssignProperties(target, next) {
-    WalkValue(next, function (path, value) {
-        const assignment = GetAssignmentFunction(path);
-        assignment(target, value);
-    });
-}

package/DOM/domNodeConfig.d.ts

@@ -1,2 +1,2 @@
-import { INodeConfig } from '../Node/nodeConfig';
+import { INodeConfig } from "../Node/nodeConfig";
 export declare const DOMNodeConfig: INodeConfig;

package/DOM/domNodeConfig.js

@@ -6,7 +6,6 @@ const list_1 = require("../Utils/list");
 const createPropertyAssignment_1 = require("./createPropertyAssignment");
 const createEventAssignment_1 = require("./createEventAssignment");
 const createAssignment_1 = require("./createAssignment");
-const createPropertyAssignment_2 = require("./createPropertyAssignment");
 const createAttributeAssignment_1 = require("./createAttributeAssignment");
 let pendingUpdates = list_1.List.Create();
 let updateScheduled = false;
@@ -51,13 +50,13 @@ function wrapPriorityUpdates(callback) {
 }
 exports.DOMNodeConfig = {
     createNode(type, namespace) {
-        if (type === 'text')
-            return window_1.wndw.document.createTextNode('');
-        return namespace ?
-            window_1.wndw.document.createElementNS(namespace, type) :
-            window_1.wndw.document.createElement(type);
+        if (type === "text")
+            return window_1.wndw.document.createTextNode("");
+        return namespace
+            ? window_1.wndw.document.createElementNS(namespace, type)
+            : window_1.wndw.document.createElement(type);
     },
-    createTextNode(value = '') {
+    createTextNode(value = "") {
         return window_1.wndw.document.createTextNode(value);
     },
     isTextNode(target) {
@@ -98,9 +97,6 @@ exports.DOMNodeConfig = {
     remove(target) {
         target && target.parentNode && target.parentNode.removeChild(target);
     },
-    createTextAssignment(target) {
-        return (0, createPropertyAssignment_1.CreateNodeValueAssignment)(target);
-    },
     setText(target, text) {
         target.nodeValue = text;
     },
@@ -111,17 +107,11 @@ exports.DOMNodeConfig = {
         target.setAttribute(attribute, value);
     },
     createPropertyAssignment(target) {
-        return (0, createPropertyAssignment_2.CreatePropertyAssignment)(target);
-    },
-    assignProperties(target, next) {
-        (0, createPropertyAssignment_1.AssignProperties)(target, next);
+        return (0, createAssignment_1.CreateAssignment)(target, createPropertyAssignment_1.CreateRootPropertyAssignment);
     },
     createEventAssignment(target) {
         return (0, createAssignment_1.CreateAssignment)(target, createEventAssignment_1.CreateEventAssignment);
     },
-    assignEvents(target, next) {
-        (0, createEventAssignment_1.AssignEvents)(target, next);
-    },
     createAttributeAssignment(target) {
         return (0, createAssignment_1.CreateAssignment)(target, createAttributeAssignment_1.CreateAttributeAssignment);
     },
@@ -143,8 +133,15 @@ exports.DOMNodeConfig = {
     },
     reconcileChildren(target, children) {
         if (!target.firstChild) {
-            for (let x = 0; x < children.length; x++)
-                target.appendChild(children[x]);
+            if (children.length > 10) {
+                const fragment = new DocumentFragment();
+                for (let x = 0; x < children.length; x++)
+                    fragment.appendChild(children[x]);
+                target.appendChild(fragment);
+            }
+            else
+                for (let x = 0; x < children.length; x++)
+                    target.appendChild(children[x]);
             return;
         }
         if (children.length === 0) {
@@ -172,7 +169,14 @@ exports.DOMNodeConfig = {
         }
         while (target.lastChild !== children[x - 1])
             target.removeChild(target.lastChild);
-        for (; x < children.length; x++)
-            target.appendChild(children[x]);
-    }
+        if (children.length - x > 10) {
+            const fragment = new DocumentFragment();
+            for (; x < children.length; x++)
+                fragment.appendChild(children[x]);
+            target.appendChild(fragment);
+        }
+        else
+            for (; x < children.length; x++)
+                target.appendChild(children[x]);
+    },
 };

package/Node/nodeConfig.d.ts

@@ -20,19 +20,14 @@ 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;
     };
-    assignProperties(target: any, next: any): void;
     createEventAssignment(target: any): {
         (next: {
             [event: string]: (event: Event) => void;
         }): void;
     };
-    assignEvents(target: any, next: any): void;
     createAttributeAssignment(target: any): {
         (next: {
             [attribute: string]: string;

package/Node/vNode.d.ts

@@ -10,6 +10,7 @@ type vNodeConfig<P = HTMLElement, E = HTMLElementEventMap, T = never> = {
 };
 export declare namespace vNode {
     function Create<P = HTMLElement, E = HTMLElementEventMap, T = never>(definition: vNodeDefinition<P, E, T>): vNodeType;
+    function CreateText(text: string): vNodeType;
     function Init(vnode: vNodeType): void;
     function InitAll(vnodes: vNodeType[]): void;
     function Destroy(vnode: vNodeType): void;

package/Node/vNode.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.vNode = void 0;
 const Store_1 = require("../Store");
+const emitter_1 = require("../Utils/emitter");
 const injector_1 = require("../Utils/injector");
 const list_1 = require("../Utils/list");
 const thread_1 = require("../Utils/thread");
@@ -16,11 +17,26 @@ var vNode;
             node: definition.node ?? null,
             children: null,
             destroyed: false,
+            onDestroyed: null,
             component: null,
             scopes: [],
         };
     }
     vNode.Create = Create;
+    function CreateText(text) {
+        return {
+            definition: null,
+            type: "text",
+            injector: null,
+            node: nodeConfig_1.NodeConfig.createTextNode(text),
+            children: null,
+            destroyed: false,
+            onDestroyed: null,
+            component: null,
+            scopes: [],
+        };
+    }
+    vNode.CreateText = CreateText;
     function Init(vnode) {
         if (vnode.definition === null)
             return;
@@ -38,6 +54,7 @@ var vNode;
         vnode.destroyed = true;
         vnode.component?.Destroy();
         Store_1.ObservableScope.DestroyAll(vnode.scopes);
+        vnode.onDestroyed && emitter_1.Emitter.Emit(vnode.onDestroyed);
         vnode.children && DestroyAll(vnode.children);
     }
     vNode.Destroy = Destroy;
@@ -70,7 +87,8 @@ var vNode;
 })(vNode || (exports.vNode = vNode = {}));
 function InitNode(vnode) {
     const { type, namespace, props, attrs, on, data, componentConstructor, children, childrenArray, } = vnode.definition;
-    const node = (vnode.node = vnode.definition.node ?? nodeConfig_1.NodeConfig.createNode(type, namespace));
+    const node = (vnode.node =
+        vnode.definition.node ?? nodeConfig_1.NodeConfig.createNode(type, namespace));
     vnode.definition = null;
     if (props) {
         const assignProperties = nodeConfig_1.NodeConfig.createPropertyAssignment(node);
@@ -95,6 +113,11 @@ function InitNode(vnode) {
         }
         else
             assignEvents(on);
+        vnode.onDestroyed ??= emitter_1.Emitter.Create();
+        emitter_1.Emitter.On(vnode.onDestroyed, function () {
+            assignEvents(null);
+            return true;
+        });
     }
     if (attrs) {
         const assignAttributes = nodeConfig_1.NodeConfig.createAttributeAssignment(node);
@@ -112,7 +135,9 @@ function InitNode(vnode) {
         vnode.component = new componentConstructor(vnode);
         vnode.component.Bound();
         const componentScope = Store_1.ObservableScope.Create(function () {
-            let nodes = injector_1.Injector.Scope(vnode.injector, function () { return vnode.component.Template(); });
+            let nodes = injector_1.Injector.Scope(vnode.injector, function () {
+                return vnode.component.Template();
+            });
             if (!Array.isArray(nodes))
                 nodes = [nodes];
             return nodes;
@@ -144,8 +169,9 @@ function Children(vnode, children, data) {
     Store_1.ObservableScope.Watch(childrenScope, CreateScheduledCallback(function (scope) {
         if (vnode.destroyed)
             return;
+        const startChildren = vnode.children;
         AssignChildren(vnode, scope);
-        UpdateChildren(vnode);
+        startChildren !== vnode.children && UpdateChildren(vnode);
     }));
     AssignChildren(vnode, childrenScope);
 }
@@ -166,6 +192,7 @@ function CreateChildrenScope(vnode, children, data) {
     Store_1.ObservableScope.OnDestroyed(scope, function () {
         DestroyNodeList(nodeList);
         Store_1.ObservableScope.Destroy(dataScope);
+        return true;
     });
     return scope;
 }
@@ -209,7 +236,7 @@ function WrapChildren(injector, children, data, nodeList) {
                         list_1.List.Add(nextNodeList, {
                             data,
                             nodes: Store_1.ObservableScope.Value(childrenScope),
-                            scope: childrenScope
+                            scope: childrenScope,
                         });
                     }
                     nextNodeArray.push(...nextNodeList.tail.data.nodes);
@@ -225,14 +252,21 @@ function WrapChildren(injector, children, data, nodeList) {
 function CreateNodeArray(children, previousChildren) {
     if (Array.isArray(children))
         return children;
-    return typeof children === 'string' ? [vNode.Create({
-            type: 'text',
-            namespace: null,
-            node: previousChildren?.[0]?.type === 'text' && previousChildren[0].node || undefined,
-            props: {
-                nodeValue: children
-            }
-        })] : [children];
+    if (typeof children === "string") {
+        const firstPrevChild = previousChildren?.[0];
+        if (firstPrevChild &&
+            firstPrevChild.node &&
+            firstPrevChild.type === "text") {
+            nodeConfig_1.NodeConfig.setText(firstPrevChild.node, children);
+            return previousChildren.length === 1
+                ? previousChildren
+                : [firstPrevChild];
+        }
+        return [
+            vNode.CreateText(children),
+        ];
+    }
+    return [children];
 }
 function DestroyNodeList(nodeList) {
     for (let node = nodeList.head; node !== null; node = node.next) {
@@ -251,6 +285,10 @@ function AssignChildren(vnode, childrenScope) {
 function UpdateChildren(vnode, init = false, skipInit = false) {
     if (!vnode.children)
         return;
+    if (vnode.children.length === 1 && vnode.children[0].type === "text") {
+        nodeConfig_1.NodeConfig.reconcileChildren(vnode.node, [vnode.children[0].node]);
+        return;
+    }
     const children = vnode.children;
     (0, thread_1.Thread)(function () {
         if (vnode.destroyed || children !== vnode.children)

package/Node/vNode.types.d.ts

@@ -2,6 +2,7 @@ import { Component } from "./component";
 import { IObservableScope } from "../Store/Tree/observableScope";
 import { Injector } from "../Utils/injector";
 import { RecursivePartial } from "../Utils/utils.types";
+import { Emitter } from "../Utils/emitter";
 export type FunctionOr<T> = {
     (): T | Promise<T>;
 } | T;
@@ -20,6 +21,7 @@ export type vNode = {
     node: Node | null;
     children: vNode[] | null;
     destroyed: boolean;
+    onDestroyed: Emitter | null;
     scopes: IObservableScope<unknown>[];
     component: Component;
 };

package/Store/Tree/observableScope.d.ts

@@ -24,10 +24,6 @@ export declare class ObservableScope<T> extends ObservableScopeWrapper<T> {
         (): T | Promise<T>;
     });
 }
-interface ICalcObservable<T> {
-    id: string;
-    scope: IObservableScope<T>;
-}
 export interface IObservableScope<T> extends IDestroyable {
     getFunction: {
         (): T;
@@ -39,12 +35,14 @@ export interface IObservableScope<T> extends IDestroyable {
     dirty: boolean;
     emitter: Emitter;
     emitters: (Emitter | null)[];
-    calcScopes: ICalcObservable<unknown>[] | null;
+    calcScopes: {
+        [id: string]: IObservableScope<unknown> | null;
+    } | null;
     calc: boolean;
     onDestroyed: Emitter | null;
     destroyed: boolean;
 }
-export declare function CalcScope<T>(callback: () => T): any;
+export declare function CalcScope<T>(callback: () => T, idOverride?: string): unknown;
 export declare namespace ObservableScope {
     function Create<T>(valueFunction: {
         (): T | Promise<T>;
@@ -56,9 +54,8 @@ export declare namespace ObservableScope {
     function Touch<T>(scope: IObservableScope<T>): void;
     function Watch<T>(scope: IObservableScope<T>, callback: EmitterCallback<[IObservableScope<T>]>): void;
     function Unwatch<T>(scope: IObservableScope<T>, callback: EmitterCallback<[IObservableScope<T> | ObservableScopeValue<T>]>): void;
-    function OnDestroyed(scope: IObservableScope<unknown>, callback: () => void): void;
+    function OnDestroyed(scope: IObservableScope<unknown>, callback: EmitterCallback): void;
     function Update(scope: IObservableScope<any>): void;
     function Destroy<T>(scope: IObservableScope<T>): void;
     function DestroyAll(scopes: IObservableScope<unknown>[]): void;
 }
-export {};

package/Store/Tree/observableScope.js

@@ -56,34 +56,31 @@ function WatchScope(scope) {
     const emitters = watchState[0];
     UpdateEmitters(scope, emitters);
     const calcScopes = watchState[1];
-    for (let x = 0; calcScopes && x < calcScopes.length; x++)
-        ObservableScope.Destroy(calcScopes[x]?.scope);
+    if (calcScopes) {
+        const calcScopeValues = Object.values(calcScopes);
+        for (let x = 0; x < calcScopeValues.length; x++)
+            calcScopeValues[x] && ObservableScope.Destroy(calcScopeValues[x]);
+    }
     scope.calcScopes = watchState[2];
     watchState = parent;
     return value;
 }
-function CalcScope(callback) {
+function CalcScope(callback, idOverride) {
     if (watchState === null)
         return callback();
-    watchState[2] ??= [];
+    const nextScopes = (watchState[2] ??= {});
     const currentScopes = watchState[1];
-    const id = callback.toString();
-    if (currentScopes !== null) {
-        let index = 0;
-        for (; currentScopes[index].id !== id; index++) { }
-        if (index < currentScopes.length) {
-            const scope = currentScopes[index];
-            currentScopes[index] = null;
-            watchState[2].push(scope);
-            return ObservableScope.Value(scope.scope);
-        }
+    const id = idOverride ?? callback.toString();
+    const currentScope = currentScopes?.[id];
+    if (currentScope) {
+        delete currentScopes[id];
+        nextScopes[id] = currentScope;
     }
-    const scope = ObservableScope.Create(callback, true);
-    watchState[2].push({
-        id,
-        scope,
-    });
-    return ObservableScope.Value(scope);
+    else if (!nextScopes[id]) {
+        const scope = ObservableScope.Create(callback, true);
+        nextScopes[id] = scope;
+    }
+    return ObservableScope.Value(nextScopes[id]);
 }
 (function (ObservableScope) {
     function Create(valueFunction, calc = false) {
@@ -174,17 +171,13 @@ function CalcScope(callback) {
 function DirtyScope(scope) {
     if (scope.dirty || !scope.getFunction)
         return;
-    if (scope.calc) {
-        const startVal = scope.value;
-        scope.dirty = true;
-        UpdateValue(scope);
-        if (startVal !== scope.value)
-            emitter_1.Emitter.Emit(scope.emitter);
-        return;
-    }
     scope.dirty = true;
-    if (scope.async) {
+    if (scope.async)
+        UpdateValue(scope);
+    else if (scope.calc) {
+        const startValue = scope.value;
         UpdateValue(scope);
+        startValue !== scope.value && emitter_1.Emitter.Emit(scope.emitter, scope);
     }
     else
         emitter_1.Emitter.Emit(scope.emitter, scope);
@@ -255,12 +248,14 @@ function UpdateEmitters(scope, right) {
 function DestroyScope(scope) {
     if (!scope)
         return;
+    const scopes = scope.calcScopes && Object.values(scope.calcScopes);
+    scopes && ObservableScope.DestroyAll(scopes);
+    scope.calcScopes = null;
     scope.emitters = null;
+    emitter_1.Emitter.Clear(scope.emitter);
     scope.emitter = null;
     scope.getFunction = null;
     scope.setCallback = null;
-    for (let x = 0; scope.calcScopes && x < scope.calcScopes.length; x++)
-        ObservableScope.Destroy(scope.calcScopes[x].scope);
     scope.destroyed = true;
-    scope.onDestroyed !== null && emitter_1.Emitter.Emit(scope.onDestroyed);
+    scope.onDestroyed && emitter_1.Emitter.Emit(scope.onDestroyed);
 }

package/Utils/array.d.ts

@@ -1,4 +1,5 @@
 export declare function RemoveNulls(array: (unknown | null)[], startIndex?: number): void;
 export declare function ArrayDiff(source: any[], target: any[]): boolean;
 export declare function ReconcileSortedEmitters<T extends [number]>(left: T[], right: T[], add: (value: T) => void, remove: (value: T) => void): void;
+export declare function InsertionSortTuples<T extends [number, ...any[]]>(arr: T[]): T[];
 export declare function ReconcileSortedArrays<T>(left: T[], right: T[], add: (value: T) => void, remove: (value: T) => void): void;

package/Utils/array.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RemoveNulls = RemoveNulls;
 exports.ArrayDiff = ArrayDiff;
 exports.ReconcileSortedEmitters = ReconcileSortedEmitters;
+exports.InsertionSortTuples = InsertionSortTuples;
 exports.ReconcileSortedArrays = ReconcileSortedArrays;
 function RemoveNulls(array, startIndex = 0) {
     let nullIndex = startIndex;
@@ -50,6 +51,19 @@ function ReconcileSortedEmitters(left, right, add, remove) {
     for (let ri = rightIndex; ri < right.length; ri++)
         add(right[ri]);
 }
+function InsertionSortTuples(arr) {
+    const n = arr.length;
+    for (let i = 1; i < n; i++) {
+        const currentItem = arr[i];
+        let j = i - 1;
+        while (j >= 0 && arr[j][0] > currentItem[0]) {
+            arr[j + 1] = arr[j];
+            j--;
+        }
+        arr[j + 1] = currentItem;
+    }
+    return arr;
+}
 function ReconcileSortedArrays(left, right, add, remove) {
     let leftIndex = 0;
     let rightIndex = 0;

package/Utils/emitter.d.ts

@@ -8,6 +8,6 @@ export declare namespace Emitter {
     function Remove(emitter: Emitter, callback: EmitterCallback): void;
     function Clear(emitter: Emitter): void;
     function Distinct(emitters: Emitter[]): void;
-    function Sort(emitters: Emitter[]): Emitter[];
+    function Sort(emitters: Emitter[]): void;
     function Compare(a: Emitter, b: Emitter): number;
 }

package/Utils/emitter.js

@@ -19,15 +19,14 @@ var Emitter;
     }
     Emitter.On = On;
     function Emit(emitter, ...args) {
-        let removed = false;
+        let writePos = 1;
         for (let x = 1; x < emitter.length; x++) {
-            if (emitter[x] === null || emitter[x](...args) === true) {
-                removed = true;
-                emitter[x] = null;
-            }
+            if (emitter[x] !== null &&
+                emitter[x](...args) !== true)
+                emitter[writePos++] = emitter[x];
         }
-        if (removed)
-            (0, array_1.RemoveNulls)(emitter);
+        if (writePos < emitter.length)
+            emitter.splice(writePos);
     }
     Emitter.Emit = Emit;
     function Remove(emitter, callback) {
@@ -41,42 +40,41 @@ var Emitter;
     }
     Emitter.Clear = Clear;
     function Distinct(emitters) {
-        if (emitters.length === 1)
+        if (emitters.length < 2)
             return;
-        emitters.length < 50 ? DistinctSmall(emitters) : DistinctLarge(emitters);
+        emitters.length < 51 ? DistinctSmall(emitters) : DistinctLarge(emitters);
     }
     Emitter.Distinct = Distinct;
     function DistinctSmall(emitters) {
         Sort(emitters);
-        let lastId = -1;
-        let remove = false;
-        for (let x = 0; x < emitters.length; x++) {
-            const id = emitters[x][0];
-            if (lastId === emitters[x][0]) {
-                emitters[x] = null;
-                remove = true;
+        let writePos = 1;
+        for (let x = 1; x < emitters.length; x++) {
+            if (emitters[x][0] !== emitters[writePos - 1][0]) {
+                emitters[writePos++] = emitters[x];
             }
-            lastId = id;
         }
-        remove && (0, array_1.RemoveNulls)(emitters);
+        if (writePos < emitters.length)
+            emitters.splice(writePos);
     }
     function DistinctLarge(emitters) {
-        let remove = false;
+        let writePos = 0;
         const ids = new Set();
         for (let x = 0; x < emitters.length; x++) {
             const id = emitters[x][0];
-            if (!ids.has(id))
+            if (!ids.has(id)) {
                 ids.add(id);
-            else {
-                emitters[x] = null;
-                remove = true;
+                emitters[writePos++] = emitters[x];
             }
         }
-        remove && (0, array_1.RemoveNulls)(emitters);
+        if (writePos < emitters.length)
+            emitters.splice(writePos);
         Sort(emitters);
     }
     function Sort(emitters) {
-        return emitters.sort(Compare);
+        if (emitters.length < 11)
+            (0, array_1.InsertionSortTuples)(emitters);
+        else
+            emitters.sort(Compare);
     }
     Emitter.Sort = Sort;
     function Compare(a, b) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "j-templates",
-  "version": "7.0.52",
+  "version": "7.0.54",
   "description": "j-templates",
   "license": "MIT",
   "repository": "https://github.com/TypesInCode/jTemplates",