j-templates 7.0.90 → 7.0.92

package/Store/Tree/observableScope.js

@@ -2,10 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObservableScope = void 0;
 exports.InlineScope = InlineScope;
+exports.MappedScope = MappedScope;
 exports.GateScope = GateScope;
 exports.PeekScope = PeekScope;
 const emitter_1 = require("../../Utils/emitter");
 const functions_1 = require("../../Utils/functions");
+function Invoke(param, callback) {
+    return callback(param);
+}
 /**
  * Creates a dynamic (reactive) observable scope.
  * @template T The type of value stored in the scope.
@@ -28,12 +32,22 @@ function CreateDynamicScope(getFunction, greedy, value) {
         value,
         emitter: emitter_1.Emitter.Create(),
         emitters: null,
+        onUpdated: null,
         onDestroyed: null,
         scopes: null,
+        mappedScopes: null,
     };
     scope.setCallback = OnSet.bind(scope);
     return scope;
 }
+function CreateBasicScope(getFunction) {
+    return {
+        type: "basic",
+        getFunction,
+        emitter: emitter_1.Emitter.Create(),
+        destroyed: false
+    };
+}
 /**
  * Creates a static (non-reactive) observable scope.
  * Static scopes are optimized for values that never change and don't need dependency tracking.
@@ -45,6 +59,8 @@ function CreateStaticScope(initialValue) {
     return {
         type: "static",
         value: initialValue,
+        onDestroyed: null,
+        destroyed: false
     };
 }
 let scopeQueue = [];
@@ -173,6 +189,8 @@ function RegisterScope(scope) {
  * @returns The scope's current value.
  */
 function GetScopeValue(scope) {
+    if (scope.type === "basic")
+        return scope.getFunction();
     if (scope.type === "static" || !scope.dirty || scope.destroyed)
         return scope.value;
     ExecuteScope(scope);
@@ -195,15 +213,17 @@ let watchState = null;
  * @param currentCalc Optional map of existing inline scopes to reuse.
  * @returns The watch state containing tracked dependencies and result.
  */
-function WatchFunction(callback, currentCalc, initialEmitters) {
+function WatchFunction(callback, currentScopes, currentMappedScopes, initialEmitters) {
     const parent = watchState;
     watchState = {
         emitterIndex: 0,
         value: null,
         emitters: initialEmitters,
         emitterSet: null,
-        currentCalc,
-        nextCalc: null,
+        currentScopes,
+        nextScopes: null,
+        currentMappedScopes: currentMappedScopes,
+        nextMappedScopes: null,
         strategy: initialEmitters === null ? INIT_STRATEGY : SAME_STRATEGY,
     };
     watchState.value = callback();
@@ -223,24 +243,35 @@ function WatchFunction(callback, currentCalc, initialEmitters) {
  */
 function ExecuteScope(scope) {
     scope.dirty = false;
-    const state = WatchFunction(scope.getFunction, scope.scopes, scope.emitters);
+    const state = WatchFunction(scope.getFunction, scope.scopes, scope.mappedScopes, scope.emitters);
     UpdateEmitters(scope, state);
-    const calcScopes = state.currentCalc;
-    scope.scopes = state.nextCalc;
-    for (const key in calcScopes)
-        DestroyScope(calcScopes[key]);
+    const currentScopes = state.currentScopes;
+    scope.scopes = state.nextScopes;
+    const currentMappedScopes = state.currentMappedScopes;
+    scope.mappedScopes = state.nextMappedScopes;
+    if (currentScopes)
+        for (let x = 0; x < currentScopes.length; x++)
+            currentScopes[x] && DestroyScope(currentScopes[x][1]);
+    if (currentMappedScopes && currentMappedScopes.size > 0)
+        for (const scopes of currentMappedScopes.values())
+            DestroyAllScopes(scopes);
     if (scope.async) {
         const promise = (scope.pending = state.value);
         promise.then(function (result) {
             if (scope.destroyed || scope.pending !== promise)
                 return;
             scope.pending = null;
+            const lastValue = scope.value;
             scope.value = result;
+            scope.onUpdated && emitter_1.Emitter.Emit(scope.onUpdated, lastValue, scope);
             emitter_1.Emitter.Emit(scope.emitter, scope);
         });
     }
-    else
+    else {
+        const lastValue = scope.value;
         scope.value = state.value;
+        scope.onUpdated && emitter_1.Emitter.Emit(scope.onUpdated, lastValue, scope);
+    }
 }
 /**
  * Creates a scope from a function, choosing between static and dynamic based on dependencies.
@@ -250,15 +281,15 @@ function ExecuteScope(scope) {
  * @param allowStatic Whether to return a static scope if no dependencies are found.
  * @returns A new observable scope.
  */
-function ExecuteFunction(callback, greedy, allowStatic) {
+function ExecuteFunction(callback, greedy) {
     const async = (0, functions_1.IsAsync)(callback);
-    const state = WatchFunction(callback, null, null);
-    if (!allowStatic || async || state.emitters !== null) {
+    const state = WatchFunction(callback, null, null, null);
+    if (async || state.emitters !== null) {
         const scope = CreateDynamicScope(callback, greedy, async ? null : state.value);
-        scope.scopes = state.nextCalc;
+        scope.scopes = state.nextScopes;
+        scope.mappedScopes = state.nextMappedScopes;
         UpdateEmitters(scope, state);
         if (async) {
-            console.log("resolving async scope");
             const promise = (scope.pending = state.value);
             promise.then(function (result) {
                 if (scope.destroyed || scope.pending !== promise)
@@ -273,17 +304,57 @@ function ExecuteFunction(callback, greedy, allowStatic) {
     const value = state.value;
     return CreateStaticScope(value);
 }
-function ScopeHelper(callback, id, greedy) {
-    const nextScopes = (watchState.nextCalc ??= {});
-    if (nextScopes[id])
-        return nextScopes[id];
-    const currentScopes = watchState.currentCalc;
-    nextScopes[id] =
-        currentScopes?.[id] ?? ExecuteFunction(callback, greedy, true);
-    if (currentScopes?.[id])
-        delete currentScopes[id];
-    return nextScopes[id];
+function ScopeHelper(callback, key, greedy) {
+    const nextScopes = (watchState.nextScopes ??= []);
+    const currentScopes = watchState.currentScopes;
+    let x = 0;
+    if (currentScopes)
+        for (; x < currentScopes.length && (currentScopes[x] === null || currentScopes[x][0] !== key); x++) { }
+    if (!currentScopes || x === currentScopes.length) {
+        const nextScope = ExecuteFunction(callback, greedy);
+        nextScopes.push([key, nextScope]);
+        return nextScope;
+    }
+    const nextScopePair = currentScopes[x];
+    currentScopes[x] = null;
+    nextScopes.push(nextScopePair);
+    return nextScopePair[1];
 }
+function MappedScopeHelper(callback, data, onUpdated, onDestroyed) {
+    const nextScopes = (watchState.nextMappedScopes ??= new Map());
+    const currentScopes = watchState.currentMappedScopes;
+    if (currentScopes?.has(data)) {
+        const nextScopeArray = currentScopes.get(data);
+        if (nextScopeArray.length === 1) {
+            currentScopes.delete(data);
+            nextScopes.set(data, nextScopeArray);
+            return nextScopeArray[0];
+        }
+        const nullIndex = nextScopeArray.lastIndexOf(null);
+        const valueIndex = nullIndex < 0 ? 0 : nullIndex + 1;
+        if (valueIndex === nextScopeArray.length - 1)
+            currentScopes.delete(data);
+        else {
+            const scope = nextScopeArray[valueIndex];
+            nextScopeArray[valueIndex] = null;
+            const scopes = nextScopes.get(data) ?? [];
+            scopes.push(scope);
+            nextScopes.set(data, scopes);
+            return scope;
+        }
+    }
+    const getFunction = Invoke.bind(null, data, callback);
+    const scope = ExecuteFunction(getFunction, false);
+    onUpdated && ObservableScope.OnUpdated(scope, onUpdated);
+    onDestroyed && ObservableScope.OnDestroyed(scope, onDestroyed);
+    const scopes = nextScopes.get(data) ?? [];
+    scopes.push(scope);
+    nextScopes.set(data, scopes);
+    return scope;
+}
+const SCOPE_DEFAULT = Symbol("SCOPE_DEFAULT");
+const GATE_DEFAULT = Symbol("GATE_DEFAULT");
+const PEEK_DEFAULT = Symbol("PEEK_DEFAULT");
 /**
  * Creates an inline computed scope registered as a dependency of the parent.
  * The scope is memoized by ID and reused across reads within the same parent evaluation.
@@ -304,11 +375,19 @@ function InlineScope(callback, idOverride) {
     if (watchState === null) {
         throw new Error("scope() must be called within a watch context");
     }
-    const id = idOverride ?? "scope_default";
+    const id = idOverride ?? SCOPE_DEFAULT;
     const scope = ScopeHelper(callback, id, false);
     RegisterScope(scope);
     return GetScopeValue(scope);
 }
+function MappedScope(data, callback, onUpdated, onDestroyed) {
+    if (watchState === null) {
+        throw new Error("scope() must be called within a watch context");
+    }
+    const scope = MappedScopeHelper(callback, data, onUpdated, onDestroyed);
+    RegisterScope(scope);
+    return GetScopeValue(scope);
+}
 /**
  * Creates a gatekeeper scope that only emits when the value actually changes (===).
  * Prevents unnecessary downstream re-evaluations when the derived value stays the same.
@@ -331,7 +410,7 @@ function GateScope(callback, idOverride) {
     if (watchState === null) {
         throw new Error("gate() must be called within a watch context");
     }
-    const id = idOverride ?? "gate_default";
+    const id = idOverride ?? GATE_DEFAULT;
     const scope = ScopeHelper(callback, id, true);
     RegisterScope(scope);
     return GetScopeValue(scope);
@@ -360,7 +439,7 @@ function PeekScope(callback, idOverride) {
     if (watchState === null) {
         throw new Error("peek() must be called within a watch context");
     }
-    const id = idOverride ?? "peek_default";
+    const id = idOverride ?? PEEK_DEFAULT;
     const scope = ScopeHelper(callback, id, false);
     return GetScopeValue(scope);
 }
@@ -421,23 +500,38 @@ function DestroyAllScopes(scopes) {
  * @param scope The scope to destroy.
  */
 function DestroyScope(scope) {
-    if (!scope || scope.type === "static")
+    if (!scope || scope.destroyed)
         return;
-    for (const key in scope.scopes)
-        DestroyScope(scope.scopes[key]);
-    // Emitter.Destroy(scope.emitter);
-    emitter_1.Emitter.DestroyCallback(scope.setCallback);
-    if (scope.emitters !== null)
-        for (let x = 0; x < scope.emitters.length; x++)
-            emitter_1.Emitter.Compact(scope.emitters[x]);
-    scope.value = undefined;
-    scope.scopes = null;
-    scope.emitters = null;
-    scope.emitter = null;
-    scope.getFunction = null;
-    scope.setCallback = null;
     scope.destroyed = true;
-    scope.onDestroyed && emitter_1.Emitter.Emit(scope.onDestroyed, scope);
+    switch (scope.type) {
+        case "basic": {
+            scope.emitter = null;
+            break;
+        }
+        case "dynamic": {
+            if (scope.scopes)
+                for (let x = 0; x < scope.scopes.length; x++)
+                    DestroyScope(scope.scopes[x][1]);
+            if (scope.mappedScopes && scope.mappedScopes.size > 0)
+                for (const childScopes of scope.mappedScopes.values())
+                    DestroyAllScopes(childScopes);
+            if (scope.emitters !== null)
+                for (let x = 0; x < scope.emitters.length; x++)
+                    emitter_1.Emitter.Remove(scope.emitters[x], scope.setCallback);
+            scope.scopes = null;
+            scope.mappedScopes = null;
+            scope.emitters = null;
+            scope.emitter = null;
+            scope.getFunction = null;
+            scope.setCallback = null;
+        }
+        case "static": {
+            const lastValue = scope.value;
+            scope.value = undefined;
+            scope.onDestroyed && emitter_1.Emitter.Emit(scope.onDestroyed, lastValue);
+            break;
+        }
+    }
 }
 var ObservableScope;
 (function (ObservableScope) {
@@ -449,10 +543,18 @@ var ObservableScope;
      * @param force If true, always creates a dynamic scope even without dependencies. Defaults to false.
      * @returns A new observable scope.
      */
-    function Create(valueFunction, greedy = false, force = false) {
-        return ExecuteFunction(valueFunction, greedy, !force);
+    function Create(valueFunction) {
+        return ExecuteFunction(valueFunction, false);
     }
     ObservableScope.Create = Create;
+    function Greedy(valueFunction) {
+        return ExecuteFunction(valueFunction, true);
+    }
+    ObservableScope.Greedy = Greedy;
+    function Basic(valueFunction) {
+        return CreateBasicScope(valueFunction);
+    }
+    ObservableScope.Basic = Basic;
     /**
      * Registers an emitter as a dependency for the current watch context.
      * @param emitter The emitter to register as a dependency.
@@ -478,7 +580,7 @@ var ObservableScope;
      * @returns The scope's current value.
      */
     function Value(scope) {
-        if (!scope)
+        if (!scope || scope.destroyed)
             return undefined;
         Touch(scope);
         return Peek(scope);
@@ -490,7 +592,7 @@ var ObservableScope;
      * @param scope The scope to register as a dependency.
      */
     function Touch(scope) {
-        if (!scope)
+        if (!scope || scope.destroyed)
             return;
         RegisterScope(scope);
     }
@@ -502,7 +604,7 @@ var ObservableScope;
      * @param callback Function to invoke when the scope's value changes.
      */
     function Watch(scope, callback) {
-        if (!scope || scope.type === "static")
+        if (!scope || scope.destroyed || scope.type === "static")
             return;
         emitter_1.Emitter.On(scope.emitter, callback);
     }
@@ -514,19 +616,24 @@ var ObservableScope;
      * @param callback The callback function to remove.
      */
     function Unwatch(scope, callback) {
-        if (!scope || scope.type === "static")
+        if (!scope || scope.destroyed || scope.type === "static")
             return;
         emitter_1.Emitter.Remove(scope.emitter, callback);
     }
     ObservableScope.Unwatch = Unwatch;
+    function OnUpdated(scope, callback) {
+        if (scope.type !== "dynamic")
+            return;
+        scope.onUpdated ??= emitter_1.Emitter.Create();
+        emitter_1.Emitter.On(scope.onUpdated, callback);
+    }
+    ObservableScope.OnUpdated = OnUpdated;
     /**
      * Registers a callback to be invoked when the scope is destroyed.
      * @param scope The scope to monitor for destruction.
      * @param callback Function to invoke when the scope is destroyed.
      */
     function OnDestroyed(scope, callback) {
-        if (scope.type === "static")
-            return;
         scope.onDestroyed ??= emitter_1.Emitter.Create();
         emitter_1.Emitter.On(scope.onDestroyed, callback);
     }
@@ -536,9 +643,12 @@ var ObservableScope;
      * @param scope The scope to mark for update.
      */
     function Update(scope) {
-        if (!scope || scope.type === "static")
+        if (!scope || scope.destroyed || scope.type === "static")
             return;
-        // OnSet(scope);
+        if (scope.type === "basic") {
+            emitter_1.Emitter.Emit(scope.emitter, this);
+            return;
+        }
         scope.setCallback();
     }
     ObservableScope.Update = Update;

package/Utils/decorators.js

@@ -134,7 +134,7 @@ function GetDestroyArrayForPrototype(prototype, create = true) {
     return array;
 }
 function CreateComputedScope(getter, store, defaultValue) {
-    const getterScope = observableScope_1.ObservableScope.Create(getter, true);
+    const getterScope = observableScope_1.ObservableScope.Greedy(getter);
     observableScope_1.ObservableScope.Watch(getterScope, (scope) => {
         const data = observableScope_1.ObservableScope.Peek(scope);
         store.Write(data, "root");
@@ -566,9 +566,9 @@ function Value() {
  * @returns An observable scope created from the tuple's value.
  */
 function CreateValueScope(tuple) {
-    return observableScope_1.ObservableScope.Create(function () {
+    return observableScope_1.ObservableScope.Basic(function () {
         return tuple[1];
-    }, false, true);
+    });
 }
 /**
  * Value decorator implementation for creating value properties.
@@ -814,7 +814,7 @@ function WatchDecorator(target, propertyKey, descriptor, scopeFunction) {
         function scopeFunctionWrapper() {
             return scopeFunction(instance);
         }
-        const scope = observableScope_1.ObservableScope.Create(scopeFunctionWrapper, true);
+        const scope = observableScope_1.ObservableScope.Greedy(scopeFunctionWrapper);
         const propertyMap = GetScopeMapForInstance(this);
         propertyMap[propertyKey] = [scope, undefined];
         observableScope_1.ObservableScope.Watch(scope, function (scope) {

package/Utils/emitter.d.ts

@@ -1,9 +1,7 @@
 export type EmitterCallback<T extends readonly any[] = any[]> = (...args: T) => void;
-export type Emitter = EmitterCallback[];
+export type Emitter = [number, ...EmitterCallback[]];
 export declare namespace Emitter {
     function Create(): Emitter;
-    function Compact(emitter: Emitter): void;
-    function DestroyCallback(callback: EmitterCallback): void;
     function On(emitter: Emitter, callback: EmitterCallback): void;
     function Emit(emitter: Emitter, ...args: any[]): void;
     function Remove(emitter: Emitter, callback: EmitterCallback): void;

package/Utils/emitter.js

@@ -1,116 +1,67 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Emitter = void 0;
+const scheduleCallback = typeof requestIdleCallback !== "undefined"
+    ? requestIdleCallback
+    : setTimeout;
+const pendingCompactEmitters = new Set();
+function Compact(emitter) {
+    if (emitter.length === 1 || emitter[0] === 0)
+        return;
+    pendingCompactEmitters.add(emitter);
+    ScheduleCompact();
+}
+let compactScheduled = false;
+function ScheduleCompact() {
+    if (compactScheduled)
+        return;
+    compactScheduled = true;
+    scheduleCallback(PerformCompact);
+}
+function PerformCompact() {
+    compactScheduled = false;
+    let compactEmitters = Array.from(pendingCompactEmitters);
+    pendingCompactEmitters.clear();
+    for (let x = 0; x < compactEmitters.length; x++)
+        CompactEmitter(compactEmitters[x]);
+}
+function CompactEmitter(emitter) {
+    if (emitter[0] === 0)
+        return;
+    emitter.splice(1, emitter[0]);
+    emitter[0] = 0;
+}
 var Emitter;
 (function (Emitter) {
-    const destroyed = new WeakSet();
-    // const pendingCompactEmitters = new Set<Emitter>();
-    let pendingCompactEmitters = [];
     function Create() {
-        return [];
+        return [0];
     }
     Emitter.Create = Create;
-    const scheduleCallback = typeof requestIdleCallback !== "undefined"
-        ? requestIdleCallback
-        : setTimeout;
-    function Compact(emitter) {
-        if (emitter.length === 0)
-            return;
-        pendingCompactEmitters.push(emitter);
-        ScheduleCompact();
-    }
-    Emitter.Compact = Compact;
-    let compactScheduled = false;
-    function ScheduleCompact() {
-        if (compactScheduled)
-            return;
-        compactScheduled = true;
-        scheduleCallback(PerformCompact);
-    }
-    function PerformCompact() {
-        compactScheduled = false;
-        let compactEmitters = pendingCompactEmitters;
-        pendingCompactEmitters = [];
-        const processedEmitters = new Set();
-        for (let x = 0; x < compactEmitters.length; x++)
-            if (!processedEmitters.has(compactEmitters[x])) {
-                CompactEmitter(compactEmitters[x]);
-                processedEmitters.add(compactEmitters[x]);
-            }
-    }
-    /* export function Compact(emitter: Emitter) {
-      if (emitter.length === 0 || destroyed.has(emitter)) {
-        return;
-      }
-  
-      if (pendingCompactEmitters.size === 0) {
-        scheduleCallback(CompactPending);
-      }
-  
-      pendingCompactEmitters.add(emitter);
-    }
-  
-    function CompactPending() {
-      if (pendingCompactEmitters.size === 0) return;
-  
-      const pending = Array.from(pendingCompactEmitters);
-      pendingCompactEmitters.clear();
-  
-      for (let x = 0; x < pending.length; x++)
-        if (!destroyed.has(pending[x])) CompactEmitter(pending[x]);
-    } */
-    function CompactEmitter(emitter) {
-        let count = 0;
-        for (; count < emitter.length &&
-            (emitter[count] === null || destroyed.has(emitter[count])); count++) { }
-        if (count > 0)
-            emitter.splice(0, count);
-        let writePos = 0;
-        for (let x = 0; x < emitter.length; x++) {
-            if (emitter[x] !== null && !destroyed.has(emitter[x]))
-                emitter[writePos++] = emitter[x];
-        }
-        if (writePos < emitter.length)
-            emitter.splice(writePos);
-    }
-    function DestroyCallback(callback) {
-        destroyed.add(callback);
-    }
-    Emitter.DestroyCallback = DestroyCallback;
-    /* export function Destroy(emitter: Emitter) {
-      pendingCompactEmitters.delete(emitter);
-      destroyed.add(emitter);
-      } */
     function On(emitter, callback) {
         emitter.push(callback);
     }
     Emitter.On = On;
     function Emit(emitter, ...args) {
-        // pendingCompactEmitters.delete(emitter);
-        let writePos = 0;
-        for (let x = 0; x < emitter.length; x++) {
-            if (emitter[x] !== null && !destroyed.has(emitter[x])) {
-                emitter[x](...args);
-                emitter[writePos++] = emitter[x];
-            }
-        }
-        if (writePos < emitter.length)
-            emitter.splice(writePos);
+        for (let x = emitter[0] + 1; x < emitter.length; x++)
+            emitter[x](...args);
     }
     Emitter.Emit = Emit;
     function Remove(emitter, callback) {
-        const index = emitter.indexOf(callback);
-        if (index >= 0) {
-            emitter[index] = null;
+        if (emitter.length === 1)
+            return;
+        const startIndex = emitter[0] + 1;
+        const index = emitter.indexOf(callback, startIndex);
+        if (index > 0) {
+            emitter[0]++;
+            emitter[index] = emitter[startIndex];
+            emitter[startIndex] = null;
             Compact(emitter);
         }
     }
     Emitter.Remove = Remove;
     function Clear(emitter) {
-        if (emitter.length === 0)
-            return;
-        // pendingCompactEmitters.delete(emitter);
-        emitter.splice(0);
+        emitter.length > 1 && emitter.splice(1);
+        emitter[0] = 0;
     }
     Emitter.Clear = Clear;
 })(Emitter || (exports.Emitter = Emitter = {}));

package/Utils/functions.js

@@ -7,5 +7,5 @@ exports.IsAsync = IsAsync;
  * @returns true if the function is async, false otherwise
  */
 function IsAsync(func) {
-    return func[Symbol.toStringTag] === "AsyncFunction";
+    return func && func[Symbol.toStringTag] === "AsyncFunction";
 }

package/Utils/json.js

@@ -55,9 +55,9 @@ function JsonDiffFactory() {
             case "array": {
                 const typedSource = source;
                 const typedPatch = patch;
-                const result = typedPatch.map(function (patch, index) {
-                    return JsonMerge(typedSource[index], patch);
-                });
+                const result = new Array(typedPatch.length);
+                for (let x = 0; x < typedPatch.length; x++)
+                    result[x] = JsonMerge(typedSource[x], typedPatch[x]);
                 return result;
             }
             case "object": {

package/index.d.ts

@@ -1,2 +1,2 @@
 export { Component } from './Node/component';
-export { InlineScope as scope, GateScope as gate, PeekScope as peek } from './Store/Tree/observableScope';
+export { InlineScope as scope, GateScope as gate, PeekScope as peek, MappedScope as mapped } from './Store/Tree/observableScope';

package/index.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.peek = exports.gate = exports.scope = exports.Component = void 0;
+exports.mapped = exports.peek = exports.gate = exports.scope = exports.Component = void 0;
 var component_1 = require("./Node/component");
 Object.defineProperty(exports, "Component", { enumerable: true, get: function () { return component_1.Component; } });
 var observableScope_1 = require("./Store/Tree/observableScope");
 Object.defineProperty(exports, "scope", { enumerable: true, get: function () { return observableScope_1.InlineScope; } });
 Object.defineProperty(exports, "gate", { enumerable: true, get: function () { return observableScope_1.GateScope; } });
 Object.defineProperty(exports, "peek", { enumerable: true, get: function () { return observableScope_1.PeekScope; } });
+Object.defineProperty(exports, "mapped", { enumerable: true, get: function () { return observableScope_1.MappedScope; } });

package/package.json

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