j-templates 7.0.72 → 7.0.74

package/DOM/index.d.ts

@@ -1,3 +1 @@
 export * from "./elements";
-export * from "./createPropertyAssignment";
-export * from "./createEventAssignment";

package/DOM/index.js

@@ -16,5 +16,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./elements"), exports);
 // export * from "./svgElements";
-__exportStar(require("./createPropertyAssignment"), exports);
-__exportStar(require("./createEventAssignment"), exports);
+// export * from "./createPropertyAssignment";
+// export * from "./createEventAssignment";

package/Node/vNode.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.vNode = void 0;
 const Store_1 = require("../Store");
 const observableScope_1 = require("../Store/Tree/observableScope");
-const emitter_1 = require("../Utils/emitter");
 const functions_1 = require("../Utils/functions");
 const injector_1 = require("../Utils/injector");
 const thread_1 = require("../Utils/thread");
@@ -22,7 +21,6 @@ var vNode;
             node: definition.node ?? null,
             children: null,
             destroyed: false,
-            onDestroyed: null,
             component: null,
             scopes: [],
         };
@@ -36,7 +34,6 @@ var vNode;
             node: nodeConfig_1.NodeConfig.createTextNode(text),
             children: null,
             destroyed: false,
-            onDestroyed: null,
             component: null,
             scopes: [],
         };
@@ -59,7 +56,6 @@ var vNode;
         vnode.destroyed = true;
         vnode.component?.Destroy();
         Store_1.ObservableScope.DestroyAll(vnode.scopes);
-        vnode.onDestroyed && emitter_1.Emitter.Emit(vnode.onDestroyed);
         for (let x = 0; vnode.children && x < vnode.children.length; x++) {
             DestroyAll(vnode.children[x][1]);
             Store_1.ObservableScope.Destroy(vnode.children[x][2]);

package/Node/vNode.types.d.ts

@@ -2,7 +2,6 @@ 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;
@@ -21,7 +20,6 @@ export type vNode = {
     node: Node | null;
     children: [any, vNode[], IObservableScope<string | vNode | vNode[]> | null][] | null;
     destroyed: boolean;
-    onDestroyed: Emitter | null;
     scopes: IObservableScope<unknown>[];
     component: Component;
 };

package/Store/Tree/observableScope.js

@@ -2,10 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObservableScope = void 0;
 exports.CalcScope = CalcScope;
-const array_1 = require("../../Utils/array");
+const bitSet_1 = require("../../Utils/bitSet");
 const emitter_1 = require("../../Utils/emitter");
 const functions_1 = require("../../Utils/functions");
-const list_1 = require("../../Utils/list");
 /**
  * Creates a dynamic (reactive) observable scope.
  * @template T The type of value stored in the scope.
@@ -46,6 +45,11 @@ function CreateStaticScope(initialValue) {
         value: initialValue,
     };
 }
+/**
+ * Queue of scopes pending batched update processing.
+ * Scopes are added when their dependencies change and greedy batching is enabled.
+ * The queue is processed in a microtask to batch multiple updates efficiently.
+ */
 let scopeQueue = [];
 /**
  * Processes all queued scopes, recomputing dirty scopes and emitting changes.
@@ -90,93 +94,78 @@ function OnSet() {
     emitter_1.Emitter.Emit(this.emitter, this);
 }
 /**
- * Registers an emitter using SAME_STRATEGY.
- * If the emitter is already registered at the current index, increments the index.
- * Otherwise, switches to PUSH_STRATEGY and appends the emitter.
- * @param state The current watch state.
- * @param emitter The emitter to register.
- */
-function RegisterSame(state, emitter) {
-    if (state.emitterIndex < state.emitters.length &&
-        state.emitters[state.emitterIndex] === emitter) {
-        state.emitterIndex++;
-        return;
-    }
-    state.emitters = state.emitters.slice(0, state.emitterIndex);
-    state.strategy = SORTED_STRATEGY;
-    RegisterSorted(state, emitter);
-}
-/**
- * Registers an emitter while maintaining sorted order by emitter ID.
- * If insertion would break sort order, falls back to PUSH_STRATEGY.
- * @param state The current watch state.
- * @param emitter The emitter to register.
+ * Strategy where emitters are accessed in the same order as the previous execution.
+ * This allows for efficient reconciliation by tracking which emitters were accessed
+ * at the same positions in the array.
  */
-function RegisterSorted(state, emitter) {
-    if (state.emitters.length === 0 ||
-        state.emitters[state.emitters.length - 1][0] < emitter[0])
-        state.emitters.push(emitter);
-    else {
-        state.strategy = PUSH_STRATEGY;
-        RegisterPush(state, emitter);
-    }
-}
-/**
- * Registers an emitter using PUSH_STRATEGY.
- * Switches to DISTINCT_STRATEGY when the emitter count exceeds 50 to optimize memory.
- * @param state The current watch state.
- * @param emitter The emitter to register.
- */
-function RegisterPush(state, emitter) {
-    state.emitters.push(emitter);
-    if (state.emitters.length > 50) {
-        const idSet = (state.emitterIds = new Set([state.emitters[0][0]]));
-        let writePos = 0;
-        for (let x = 1; x < state.emitters.length; x++) {
-            if (!idSet.has(state.emitters[x][0])) {
-                state.emitters[++writePos] = state.emitters[x];
-                idSet.add(state.emitters[x][0]);
-            }
-        }
-        writePos++;
-        if (writePos < state.emitters.length)
-            state.emitters.splice(writePos);
-        state.strategy = DISTINCT_STRATEGY;
-    }
-}
+const SAME_STRATEGY = 1;
 /**
- * Registers an emitter using DISTINCT_STRATEGY.
- * Only adds emitters that haven't been registered yet, using an ID set for O(1) lookup.
- * @param state The current watch state.
- * @param emitter The emitter to register.
+ * Strategy where new emitters are pushed to the array when accessed.
+ * Used when the access pattern changes from the previous execution.
  */
-function RegisterDistinct(state, emitter) {
-    if (!state.emitterIds.has(emitter[0])) {
-        state.emitters.push(emitter);
-        state.emitterIds.add(emitter[0]);
-    }
+const PUSH_STRATEGY = 2;
+function GetBitSetFor(emitters) {
+    const bitSet = bitSet_1.BitSetPool.Get(BIT_SET_POOL);
+    for (let x = 0; x < emitters.length; x++)
+        bitSet_1.BitSet.set(bitSet, emitters[x][0]);
+    return bitSet;
 }
 /**
- * Routes an emitter to the appropriate registration strategy based on current watch state.
- * Does nothing if not within a watch context.
- * @param emitter The emitter to register.
+ * Registers an emitter as a dependency during a watch operation.
+ *
+ * This function tracks which emitters are accessed while executing a scope's getFunction.
+ * It uses two strategies for efficiency:
+ *
+ * - **SAME_STRATEGY**: When emitters are accessed in the same order as the previous execution,
+ *   it tracks this via emitterIndex and skips array operations. Only switches to PUSH_STRATEGY
+ *   when the order changes.
+ *
+ * - **PUSH_STRATEGY**: When access order differs or is new, emitters are pushed to the array.
+ *   The BitSet prevents duplicates (same emitter accessed multiple times).
+ *
+ * The function does nothing if called outside a watch context (watchState is null).
+ *
+ * @param emitter The emitter to register as a dependency. Must have a unique ID at index 0.
  */
 function RegisterEmitter(emitter) {
     if (watchState === null)
         return;
     switch (watchState.strategy) {
-        case SAME_STRATEGY:
-            RegisterSame(watchState, emitter);
-            break;
-        case SORTED_STRATEGY:
-            RegisterSorted(watchState, emitter);
-            break;
-        case PUSH_STRATEGY:
-            RegisterPush(watchState, emitter);
+        case SAME_STRATEGY: {
+            if (watchState.emitterIndex < watchState.emitters.length &&
+                watchState.emitters[watchState.emitterIndex][0] === emitter[0]) {
+                watchState.emitterIndex++;
+                // BitSet.set(watchState.emitterIds, emitter[0]);
+            }
+            else {
+                watchState.strategy = PUSH_STRATEGY;
+                watchState.emitters = watchState.emitters.slice(0, watchState.emitterIndex);
+                RegisterEmitter(emitter);
+            }
             break;
-        case DISTINCT_STRATEGY:
-            RegisterDistinct(watchState, emitter);
+        }
+        case PUSH_STRATEGY: {
+            switch (watchState.emitters.length) {
+                case 0: {
+                    watchState.emitters.push(emitter);
+                    break;
+                }
+                case 1: {
+                    if (watchState.emitters[0][0] !== emitter[0])
+                        watchState.emitters.push(emitter);
+                    break;
+                }
+                default: {
+                    if (watchState.emitters[watchState.emitters.length - 1][0] !== emitter[0]) {
+                        watchState.emitterIds ??= GetBitSetFor(watchState.emitters);
+                        if (bitSet_1.BitSet.add(watchState.emitterIds, emitter[0]))
+                            watchState.emitters.push(emitter);
+                    }
+                    break;
+                }
+            }
             break;
+        }
     }
 }
 /**
@@ -201,47 +190,16 @@ function GetScopeValue(scope) {
     return scope.value;
 }
 /**
- * Strategy constants for optimizing emitter registration during watch operations.
- * Each strategy represents a different approach to tracking and deduplicating dependencies.
+ * Global watch state representing the current dependency tracking context.
+ * This is set during scope execution and tracks which emitters/scopes are accessed.
+ * Nested watch contexts are supported via the parent reference pattern.
  */
-const SAME_STRATEGY = 1;
-const PUSH_STRATEGY = 2;
-const SORTED_STRATEGY = 3;
-const DISTINCT_STRATEGY = 4;
-const SHRINK_STRATEGY = 5;
 let watchState = null;
-const watchPool = list_1.List.Create();
-/**
- * Creates a new watch state object, reusing from pool if available.
- * Object pooling reduces GC pressure during frequent watch operations.
- * @returns A new or recycled watch state object.
- */
-function CreateWatchState() {
-    return (list_1.List.Pop(watchPool) ?? {
-        emitterIndex: 0,
-        value: null,
-        emitters: null,
-        emitterIds: null,
-        currentCalc: null,
-        nextCalc: null,
-        strategy: PUSH_STRATEGY,
-    });
-}
 /**
- * Returns a watch state object to the pool for reuse.
- * Resets all fields to their default values before pooling.
- * @param state The watch state to return to the pool.
+ * Pool for recycling BitSet objects to reduce garbage collection overhead.
+ * BitSets are borrowed during watch operations and returned after use.
  */
-function ReturnWatchState(state) {
-    state.emitterIndex = 0;
-    state.value = null;
-    state.emitters = null;
-    state.emitterIds = null;
-    state.currentCalc = null;
-    state.nextCalc = null;
-    state.strategy = SORTED_STRATEGY;
-    list_1.List.Push(watchPool, state);
-}
+const BIT_SET_POOL = bitSet_1.BitSetPool.Create();
 /**
  * Executes a callback while tracking all scope and emitter dependencies.
  * Creates a watch context that records what was accessed during execution.
@@ -251,19 +209,18 @@ function ReturnWatchState(state) {
  */
 function WatchFunction(callback, currentCalc, initialEmitters) {
     const parent = watchState;
-    watchState = CreateWatchState();
-    watchState.emitters = initialEmitters ?? [];
-    watchState.currentCalc = currentCalc;
-    if (initialEmitters !== null)
-        watchState.strategy = SAME_STRATEGY;
+    watchState = {
+        emitterIndex: 0,
+        strategy: initialEmitters === null ? PUSH_STRATEGY : SAME_STRATEGY,
+        value: null,
+        emitters: initialEmitters ?? [],
+        emitterIds: null, // BitSetPool.Get(BIT_SET_POOL),
+        currentCalc,
+        nextCalc: null,
+    };
     watchState.value = callback();
     const resultState = watchState;
     watchState = parent;
-    if (resultState.strategy === SAME_STRATEGY &&
-        resultState.emitterIndex < resultState.emitters.length) {
-        resultState.emitters = resultState.emitters.slice(0, resultState.emitterIndex);
-        resultState.strategy = SHRINK_STRATEGY;
-    }
     return resultState;
 }
 /**
@@ -274,7 +231,11 @@ function WatchFunction(callback, currentCalc, initialEmitters) {
 function ExecuteScope(scope) {
     scope.dirty = false;
     const state = WatchFunction(scope.getFunction, scope.calcScopes, scope.emitters);
-    UpdateEmitters(scope, state.emitters, state.strategy);
+    if (state.strategy === SAME_STRATEGY &&
+        state.emitterIndex < state.emitters.length)
+        state.emitters = state.emitters.slice(0, state.emitterIndex);
+    UpdateEmitters(scope, state);
+    state.emitterIds && bitSet_1.BitSetPool.Return(BIT_SET_POOL, state.emitterIds);
     const calcScopes = state.currentCalc;
     scope.calcScopes = state.nextCalc;
     for (const key in calcScopes)
@@ -286,7 +247,6 @@ function ExecuteScope(scope) {
         });
     else
         scope.value = state.value;
-    ReturnWatchState(state);
 }
 /**
  * Creates a scope from a function, choosing between static and dynamic based on dependencies.
@@ -302,17 +262,16 @@ function ExecuteFunction(callback, greedy, allowStatic) {
     if (!allowStatic || async || state.emitters !== null) {
         const scope = CreateDynamicScope(callback, greedy, async ? null : state.value);
         scope.calcScopes = state.nextCalc;
-        UpdateEmitters(scope, state.emitters, state.strategy);
+        UpdateEmitters(scope, state);
+        state.emitterIds && bitSet_1.BitSetPool.Return(BIT_SET_POOL, state.emitterIds);
         if (async)
             state.value.then(function (result) {
                 scope.value = result;
                 emitter_1.Emitter.Emit(scope.emitter, scope);
             });
-        ReturnWatchState(state);
         return scope;
     }
     const value = state.value;
-    ReturnWatchState(state);
     return CreateStaticScope(value);
 }
 /**
@@ -335,7 +294,7 @@ function CalcScope(callback, idOverride) {
         return callback();
     const nextScopes = (watchState.nextCalc ??= {});
     const id = idOverride ?? "default";
-    if (nextScopes[id]) {
+    if (Object.hasOwn(nextScopes, id)) {
         RegisterScope(nextScopes[id]);
         return GetScopeValue(nextScopes[id]);
     }
@@ -347,39 +306,31 @@ function CalcScope(callback, idOverride) {
     return GetScopeValue(nextScopes[id]);
 }
 /**
- * Updates a scope's dependency emitters using efficient diffing.
- * Subscribes to new emitters and unsubscribes from removed ones.
- * @param scope The scope to update dependencies for.
- * @param right The new list of emitters to track.
- * @param distinct Whether emitters are already unique (sorted and deduplicated).
+ * Updates a scope's emitter subscriptions based on the new watch state.
+ * Efficiently reconciles old and new emitter lists starting from emitterIndex.
+ *
+ * Emitters before emitterIndex are in the same position and don't need updates.
+ * Emitters at/after emitterIndex are removed if no longer accessed or added if newly accessed.
+ *
+ * @param scope The scope to update emitter subscriptions for.
+ * @param state The watch state containing the new emitter list.
  */
-function UpdateEmitters(scope, right, strategy) {
-    switch (strategy) {
-        case SHRINK_STRATEGY: {
-            for (let x = right.length; x < scope.emitters.length; x++)
-                emitter_1.Emitter.Remove(scope.emitters[x], scope.setCallback);
-            break;
+function UpdateEmitters(scope, state) {
+    const currentEmitters = scope.emitters;
+    const nextEmitters = state.emitters;
+    const nextEmitterIds = state.emitterIds;
+    const sameIndex = state.emitterIndex;
+    if (currentEmitters !== null) {
+        for (let x = sameIndex; x < currentEmitters.length; x++) {
+            if (nextEmitterIds === null || !bitSet_1.BitSet.remove(nextEmitterIds, currentEmitters[x][0]))
+                emitter_1.Emitter.Remove(currentEmitters[x], scope.setCallback);
         }
-        case PUSH_STRATEGY:
-        case DISTINCT_STRATEGY:
-            strategy === PUSH_STRATEGY
-                ? emitter_1.Emitter.Distinct(right)
-                : emitter_1.Emitter.Sort(right);
-        case SORTED_STRATEGY:
-            if (scope.emitters === null || scope.emitters.length === 0) {
-                for (let x = 0; x < right.length; x++)
-                    emitter_1.Emitter.On(right[x], scope.setCallback);
-            }
-            else {
-                (0, array_1.ReconcileSortedEmitters)(scope.emitters, right, function (emitter) {
-                    emitter_1.Emitter.On(emitter, scope.setCallback);
-                }, function (emitter) {
-                    emitter_1.Emitter.Remove(emitter, scope.setCallback);
-                });
-            }
-            break;
     }
-    scope.emitters = right;
+    for (let x = sameIndex; x < nextEmitters.length; x++) {
+        if (nextEmitterIds === null || bitSet_1.BitSet.has(nextEmitterIds, nextEmitters[x][0]))
+            emitter_1.Emitter.On(nextEmitters[x], scope.setCallback);
+    }
+    scope.emitters = nextEmitters;
 }
 /**
  * Destroys multiple scopes, cleaning up their resources.
@@ -411,6 +362,7 @@ function DestroyScope(scope) {
     scope.setCallback = null;
     scope.destroyed = true;
     scope.onDestroyed && emitter_1.Emitter.Emit(scope.onDestroyed, scope);
+    scope.onDestroyed && emitter_1.Emitter.Destroy(scope.onDestroyed);
 }
 var ObservableScope;
 (function (ObservableScope) {

package/Utils/bitSet.d.ts

@@ -0,0 +1,23 @@
+export type BitSet = {
+    init: boolean;
+    buffer: Uint32Array | null;
+    activeFrames: Set<number>;
+    minFrame: number;
+    maxFrame: number;
+};
+export type BitSetPool = {
+    pool: BitSet[];
+    index: number;
+};
+export declare namespace BitSetPool {
+    function Create(): BitSetPool;
+    function Get(pool: BitSetPool): BitSet;
+    function Return(pool: BitSetPool, bitSet: BitSet): void;
+}
+export declare namespace BitSet {
+    function Create(): BitSet;
+    function set(set: BitSet, num: number): void;
+    function has(set: BitSet, num: number): boolean;
+    function add(set: BitSet, num: number): boolean;
+    function remove(set: BitSet, num: number): boolean;
+}

package/Utils/bitSet.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitSet = exports.BitSetPool = void 0;
+// 100000 = 31
+const FRAME_BIT_SHIFT = 5;
+const DEFAULT_FRAME_COUNT = 1024;
+const DEFAULT_FRAME_HALF = DEFAULT_FRAME_COUNT / 2;
+function GetFrame(number) {
+    // Effectively equivalent to Math.floor(number / 32)
+    return number >>> FRAME_BIT_SHIFT;
+}
+function GetBit(number) {
+    // JavaScript only uses rightmost 5 bits of num for this operation
+    // Effectively equivalent to number % 32
+    return 1 << number;
+}
+function Resize(set, frame) {
+    if (set.minFrame <= frame && frame < set.maxFrame)
+        return;
+    const currentSize = set.maxFrame - set.minFrame;
+    let newMin = Math.min(set.minFrame, frame);
+    let newMax = Math.max(set.maxFrame, frame + 1);
+    let newSize = newMax - newMin;
+    const minimumNewSize = currentSize * 2;
+    if (newSize < minimumNewSize) {
+        const growBy = minimumNewSize - newSize;
+        const growByHalf = growBy / 2;
+        newMin = newMin - Math.floor(growByHalf);
+        newMax = newMax + Math.ceil(growByHalf);
+        if (newMin < 0) {
+            newMax -= newMin;
+            newMin = 0;
+        }
+        newSize = newMax - newMin;
+    }
+    const newBuffer = new Uint32Array(newSize);
+    newBuffer.set(set.buffer, set.minFrame - newMin);
+    set.buffer = newBuffer;
+    set.minFrame = newMin;
+    set.maxFrame = newMax;
+}
+function Initialize(set, initFrameNumber) {
+    if (set.init)
+        return;
+    set.init = true;
+    set.activeFrames.clear();
+    const frame = GetFrame(initFrameNumber);
+    const sizeHalf = (set.buffer?.length ?? DEFAULT_FRAME_COUNT) / 2;
+    set.buffer ??= new Uint32Array(DEFAULT_FRAME_COUNT);
+    set.minFrame = frame - Math.floor(sizeHalf);
+    set.maxFrame = frame + Math.ceil(sizeHalf);
+    if (set.minFrame < 0) {
+        set.maxFrame -= set.minFrame;
+        set.minFrame = 0;
+    }
+}
+var BitSetPool;
+(function (BitSetPool) {
+    function Create() {
+        return {
+            pool: [],
+            index: 0
+        };
+    }
+    BitSetPool.Create = Create;
+    function Get(pool) {
+        return pool.index === 0 ? BitSet.Create() : pool.pool[--pool.index];
+    }
+    BitSetPool.Get = Get;
+    function Return(pool, bitSet) {
+        bitSet.init = false;
+        pool.pool[pool.index++] = bitSet;
+    }
+    BitSetPool.Return = Return;
+})(BitSetPool || (exports.BitSetPool = BitSetPool = {}));
+var BitSet;
+(function (BitSet) {
+    function Create() {
+        return {
+            init: false,
+            buffer: null,
+            activeFrames: new Set(),
+            minFrame: -1,
+            maxFrame: -1,
+        };
+    }
+    BitSet.Create = Create;
+    function set(set, num) {
+        Initialize(set, num);
+        const frame = GetFrame(num);
+        Resize(set, frame);
+        if (!set.activeFrames.has(frame)) {
+            set.buffer[frame] = 0;
+            set.activeFrames.add(frame);
+        }
+        const frameOffset = frame - set.minFrame;
+        set.buffer[frameOffset] |= GetBit(num);
+    }
+    BitSet.set = set;
+    function has(set, num) {
+        if (set.buffer === null)
+            return false;
+        const frame = GetFrame(num);
+        if (!set.activeFrames.has(frame))
+            return false;
+        if (frame < set.minFrame || set.maxFrame <= frame)
+            return false;
+        const frameOffset = frame - set.minFrame;
+        const frameValue = set.buffer[frameOffset] & GetBit(num);
+        return frameValue !== 0;
+    }
+    BitSet.has = has;
+    function add(set, num) {
+        Initialize(set, num);
+        const frame = GetFrame(num);
+        Resize(set, frame);
+        if (!set.activeFrames.has(frame)) {
+            set.buffer[frame] = 0;
+            set.activeFrames.add(frame);
+        }
+        const frameOffset = frame - set.minFrame;
+        const frameStart = set.buffer[frameOffset];
+        set.buffer[frameOffset] |= GetBit(num);
+        return frameStart !== set.buffer[frameOffset];
+    }
+    BitSet.add = add;
+    function remove(set, num) {
+        if (set.buffer === null)
+            return false;
+        const frame = GetFrame(num);
+        if (!set.activeFrames.has(frame) || frame < set.minFrame || set.maxFrame <= frame)
+            return false;
+        const frameOffset = frame - set.minFrame;
+        const frameStart = set.buffer[frameOffset];
+        set.buffer[frameOffset] ^= GetBit(num);
+        return frameStart !== set.buffer[frameOffset];
+    }
+    BitSet.remove = remove;
+})(BitSet || (exports.BitSet = BitSet = {}));

package/Utils/emitter.d.ts

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

package/Utils/emitter.js

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Emitter = void 0;
-const array_1 = require("./array");
+const idPool = [];
+let idPoolIndex = 0;
+let globalId = 0;
 var Emitter;
 (function (Emitter) {
-    let globalId = 0;
     function Create() {
-        const emitter = [++globalId];
+        const emitterId = idPoolIndex === 0 ? ++globalId : idPool[--idPoolIndex];
+        const emitter = [emitterId];
         return emitter;
     }
     Emitter.Create = Create;
@@ -33,6 +35,7 @@ var Emitter;
     }
     Emitter.Emit = Emit;
     function Destroy(emitter) {
+        idPool[idPoolIndex++] = emitter[0];
         emitter[0] = -1;
     }
     Emitter.Destroy = Destroy;
@@ -48,30 +51,4 @@ var Emitter;
         emitter.splice(1);
     }
     Emitter.Clear = Clear;
-    function Distinct(emitters) {
-        if (emitters.length < 2)
-            return;
-        Sort(emitters);
-        let writePos = 0;
-        for (let x = 1; x < emitters.length; x++) {
-            if (emitters[x][0] !== emitters[writePos][0]) {
-                emitters[++writePos] = emitters[x];
-            }
-        }
-        writePos++;
-        if (writePos < emitters.length)
-            emitters.splice(writePos);
-    }
-    Emitter.Distinct = Distinct;
-    function Sort(emitters) {
-        if (emitters.length < 11)
-            (0, array_1.InsertionSortTuples)(emitters);
-        else
-            emitters.sort(Compare);
-    }
-    Emitter.Sort = Sort;
-    function Compare(a, b) {
-        return a[0] - b[0];
-    }
-    Emitter.Compare = Compare;
 })(Emitter || (exports.Emitter = Emitter = {}));

package/package.json

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