@motifx/core 1.0.1 → 1.2.0-rc.0

package/dist/chunks/core-DXGu4dNE.cjs

@@ -1,1642 +0,0 @@
-'use strict';
-
-function rethrowLater(error) {
-    setTimeout(() => { throw error; }, 0);
-}
-class ErrorHandler {
-    unexpectedErrorHandler = rethrowLater;
-    listeners = [];
-    _isDevelopment = false;
-    _enableConsoleLogging = true;
-    setDevelopmentMode(isDev) {
-        this._isDevelopment = isDev;
-    }
-    setConsoleLogging(enabled) {
-        this._enableConsoleLogging = enabled;
-    }
-    isDevelopment() {
-        return this._isDevelopment || globalThis.__MOTIF_DEV__ === true;
-    }
-    reportSuppressed(context, error) {
-        this.logIfDev(context, error);
-    }
-    report(error) {
-        if (this._enableConsoleLogging) {
-            if (error.cause !== undefined)
-                console.error(error.message, error.cause);
-            else
-                console.error(error.message);
-        }
-        try {
-            const bus = globalThis.__MOTIF_DEVTOOLS_BUS__;
-            if (bus && typeof bus.publish === 'function') {
-                bus.publish('error:caught', { context: error.code ?? error.name, error: this.serializeError(error) });
-            }
-        }
-        catch { /* ignore */ }
-        this.emit(error);
-    }
-    logIfDev(context, error) {
-        if (this.isDevelopment() && this._enableConsoleLogging) {
-            console.error(`[motifjs Error - ${context}]`, error);
-        }
-        try {
-            const bus = globalThis.__MOTIF_DEVTOOLS_BUS__;
-            if (bus && typeof bus.publish === 'function') {
-                bus.publish('error:caught', { context, error: this.serializeError(error) });
-            }
-        }
-        catch { /* ignore */ }
-    }
-    serializeError(error) {
-        if (!error)
-            return { message: 'Unknown error' };
-        if (error instanceof Error) {
-            return {
-                name: error.name,
-                message: error.message,
-                stack: error.stack,
-                cause: error.cause ? this.serializeError(error.cause) : undefined
-            };
-        }
-        if (typeof error === 'object') {
-            try {
-                return JSON.parse(JSON.stringify(error));
-            }
-            catch {
-                return String(error);
-            }
-        }
-        return String(error);
-    }
-    addListener(listener) {
-        this.listeners.push(listener);
-        return () => {
-            const index = this.listeners.indexOf(listener);
-            if (index !== -1) {
-                this.listeners.splice(index, 1);
-            }
-        };
-    }
-    emit(error) {
-        for (const listener of this.listeners.slice()) {
-            listener(error);
-        }
-    }
-    setUnexpectedErrorHandler(handler) {
-        this.unexpectedErrorHandler = handler;
-    }
-    getUnexpectedErrorHandler() {
-        return this.unexpectedErrorHandler;
-    }
-    onUnexpectedError(error) {
-        this.unexpectedErrorHandler(error);
-        this.emit(error);
-    }
-    safeCall(fn, context, fallback) {
-        try {
-            return fn();
-        }
-        catch (error) {
-            this.logIfDev(context, error);
-            this.onUnexpectedError(error);
-            return fallback;
-        }
-    }
-    async safeCallAsync(fn, context, fallback) {
-        try {
-            return await fn();
-        }
-        catch (error) {
-            this.logIfDev(context, error);
-            this.onUnexpectedError(error);
-            return fallback;
-        }
-    }
-    safeCallSilent(fn, context) {
-        try {
-            fn();
-        }
-        catch (error) {
-            this.logIfDev(context, error);
-        }
-    }
-    async safeCallSilentAsync(fn, context) {
-        try {
-            return await fn();
-        }
-        catch (error) {
-            this.logIfDev(context, error);
-        }
-    }
-    wrapSafe(fn, context) {
-        return (...args) => {
-            try {
-                return fn(...args);
-            }
-            catch (error) {
-                this.logIfDev(context, error);
-                this.onUnexpectedError(error);
-                return undefined;
-            }
-        };
-    }
-    wrapSafeAsync(fn, context) {
-        return async (...args) => {
-            try {
-                return await fn(...args);
-            }
-            catch (error) {
-                this.logIfDev(context, error);
-                this.onUnexpectedError(error);
-                return undefined;
-            }
-        };
-    }
-}
-const errorHandler = new ErrorHandler();
-function setErrorConsoleLogging(enabled) {
-    errorHandler.setConsoleLogging(enabled);
-}
-function safeCall(fn, context, fallback) {
-    return errorHandler.safeCall(fn, context, fallback);
-}
-function safeCallAsync(fn, context, fallback) {
-    return errorHandler.safeCallAsync(fn, context, fallback);
-}
-function safeCallSilent(fn, context) {
-    errorHandler.safeCallSilent(fn, context);
-}
-function safeCallSilentAsync(fn, context) {
-    return errorHandler.safeCallSilentAsync(fn, context);
-}
-function setUnexpectedErrorHandler(handler) {
-    errorHandler.setUnexpectedErrorHandler(handler);
-}
-
-const state = {
-    enabled: false,
-    listeners: new Set(),
-    warnings: [],
-    routes: null,
-};
-/** Dev modu: devtools açık ya da `globalThis.__MOTIF_DEV__ === true`. */
-function isDevLike() {
-    return state.enabled || globalThis.__MOTIF_DEV__ === true;
-}
-function detectEnabled() {
-    try {
-        if (typeof window === 'undefined')
-            return false;
-        const w = window;
-        if (w.__motif_DEVTOOLS === true)
-            return true;
-        if (globalThis.__MOTIF_DEVTOOLS__ === true)
-            return true;
-        if (globalThis.__MOTIF_DEVTOOLS_FLAG === true)
-            return true;
-        const qs = (w.location && w.location.search) || '';
-        if (qs && /(?:[?&])devtools=1(?:&|$)/i.test(qs))
-            return true;
-        return false;
-    }
-    catch {
-        return false;
-    }
-}
-function ensureDevtoolsFlagInitialized() {
-    if (state.enabled)
-        return;
-    state.enabled = detectEnabled();
-    if (state.enabled) {
-        try {
-            window.__motifDevBus = { on, emit, warn, getWarnings, isEnabled, setRoutes, getRoutes };
-        }
-        catch { }
-    }
-}
-function isEnabled() { return state.enabled; }
-function on(listener) {
-    state.listeners.add(listener);
-    return () => { state.listeners.delete(listener); };
-}
-function emit(type, payload) {
-    const ev = { type, payload };
-    for (const l of state.listeners) {
-        try {
-            l(ev);
-        }
-        catch { }
-    }
-    try {
-        const bus = globalThis.__MOTIF_DEVTOOLS_BUS__;
-        if (bus && typeof bus.publish === 'function') {
-            bus.publish('devtools:' + type, payload);
-        }
-    }
-    catch { }
-}
-function warn(code, message, details) {
-    if (!isDevLike())
-        return;
-    const w = { code, message, details };
-    state.warnings.push(w);
-    try {
-        if (typeof console !== 'undefined')
-            details === undefined ? console.warn(`[motifjs] ${code}: ${message}`) : console.warn(`[motifjs] ${code}: ${message}`, details);
-    }
-    catch { }
-    emit('warning', w);
-}
-function getWarnings() { return state.warnings.slice(); }
-function setRoutes(routes) { state.routes = routes; }
-function getRoutes() { return state.routes; }
-
-const motifMessages = {
-    MJX101: (tag) => `dom.createElement('${tag}'): no document is available (no DOM environment).`,
-    MJX102: (description) => `Invalid element selector "${description}".`,
-    MJX103: (tag) => `dom.createElementNS('${tag}') failed.`,
-    MJX104: () => `Skipped inserting a component into the DOM because it contains its own parent.`,
-    MJX105: () => `Applying router link classes failed.`,
-    MJX106: () => `The placeholder parent changed; rebuilding the component.`,
-    MJX107: () => `Disposing a child component failed.`,
-    MJX108: () => `Component is disposed; the result of doWork was discarded.`,
-    MJX109: () => `A content block child was removed because its content body is being disposed.`,
-    MJX110: (ms) => `Lazy timeout: the component did not load within ${ms} ms.`,
-    MJX111: () => `Lazy aborted: loading the component was cancelled.`,
-    MJX112: (depth) => `resolveComponent: the factory chain exceeded ${depth} levels; a factory may be returning itself.`,
-    MJX113: () => `The transport slot has no parent; mount the slot before transporting into it.`,
-    MJX114: () => `Placing the navigation target into its host failed.`,
-    MJX115: () => `Disposing the previous navigation target failed.`,
-    MJX116: (ms) => `Timeout: the listener guard did not settle within ${ms} ms.`,
-    MJX117: () => `Detaching a control failed.`,
-    MJX118: () => `The onRemove callback failed while detaching a control.`,
-    MJX119: () => `Moving a fragment's DOM range stopped: its end marker was not found (possible infinite loop).`,
-    MJX120: () => `Scanning a fragment's DOM range stopped: its end marker was not found (possible infinite loop).`,
-    MJX121: (compiled, runtime) => `This code was compiled for compiler contract ${compiled}, but the @motifx/core runtime implements contract ${runtime}. Install matching versions of @motifx/compiler and @motifx/core, and rebuild packages that ship compiled JSX.`,
-    MJX122: (hook) => `The component ${hook} hook threw.`,
-    MJX123: (event) => `The '${event}' event handler threw.`,
-    MJX201: () => `ListBinding: renderFn must return a component instance, a component class, or a factory function.`,
-    MJX202: (key, index) => `ListBinding: duplicate key "${String(key)}" at index ${index}. Rows are matched by the item object, not by key, so rendering is not affected; keep keys unique so they identify items.`,
-    MJX203: (max) => `An effect ran ${max} times in one flush and keeps triggering itself; it is skipped for the rest of this flush. It probably writes a value it reads (for example state.n++). Wrap the write in untracked(...).`,
-    MJX204: () => `A component reached a text binding and was not written to the DOM. For a template prop that can change later, write a getter: {() => props.tpl}. Templates that are ready at setup also work as {props.tpl}.`,
-    MJX205: () => `Virtualization: the watch callback threw.`,
-    MJX206: () => `Virtualization: autoRefresh stopped; dataRequest may be changing the reactive data it reads on every refresh.`,
-    MJX207: () => `Virtualization: loading data failed.`,
-    MJX208: () => `An effect threw.`,
-    MJX301: (outlet, ms) => `RouterView outlet '${outlet}' was not built within ${ms} ms, so the route chain cannot be mounted. Does the layout component render a <RouterView>?`,
-    MJX302: (name) => `Named route '${name}' was not found.`,
-    MJX303: (chain) => `Redirect loop or too many redirects: ${chain}`,
-    MJX304: () => `Route execution failed.`,
-    MJX305: () => `The error fallback route failed.`,
-    MJX306: (hook) => `The ${hook} hook threw.`,
-    MJX307: () => `Disposing a route component failed.`,
-    MJX308: () => `The stack navigation transition failed.`,
-    MJX309: () => `Router is not initialized. Call useRouter() before navigating.`,
-    MJX310: (parentPath) => `Route path cannot be empty; use '/' for the default child. Under parent "${parentPath}".`,
-    MJX311: (path, parentPath) => `Child route path should start with '/': "${path}" under parent "${parentPath}".`,
-    MJX312: (full) => `Child route path resolves to the same full path as its parent: "${full}".`,
-    MJX313: (full) => `Multiple routes resolve to the same full path: "${full}".`,
-    MJX314: (alias, parentPath) => `Child route alias should start with '/': "${alias}" under parent "${parentPath}".`,
-    MJX315: (alias) => `Route alias resolves to the route's own path: "${alias}".`,
-    MJX316: (alias) => `Multiple routes use the same alias: "${alias}".`,
-    MJX401: (token) => `Service not registered for token: ${token}`,
-    MJX402: (token) => `Async factory used with get() for token ${token}; use getAsync().`,
-    MJX403: () => `Invalid service descriptor.`,
-    MJX404: (chain) => `Cyclic dependency detected: ${chain}`,
-    MJX405: () => `Only one ApplicationBuilder instance is allowed.`,
-    MJX406: (selector) => `Application.run: host not found for selector: ${selector}`,
-    MJX407: (token) => `getService: no ServiceProvider found for token '${token}'.`,
-    MJX408: (token, reason) => `getService failed for token '${token}': ${reason}`,
-    MJX409: (token) => `inject(${token}) was called outside a service construction; call it in a field initializer or constructor of a class the ServiceProvider creates.`,
-    MJX410: (token, sources) => `Multiple sources provided for token '${token}': ${sources}. Resolution order is useValue > useFactory > useClass.`,
-    MJX411: (token) => `'deps' must be an array for token '${token}'; the invalid deps are ignored.`,
-    MJX413: (token) => `Service '${token}' is registered with a function that cannot be constructed. Use { useValue: fn } to provide the function itself or { useFactory: fn } to create the service.`,
-    MJX414: (token, reason) => `FromService failed for token '${token}': ${reason}`,
-    MJX501: () => `Disposable already disposed.`,
-    MJX502: () => `Cannot register a disposable on itself.`,
-    MJX503: () => `Errors were thrown while disposing a store.`,
-    MJX504: () => `A disposable was added to a DisposableStore that is already disposed; the added object will leak.`,
-    MJX505: () => `Cannot dispose a disposable on itself.`,
-    MJX507: (name, limit, count) => `[${name}] potential listener LEAK: ${limit} listeners already; most frequent stack (${count}):`,
-    MJX601: () => `Sequence contains no elements.`,
-    MJX602: () => `Circuit is open.`,
-    MJX603: () => `Bulkhead queue is full.`,
-    MJX604: () => `Rate limit exceeded.`,
-    MJX605: () => `Operation timed out.`,
-    MJX607: () => `A history must be created with at least one entry.`,
-    MJX608: () => `Method not implemented.`,
-    MJX609: () => `OperationRunner: the operation threw.`,
-    MJX610: () => `Matching the request path failed.`,
-    MJX611: () => `The devtools panel failed to load.`,
-};
-class MotifError extends Error {
-    code;
-    constructor(code, message, options) {
-        super(message, options);
-        this.name = 'MotifError';
-        this.code = code;
-    }
-}
-function formatMotifMessage(code, ...args) {
-    return `[motifjs] ${code}: ${motifMessages[code](...args)}`;
-}
-function motifError(code, ...args) {
-    return new MotifError(code, formatMotifMessage(code, ...args));
-}
-function reportError(code, cause, ...args) {
-    errorHandler.report(new MotifError(code, formatMotifMessage(code, ...args), { cause }));
-}
-function callReported(fn, code, ...args) {
-    try {
-        const result = fn();
-        if (result && typeof result.then === 'function') {
-            result.then(undefined, (error) => reportError(code, error, ...args));
-        }
-    }
-    catch (error) {
-        reportError(code, error, ...args);
-    }
-}
-function reportWarning(code, args, details) {
-    warn(code, motifMessages[code](...args), details);
-}
-
-const ITERATE_KEY = Symbol('');
-let followTracking = true;
-let arrayScope = { enabled: false, key: '' };
-function getRaw(value) {
-    let current = value;
-    while (current && current["[__raw__]" /* Flags.RAW */]) {
-        current = current["[__raw__]" /* Flags.RAW */];
-    }
-    return current;
-}
-function isReadonly(candidate) {
-    if (candidate == null)
-        return false;
-    return Boolean(candidate["[__isReadonly__]" /* Flags.IS_READONLY */]);
-}
-function hasOwn(target, key) {
-    return Object.prototype.hasOwnProperty.call(target, key);
-}
-function isObject(value) {
-    return typeof value === 'object' && value !== null;
-}
-const intrinsicSymbols = new Set(Object.values(Object.getOwnPropertyDescriptors(Symbol))
-    .map(descriptor => descriptor.value)
-    .filter((value) => typeof value === 'symbol'));
-function isIntrinsicSymbol(key) {
-    return typeof key === 'symbol' && intrinsicSymbols.has(key);
-}
-const proxyableTags = new Map([
-    ['[object Object]', 1 /* TargetType.COMMON */],
-    ['[object Array]', 1 /* TargetType.COMMON */],
-    ['[object Map]', 2 /* TargetType.COLLECTION */],
-    ['[object Set]', 2 /* TargetType.COLLECTION */],
-    ['[object WeakMap]', 2 /* TargetType.COLLECTION */],
-    ['[object WeakSet]', 2 /* TargetType.COLLECTION */],
-]);
-function getTargetType(value) {
-    var proto = Object.getPrototypeOf(value);
-    var cname = "";
-    if (proto && proto.constructor) {
-        cname = proto.constructor.name;
-    }
-    if ((cname === "Control" || cname == "RouteManager" || cname == "ServiceManager")) {
-        return 0 /* TargetType.SYSTEM */;
-    }
-    if (!Object.isExtensible(value)) {
-        return 0 /* TargetType.INVALID */;
-    }
-    return proxyableTags.get(Object.prototype.toString.call(value)) ?? 0 /* TargetType.INVALID */;
-}
-const canonicalIndex = /^(?:0|[1-9]\d*)$/;
-const isNumericKey = (key) => typeof key === 'string' && canonicalIndex.test(key) && String(Number(key)) === key;
-const savedTracking = [];
-let trackingDepth = 0;
-function enterTracking(enabled) {
-    savedTracking[trackingDepth++] = followTracking;
-    followTracking = enabled;
-}
-function pauseTracking() {
-    enterTracking(false);
-}
-function enableTracking() {
-    enterTracking(true);
-}
-function resetTracking() {
-    followTracking = trackingDepth > 0 ? savedTracking[--trackingDepth] : true;
-}
-const arrayStack = [];
-function addArrayStack(key) {
-    arrayStack.push(arrayScope);
-    arrayScope.enabled = true;
-    arrayScope.key = key;
-}
-function removeArrayStack() {
-    const last = arrayStack.pop();
-    if (arrayStack.length > 0) {
-        arrayScope = last === undefined ? { enabled: false, key: '' } : last;
-    }
-    else {
-        arrayScope = { enabled: false, key: '' };
-    }
-}
-
-class LeakMonitor {
-    threshold;
-    name;
-    _origins = new Map();
-    _quietChecks = 0;
-    constructor(threshold, name) {
-        this.threshold = threshold;
-        this.name = name;
-    }
-    check(size) {
-        if (this.threshold <= 0 || size < this.threshold) {
-            return undefined;
-        }
-        const origin = new Error().stack ?? '';
-        this._origins.set(origin, (this._origins.get(origin) ?? 0) + 1);
-        this._quietChecks--;
-        if (this._quietChecks <= 0) {
-            this._quietChecks = this.threshold / 2;
-            const [stack, count] = this._busiestOrigin();
-            reportWarning('MJX507', [this.name, size, count], stack);
-        }
-        return () => {
-            this._origins.set(origin, (this._origins.get(origin) ?? 0) - 1);
-        };
-    }
-    _busiestOrigin() {
-        let busiest = ['', 0];
-        for (const entry of this._origins) {
-            if (entry[1] > busiest[1]) {
-                busiest = entry;
-            }
-        }
-        return busiest;
-    }
-}
-
-function createRing() {
-    const ring = { value: undefined, linked: false };
-    ring.before = ring;
-    ring.after = ring;
-    return ring;
-}
-class LinkedList {
-    _ring = createRing();
-    _count = 0;
-    get size() {
-        return this._count;
-    }
-    isEmpty() {
-        return this._count === 0;
-    }
-    push(value) {
-        return this._link(value, this._ring.before);
-    }
-    unshift(value) {
-        return this._link(value, this._ring);
-    }
-    pop() {
-        return this._take(this._ring.before);
-    }
-    shift() {
-        return this._take(this._ring.after);
-    }
-    clear() {
-        for (let link = this._ring.after; link !== this._ring; link = link.after) {
-            link.linked = false;
-        }
-        this._ring = createRing();
-        this._count = 0;
-    }
-    *[Symbol.iterator]() {
-        const ring = this._ring;
-        for (let link = ring.after; link !== ring; link = link.after) {
-            yield link.value;
-        }
-    }
-    _link(value, previous) {
-        const link = { value, before: previous, after: previous.after, linked: true };
-        previous.after.before = link;
-        previous.after = link;
-        this._count++;
-        return () => this._unlink(link);
-    }
-    _take(link) {
-        if (link === this._ring) {
-            return undefined;
-        }
-        const value = link.value;
-        this._unlink(link);
-        return value;
-    }
-    _unlink(link) {
-        if (!link.linked) {
-            return;
-        }
-        link.linked = false;
-        link.before.after = link.after;
-        link.after.before = link.before;
-        this._count--;
-    }
-}
-
-exports.NodeTypes = void 0;
-(function (NodeTypes) {
-    NodeTypes[NodeTypes["ELEMENT_NODE"] = 1] = "ELEMENT_NODE";
-    NodeTypes[NodeTypes["ATTRIBUTE_NODE"] = 2] = "ATTRIBUTE_NODE";
-    NodeTypes[NodeTypes["TEXT_NODE"] = 3] = "TEXT_NODE";
-    NodeTypes[NodeTypes["CDATA_SECTION_NODE"] = 4] = "CDATA_SECTION_NODE";
-    NodeTypes[NodeTypes["ENTITY_REFERENCE_NODE"] = 5] = "ENTITY_REFERENCE_NODE";
-    /**deprecated */
-    NodeTypes[NodeTypes["ENTITY_NODE"] = 6] = "ENTITY_NODE";
-    /**deprecated */
-    NodeTypes[NodeTypes["PROCESSING_INSTRUCTION_NODE"] = 7] = "PROCESSING_INSTRUCTION_NODE";
-    NodeTypes[NodeTypes["COMMENT_NODE"] = 8] = "COMMENT_NODE";
-    NodeTypes[NodeTypes["DOCUMENT_NODE"] = 9] = "DOCUMENT_NODE";
-    NodeTypes[NodeTypes["DOCUMENT_TYPE_NODE"] = 10] = "DOCUMENT_TYPE_NODE";
-    NodeTypes[NodeTypes["DOCUMENT_FRAGMENT_NODE"] = 11] = "DOCUMENT_FRAGMENT_NODE";
-    /**deprecated */
-    NodeTypes[NodeTypes["NOTATION_NODE"] = 12] = "NOTATION_NODE";
-})(exports.NodeTypes || (exports.NodeTypes = {}));
-
-class Effect {
-    fn;
-    callback;
-    deps = [];
-    active = true;
-    running = false;
-    scheduler;
-    constructor(fn, callback) {
-        this.fn = fn;
-        this.callback = callback;
-    }
-    run() {
-        let value;
-        if (!this.active || this.running)
-            return;
-        cleanup(this);
-        effectStack.push(this);
-        this.running = true;
-        try {
-            value = this.fn();
-        }
-        finally {
-            effectStack.pop();
-            this.running = false;
-            if (this.callback) {
-                this.callback(value);
-            }
-        }
-    }
-    stop() {
-        this.active = false;
-        cleanup(this);
-    }
-}
-const depMap = new WeakMap();
-const effectStack = [];
-const effectQueue = new Set();
-let isFlushing = false;
-let leakEnabled = false;
-let leakThreshold = -1;
-let leakMonitor;
-const leakCleanups = new WeakMap();
-function configureReactivityLeakMonitor(opts = {}) {
-    leakEnabled = !!opts.enabled;
-    leakThreshold = typeof opts.threshold === 'number' ? opts.threshold : (leakEnabled ? 200 : -1);
-    leakMonitor = leakEnabled && leakThreshold > 0 ? new LeakMonitor(leakThreshold, opts.name ?? 'reactivity-core') : undefined;
-}
-function track(target, key) {
-    if (!followTracking)
-        return;
-    const rawTarget = getRaw(target);
-    const effect = effectStack[effectStack.length - 1];
-    if (!effect || !effect.active)
-        return;
-    let deps = depMap.get(rawTarget);
-    if (!deps)
-        depMap.set(rawTarget, (deps = new Map()));
-    let dep = deps.get(key);
-    if (!dep)
-        deps.set(key, (dep = new Set()));
-    if (!dep.has(effect)) {
-        dep.add(effect);
-        effect.deps.push([rawTarget, key]);
-        if (leakEnabled && leakMonitor && leakThreshold > 0) {
-            try {
-                const cleanup = leakMonitor.check(dep.size);
-                if (cleanup) {
-                    let m = leakCleanups.get(dep);
-                    if (!m) {
-                        m = new Map();
-                        leakCleanups.set(dep, m);
-                    }
-                    m.set(effect, cleanup);
-                }
-            }
-            catch { }
-        }
-    }
-}
-function trigger(target, key) {
-    const rawTarget = getRaw(target);
-    const deps = depMap.get(rawTarget);
-    if (!deps)
-        return;
-    const effects = deps.get(key);
-    if (!effects)
-        return;
-    let queued = false;
-    effects.forEach(effect => {
-        if (!effect.active)
-            return;
-        if (effect.scheduler) {
-            runReported(effect.scheduler);
-            return;
-        }
-        effectQueue.add(effect);
-        queued = true;
-    });
-    if (queued)
-        flushEffects();
-}
-function runReported(fn) {
-    try {
-        fn();
-    }
-    catch (error) {
-        reportError('MJX208', error);
-    }
-}
-const MAX_EFFECT_RUNS_PER_FLUSH = 50;
-function flushEffects() {
-    if (isFlushing)
-        return;
-    isFlushing = true;
-    Promise.resolve().then(() => {
-        const runCounts = new Map();
-        try {
-            while (effectQueue.size > 0) {
-                const batch = Array.from(effectQueue);
-                effectQueue.clear();
-                for (const e of batch) {
-                    const runs = (runCounts.get(e) ?? 0) + 1;
-                    runCounts.set(e, runs);
-                    if (runs > MAX_EFFECT_RUNS_PER_FLUSH) {
-                        if (runs === MAX_EFFECT_RUNS_PER_FLUSH + 1) {
-                            reportWarning('MJX203', [MAX_EFFECT_RUNS_PER_FLUSH], { fn: String(e.fn).slice(0, 200) });
-                        }
-                        continue;
-                    }
-                    runReported(() => e.run());
-                }
-            }
-        }
-        finally {
-            effectQueue.clear();
-            isFlushing = false;
-        }
-    });
-}
-function cleanup(effect) {
-    for (const [target, key] of effect.deps) {
-        const keyMap = depMap.get(target);
-        if (!keyMap)
-            continue;
-        const depSet = keyMap.get(key);
-        if (!depSet)
-            continue;
-        depSet.delete(effect);
-        try {
-            const map = leakCleanups.get(depSet);
-            const fn = map?.get(effect);
-            if (fn) {
-                try {
-                    fn();
-                }
-                catch { }
-                map.delete(effect);
-            }
-        }
-        catch { }
-        if (depSet.size === 0) {
-            keyMap.delete(key);
-        }
-        if (keyMap.size === 0) {
-            depMap.delete(target);
-        }
-    }
-    effect.deps = [];
-}
-function effect(fn, onValueChanged) {
-    const e = new Effect(fn, onValueChanged);
-    runReported(() => e.run());
-    return () => e.stop();
-}
-function createScheduledEffect(fn, scheduler) {
-    const e = new Effect(fn);
-    e.scheduler = scheduler;
-    return {
-        run: () => { runReported(() => e.run()); },
-        stop: () => e.stop(),
-    };
-}
-function popAsyncTracking(t) {
-    if (!t.pushed)
-        return;
-    t.pushed = false;
-    const i = effectStack.lastIndexOf(t.effect);
-    if (i >= 0)
-        effectStack.splice(i, 1);
-}
-const asyncTracking = {
-    capture() {
-        return { effect: effectStack[effectStack.length - 1], pushed: false };
-    },
-    suspend(t, value) {
-        popAsyncTracking(t);
-        return value;
-    },
-    resume(t, value) {
-        if (t.effect && t.effect.active && !t.pushed) {
-            effectStack.push(t.effect);
-            t.pushed = true;
-        }
-        return value;
-    },
-    end(t) {
-        popAsyncTracking(t);
-    },
-};
-const UNTRACKED_SENTINEL = new Effect(() => { });
-UNTRACKED_SENTINEL.active = false;
-function untracked(fn) {
-    effectStack.push(UNTRACKED_SENTINEL);
-    try {
-        return fn();
-    }
-    finally {
-        effectStack.pop();
-    }
-}
-function debugGetDeps(target) {
-    const rawTarget = getRaw(target);
-    return depMap.get(rawTarget);
-}
-function debugGetDepMap() {
-    return depMap;
-}
-
-const SIGNAL_TARGET = Symbol('SignalTarget');
-const SIGNAL_KEY = Symbol('SignalKey');
-class Signal {
-    _value;
-    _target;
-    _key;
-    _equals;
-    _disposed = false;
-    static create(initialValue, equals) {
-        return new Signal(initialValue, equals);
-    }
-    constructor(initialValue, equals = Object.is) {
-        this._value = initialValue;
-        this._target = { [SIGNAL_TARGET]: true };
-        this._key = SIGNAL_KEY;
-        this._equals = equals;
-    }
-    get value() {
-        if (!this._disposed) {
-            track(this._target, this._key);
-        }
-        return this._value;
-    }
-    set value(newValue) {
-        if (this._disposed)
-            return;
-        if (!this._equals(this._value, newValue)) {
-            this._value = newValue;
-            trigger(this._target, this._key);
-        }
-    }
-    peek() {
-        return this._value;
-    }
-    update(updater) {
-        this.value = (updater(this._value));
-    }
-    mutate(mutator) {
-        if (this._disposed)
-            return;
-        mutator(this._value);
-        trigger(this._target, this._key);
-    }
-    notify() {
-        if (this._disposed)
-            return;
-        trigger(this._target, this._key);
-    }
-    asReadonly() {
-        const self = this;
-        return {
-            get value() { return self.value; },
-            peek() { return self.peek(); },
-            valueOf() { return self.valueOf(); },
-            toString() { return self.toString(); }
-        };
-    }
-    dispose() {
-        this._disposed = true;
-    }
-    valueOf() {
-        return this.value;
-    }
-    toString() {
-        return String(this.value);
-    }
-}
-class Computed {
-    _value;
-    _dirty = true;
-    _computing = false;
-    _target;
-    _key;
-    _getter;
-    _cleanup;
-    constructor(getter) {
-        this._getter = getter;
-        this._target = { [SIGNAL_TARGET]: true };
-        this._key = SIGNAL_KEY;
-        this._cleanup = effect(() => {
-            if (this._computing)
-                return;
-            this._computing = true;
-            try {
-                const newVal = this._getter();
-                const changed = this._dirty || !Object.is(this._value, newVal);
-                this._value = newVal;
-                this._dirty = false;
-                if (changed) {
-                    trigger(this._target, this._key);
-                }
-            }
-            finally {
-                this._computing = false;
-            }
-        });
-    }
-    get value() {
-        track(this._target, this._key);
-        if (this._dirty) {
-            this._computing = true;
-            pauseTracking();
-            try {
-                this._value = this._getter();
-                this._dirty = false;
-            }
-            finally {
-                resetTracking();
-                this._computing = false;
-            }
-        }
-        return this._value;
-    }
-    peek() {
-        if (this._dirty) {
-            pauseTracking();
-            try {
-                this._value = this._getter();
-                this._dirty = false;
-            }
-            finally {
-                resetTracking();
-            }
-        }
-        return this._value;
-    }
-    dispose() {
-        if (this._cleanup) {
-            this._cleanup();
-            this._cleanup = undefined;
-        }
-    }
-    valueOf() {
-        return this.value;
-    }
-    toString() {
-        return String(this.value);
-    }
-}
-class LazyComputed {
-    _value;
-    _dirty = true;
-    _disposed = false;
-    _target;
-    _key;
-    _getter;
-    _runner;
-    constructor(getter) {
-        this._getter = getter;
-        this._target = { [SIGNAL_TARGET]: true };
-        this._key = SIGNAL_KEY;
-        this._runner = createScheduledEffect(() => { this._value = this._getter(); }, () => {
-            if (this._dirty || this._disposed)
-                return;
-            this._dirty = true;
-            trigger(this._target, this._key);
-        });
-    }
-    get value() {
-        if (!this._disposed) {
-            track(this._target, this._key);
-        }
-        this._refresh();
-        return this._value;
-    }
-    peek() {
-        this._refresh();
-        return this._value;
-    }
-    get isDirty() {
-        return this._dirty;
-    }
-    _refresh() {
-        if (!this._dirty)
-            return;
-        if (this._disposed) {
-            this._value = untracked(this._getter);
-        }
-        else {
-            this._runner.run();
-        }
-        this._dirty = false;
-    }
-    dispose() {
-        if (this._disposed)
-            return;
-        this._disposed = true;
-        this._runner.stop();
-    }
-    valueOf() {
-        return this.value;
-    }
-    toString() {
-        return String(this.value);
-    }
-}
-
-const glblths = globalThis;
-function getCurrentDom() {
-    if (glblths && glblths.motifDom) {
-        return glblths.motifDom.window.document;
-    }
-    return glblths.document;
-}
-const dom = {
-    get window() {
-        if (glblths && glblths.window) {
-            return glblths.window;
-        }
-        else if (glblths && glblths) {
-            return glblths.motifDom.window;
-        }
-        else {
-            return glblths;
-        }
-    },
-    _created: new Map(),
-    document: getCurrentDom(),
-    createElement(tagName, options) {
-        const doc = getCurrentDom();
-        if (!doc) {
-            throw motifError('MJX101', tagName);
-        }
-        if (tagName === "text") {
-            return doc.createTextNode('');
-        }
-        if (!this._created.has(tagName)) {
-            const view = doc.createElement(tagName, options);
-            this._created.set(tagName, view);
-        }
-        const tpl = this._created.get(tagName);
-        return tpl.cloneNode(false);
-    },
-    createDocumentFragment() {
-        try {
-            var cd = getCurrentDom();
-            if (cd) {
-                return cd.createDocumentFragment();
-            }
-        }
-        catch (error) {
-            errorHandler.reportSuppressed('dom.createDocumentFragment', error);
-        }
-    },
-    createComment(content) {
-        try {
-            return getCurrentDom()?.createComment(content);
-        }
-        catch (error) {
-            errorHandler.reportSuppressed('dom.createComment', error);
-        }
-    },
-    createTextNode(content) {
-        try {
-            return getCurrentDom()?.createTextNode(content);
-        }
-        catch (error) {
-            errorHandler.reportSuppressed('dom.createTextNode', error);
-        }
-    },
-    querySelectorAll(selectors) {
-        try {
-            return getCurrentDom()?.querySelectorAll(selectors);
-        }
-        catch (error) {
-            errorHandler.reportSuppressed('dom.querySelectorAll', error);
-        }
-    },
-    createElementNS(namepsaceUri, tagName, options) {
-        try {
-            return getCurrentDom()?.createElementNS(namepsaceUri, tagName, options);
-        }
-        catch (error) {
-            reportError('MJX103', error, tagName);
-        }
-    },
-    convertToSvgElement(element) {
-        const SVG_NAMESPACE = "http://www.w3.org/2000/svg";
-        const tagName = element.tagName.toLowerCase();
-        const newSvgElement = document.createElementNS(SVG_NAMESPACE, tagName);
-        for (const attr of element.attributes) {
-            newSvgElement.setAttribute(attr.name, attr.value);
-        }
-        while (element.firstChild) {
-            newSvgElement.appendChild(element.firstChild);
-        }
-        const parent = element.parentNode;
-        if (parent) {
-            parent.replaceChild(newSvgElement, element);
-        }
-        return newSvgElement;
-    },
-    get body() {
-        return getCurrentDom()?.body;
-    }
-};
-const SELECTOR_REGEX = /([\w\-]+)?(#([\w\-]+))?((\.([\w\-]+))*)/;
-var Namespace;
-(function (Namespace) {
-    Namespace["HTML"] = "http://www.w3.org/1999/xhtml";
-    Namespace["SVG"] = "http://www.w3.org/2000/svg";
-})(Namespace || (Namespace = {}));
-function _$(namespace, description, attrs, ...children) {
-    const match = SELECTOR_REGEX.exec(description);
-    if (!match) {
-        throw motifError('MJX102', description);
-    }
-    const tagName = match[1] || 'div';
-    let result;
-    if (namespace !== Namespace.HTML) {
-        result = dom.createElementNS(namespace, tagName);
-    }
-    else {
-        result = dom.createElement(tagName);
-    }
-    if (match[3]) {
-        result.id = match[3];
-    }
-    if (match[4]) {
-        result.className = match[4].replace(/\./g, ' ').trim();
-    }
-    if (attrs) {
-        Object.entries(attrs).forEach(([name, value]) => {
-            if (typeof value === 'undefined') {
-                return;
-            }
-            if (/^on\w+$/.test(name)) {
-                result[name] = value;
-            }
-            else if (name === 'selected') {
-                if (value) {
-                    result.setAttribute(name, 'true');
-                }
-            }
-            else {
-                result.setAttribute(name, value);
-            }
-        });
-    }
-    result.append(...children);
-    return result;
-}
-function $(description, attrs, ...children) {
-    return _$(Namespace.HTML, description, attrs, ...children);
-}
-
-const ARRAY_MUTATORS = new Set(['push', 'pop', 'shift', 'unshift', 'splice', 'reverse', 'sort']);
-const NOT_META = Symbol('');
-const metaReaders = new Map([
-    ["[__isReactive__]" /* Flags.IS_REACTIVE */, () => true],
-    ["[__isReadonly__]" /* Flags.IS_READONLY */, engine => engine.isReadonly],
-    ["[__issuperficial__]" /* Flags.IS_SUPERFICIAL */, engine => engine.superficial],
-    ["[__get_setup__]" /* Flags.GET_SETUP */, (_engine, target) => target],
-    ["[__raw__]" /* Flags.RAW */, (engine, target, receiver) => engine.ReactiveMap().get(target) === receiver ? target : NOT_META],
-]);
-function readMeta(engine, target, key, receiver) {
-    if (typeof key !== 'string' || key.charCodeAt(0) !== 91)
-        return NOT_META;
-    const reader = metaReaders.get(key);
-    return reader === undefined ? NOT_META : reader(engine, target, receiver);
-}
-function createGetter(engine) {
-    return function (target, p, receiver) {
-        const meta = readMeta(engine, target, p, receiver);
-        if (meta !== NOT_META)
-            return meta;
-        if (Array.isArray(target) && !engine.isReadonly) {
-            const patched = engine.arrayMethods.get;
-            if (hasOwn(patched, p)) {
-                const method = patched[p];
-                if (ARRAY_MUTATORS.has(p))
-                    addArrayStack(p);
-                else
-                    track(target, p);
-                return method;
-            }
-        }
-        const value = Reflect.get(target, p, receiver);
-        if (p === '__proto__' || isIntrinsicSymbol(p))
-            return value;
-        if (!engine.isReadonly)
-            track(target, p);
-        if (engine.superficial || !isObject(value))
-            return value;
-        return engine.reactive(value);
-    };
-}
-
-function createSetter(engine) {
-    return function (target, p, newValue, receiver) {
-        if (isReadonly(target)) {
-            return false;
-        }
-        const isArray = Array.isArray(target);
-        const oldValue = target[p];
-        const oldLength = isArray ? target.length : 0;
-        const numeric = isArray && isNumericKey(p);
-        const hadKey = numeric ? Number(p) < oldLength : hasOwn(target, p);
-        const res = Reflect.set(target, p, newValue, receiver);
-        if (engine.onValueChanged) {
-            try {
-                engine.onValueChanged({ raw: target, proxy: receiver }, p);
-            }
-            catch { }
-        }
-        if (getRaw(target) !== getRaw(receiver)) {
-            return res;
-        }
-        if (!isArray && hadKey && Object.is(newValue, oldValue)) {
-            return res;
-        }
-        trigger(target, p);
-        if (!isArray && !hadKey) {
-            trigger(target, ITERATE_KEY);
-        }
-        if (numeric && !hadKey) {
-            trigger(target, 'length');
-        }
-        if (isArray && p === 'length') {
-            const newLength = Number(newValue);
-            for (let i = newLength; i < oldLength; i++) {
-                trigger(target, String(i));
-            }
-        }
-        removeArrayStack();
-        return res;
-    };
-}
-
-function createOwn(engine) {
-    return function ownKeys(target) {
-        const shapeKey = Array.isArray(target) ? 'length' : ITERATE_KEY;
-        track(target, shapeKey);
-        return Reflect.ownKeys(target);
-    };
-}
-function createHas(engine) {
-    return function has(target, p) {
-        const found = Reflect.has(target, p);
-        if (isIntrinsicSymbol(p))
-            return found;
-        track(target, p);
-        return found;
-    };
-}
-function createDelete(engine) {
-    return function deleteProperty(target, p) {
-        pauseTracking();
-        try {
-            const isOwned = hasOwn(target, p);
-            const result = Reflect.deleteProperty(target, p);
-            if (isOwned) {
-                if (Array.isArray(target)) {
-                    trigger(target, 'length');
-                }
-                else {
-                    trigger(target, p);
-                    trigger(target, ITERATE_KEY);
-                }
-            }
-            return result;
-        }
-        finally {
-            resetTracking();
-        }
-    };
-}
-
-const PATCHED_ARRAY_METHODS = [
-    ['includes', 'lookup'],
-    ['indexOf', 'lookup'],
-    ['lastIndexOf', 'lookup'],
-    ['sort', 'order'],
-    ['concat', 'join'],
-    ['push', 'structural'],
-    ['pop', 'structural'],
-    ['shift', 'structural'],
-    ['unshift', 'structural'],
-    ['splice', 'structural'],
-    ['reverse', 'structural'],
-];
-const isLookupMiss = (outcome) => outcome === false || outcome === -1;
-class ArrayMethods {
-    engine;
-    constructor(engine) {
-        this.engine = engine;
-    }
-    get = this.createArrayMethods();
-    createArrayMethods() {
-        const table = {};
-        for (const [name, kind] of PATCHED_ARRAY_METHODS) {
-            table[name] = this.patch(name, kind);
-        }
-        return table;
-    }
-    patch(name, kind) {
-        const owner = this;
-        switch (kind) {
-            case 'lookup':
-                return function (...needles) {
-                    const source = getRaw(this);
-                    owner.engine.track(source, 'length');
-                    const direct = source[name](...needles);
-                    if (!isLookupMiss(direct))
-                        return direct;
-                    return source[name](...needles.map(needle => getRaw(needle)));
-                };
-            case 'order':
-                return function (...args) {
-                    const source = getRaw(this);
-                    const size = this.length;
-                    for (let index = 0; index < size; index++) {
-                        owner.engine.track(source, String(index));
-                    }
-                    const sorted = source[name].apply(this, args);
-                    owner.engine.track(source, name);
-                    return sorted;
-                };
-            case 'join':
-                return function (...args) {
-                    return Array.prototype.concat.apply(this, args);
-                };
-            default:
-                return function (...args) {
-                    pauseTracking();
-                    const source = getRaw(this);
-                    try {
-                        return source[name].apply(this, args);
-                    }
-                    finally {
-                        resetTracking();
-                    }
-                };
-        }
-    }
-}
-
-const ReactiveEngineMapper = new WeakSet();
-const AllreactiveMap = new WeakMap();
-function armgetter() { return AllreactiveMap; }
-class ReactiveEngine {
-    _gci;
-    startGc(_intervalMs = 10000) { }
-    stopGc() { if (this._gci) {
-        try {
-            clearInterval(this._gci);
-        }
-        catch { }
-        this._gci = undefined;
-    } }
-    constructor() {
-        ReactiveEngineMapper.add(this);
-        this.startGc();
-    }
-    DisposeMapper = new LinkedList();
-    arrayTriggerCache = new Map();
-    ReactiveMap = () => armgetter();
-    activeCallback;
-    isReadonly = false;
-    superficial = false;
-    arrayMethods = new ArrayMethods(this);
-    arrayHandler = {
-        get: createGetter(this),
-        set: createSetter(this),
-        has: createHas(),
-        deleteProperty: createDelete(),
-        ownKeys: createOwn()
-    };
-    deepHandler = {
-        get: createGetter(this),
-        set: createSetter(this),
-        has: createHas(),
-        deleteProperty: createDelete(),
-        ownKeys: createOwn()
-    };
-    reactive(model) {
-        if (!isObject(model)) {
-            model = { value: model };
-        }
-        const targetType = getTargetType(model);
-        if (targetType === 0 /* TargetType.SYSTEM */ || targetType === 2 /* TargetType.COLLECTION */ || 0 /* TargetType.INVALID */) {
-            return model;
-        }
-        let existingProxy = AllreactiveMap.get(model);
-        if (existingProxy) {
-            return existingProxy;
-        }
-        existingProxy = AllreactiveMap.get(getRaw(model));
-        if (existingProxy) {
-            return existingProxy;
-        }
-        // if (targetType === TargetType.INVALID) {
-        if (Array.isArray(model)) {
-            var proxy = new Proxy(model, this.arrayHandler);
-            // var original = Object.getPrototypeOf(proxy);
-            // original["copy"] = () => { return model; }
-            //     return "copied";
-            AllreactiveMap.set(model, proxy);
-            // try { this.startGc(); } catch { }
-            return proxy;
-        }
-        else {
-            var proxy = new Proxy(model, this.deepHandler);
-            AllreactiveMap.set(model, proxy);
-            // try { this.startGc(); } catch { }
-            return proxy;
-        }
-    }
-    clearModel(model) {
-        if (model != null && model != undefined) {
-            Object.keys(model).forEach((key) => {
-                if (typeof model[key] === 'object') {
-                    if (AllreactiveMap.has(model[key]) || AllreactiveMap.has(getRaw(model[key]))) {
-                        this.clearModel(model[key]);
-                    }
-                }
-                AllreactiveMap.delete(getRaw(model[key]));
-                AllreactiveMap.delete(model[key]);
-            });
-            AllreactiveMap.delete(getRaw(model));
-            AllreactiveMap.delete(model);
-        }
-    }
-    track(model, key) {
-        track(model, key);
-    }
-    trigger(model, key, value) {
-        trigger(model, key);
-    }
-    ArrayTrigger(target, key, ...args) {
-        this.trigger(target, key, args);
-    }
-    onValueChanged;
-    toRaw(item) {
-        return JSON.parse(JSON.stringify(this.deepClone(item)));
-    }
-    deepClone(item) {
-        var self = this;
-        if (!item) {
-            return item;
-        }
-        var types = [Number, String, Boolean], result;
-        types.forEach(function (type) {
-            if (item instanceof type) {
-                result = type(item);
-            }
-        });
-        if (typeof result == "undefined") {
-            if (Object.prototype.toString.call(item) === "[object Array]") {
-                result = [];
-                item.forEach(function (child, index, array) {
-                    result[index] = self.deepClone(child);
-                });
-            }
-            else if (typeof item == "object") {
-                if (item.nodeType && typeof item.cloneNode == "function") {
-                    result = item.cloneNode(true);
-                }
-                else if (!item.prototype) {
-                    if (item instanceof Date) {
-                        result = new Date(item);
-                    }
-                    else {
-                        result = {};
-                        for (var i in item) {
-                            result[i] = self.deepClone(item[i]);
-                        }
-                    }
-                }
-                else {
-                    {
-                        result = item;
-                    }
-                }
-            }
-            else {
-                result = item;
-            }
-        }
-        return result;
-    }
-    pauseTracking() {
-        pauseTracking();
-    }
-    enableTracking() {
-        enableTracking();
-    }
-    resetTracking() {
-        resetTracking();
-    }
-    dispose() {
-        var cnt = true;
-        this.stopGc();
-        while (cnt == true) {
-            if (this.DisposeMapper.size > 0) {
-                const element = this.DisposeMapper.pop();
-                //     if (ApplicationService.current?.Options?.onReactiveEffectRun) {
-                AllreactiveMap.delete(element);
-            }
-            else {
-                cnt = false;
-            }
-        }
-        this.DisposeMapper.clear();
-        ReactiveEngineMapper.delete(this);
-        // if (ApplicationService.current?.Options?.onReactiveEffectRun) {
-    }
-}
-
-const engine = new ReactiveEngine();
-/* @DEV-ONLY */ const reactiveRegistry = [];
-const isDevRegistryEnabled = () => {
-    try {
-        const g = globalThis;
-        if (!g.__MOTIF_DEV__)
-            return false;
-        if (g.__MOTIF_STORE_REGISTRY__ !== reactiveRegistry)
-            g.__MOTIF_STORE_REGISTRY__ = reactiveRegistry;
-        return true;
-    }
-    catch {
-        return false;
-    }
-};
-// export * from "./IStoreBinder";
-// export function reactiveListeners(model?: any) {
-//     if (model) {
-//         /* @DEV-ONLY */return debugGetDeps(model) ?? new Map();
-//     return debugGetDepMap();
-function reactive(model) {
-    const result = engine.reactive(model);
-    /* @DEV-ONLY */ try {
-        /* @DEV-ONLY */ if (isDevRegistryEnabled()) {
-            /* @DEV-ONLY */ const name = model?.constructor?.name || 'reactive';
-            /* @DEV-ONLY */ reactiveRegistry.push({ name, value: result, type: 'reactive' });
-            /* @DEV-ONLY */ if (reactiveRegistry.length > 200)
-                reactiveRegistry.shift();
-            /* @DEV-ONLY */ }
-        /* @DEV-ONLY */
-        /* @DEV-ONLY */ }
-    catch { }
-    return result;
-}
-function useModel(model) {
-    const result = engine.reactive(model);
-    /* @DEV-ONLY */ try {
-        /* @DEV-ONLY */ if (isDevRegistryEnabled()) {
-            /* @DEV-ONLY */ const name = model?.constructor?.name || 'useModel';
-            /* @DEV-ONLY */ reactiveRegistry.push({ name, value: result, type: 'reactive' });
-            /* @DEV-ONLY */ if (reactiveRegistry.length > 200)
-                reactiveRegistry.shift();
-            /* @DEV-ONLY */ }
-        /* @DEV-ONLY */
-        /* @DEV-ONLY */ }
-    catch { }
-    return result;
-}
-function clearModel(model) {
-    return engine.clearModel(model);
-}
-function deepClone(item) {
-    return engine.deepClone(item);
-}
-function createSignal(initialValue) {
-    const sig = new Signal(initialValue);
-    /* @DEV-ONLY */ try {
-        /* @DEV-ONLY */ if (isDevRegistryEnabled()) {
-            /* @DEV-ONLY */ const name = `signal_${reactiveRegistry.length}`;
-            /* @DEV-ONLY */ reactiveRegistry.push({ name, value: sig.value, type: 'signal' });
-            /* @DEV-ONLY */ if (reactiveRegistry.length > 200)
-                reactiveRegistry.shift();
-            /* @DEV-ONLY */ }
-        /* @DEV-ONLY */
-        /* @DEV-ONLY */ }
-    catch { }
-    return sig;
-}
-function createComputed(getter) {
-    const comp = new Computed(getter);
-    /* @DEV-ONLY */ try {
-        /* @DEV-ONLY */ if (isDevRegistryEnabled()) {
-            /* @DEV-ONLY */ const name = `computed_${reactiveRegistry.length}`;
-            /* @DEV-ONLY */ reactiveRegistry.push({ name, value: comp.value, type: 'computed' });
-            /* @DEV-ONLY */ if (reactiveRegistry.length > 200)
-                reactiveRegistry.shift();
-            /* @DEV-ONLY */ }
-        /* @DEV-ONLY */
-        /* @DEV-ONLY */ }
-    catch { }
-    return comp;
-}
-function createLazyComputed(getter) {
-    const comp = new LazyComputed(getter);
-    /* @DEV-ONLY */ try {
-        /* @DEV-ONLY */ if (isDevRegistryEnabled()) {
-            /* @DEV-ONLY */ const name = `lazyComputed_${reactiveRegistry.length}`;
-            /* @DEV-ONLY */ reactiveRegistry.push({ name, value: undefined, type: 'computed' });
-            /* @DEV-ONLY */ if (reactiveRegistry.length > 200)
-                reactiveRegistry.shift();
-            /* @DEV-ONLY */ }
-        /* @DEV-ONLY */
-        /* @DEV-ONLY */ }
-    catch { }
-    return comp;
-}
-
-exports.$ = $;
-exports.Computed = Computed;
-exports.ErrorHandler = ErrorHandler;
-exports.LazyComputed = LazyComputed;
-exports.LinkedList = LinkedList;
-exports.MotifError = MotifError;
-exports.Signal = Signal;
-exports.asyncTracking = asyncTracking;
-exports.callReported = callReported;
-exports.clearModel = clearModel;
-exports.configureReactivityLeakMonitor = configureReactivityLeakMonitor;
-exports.createComputed = createComputed;
-exports.createLazyComputed = createLazyComputed;
-exports.createSignal = createSignal;
-exports.debugGetDepMap = debugGetDepMap;
-exports.debugGetDeps = debugGetDeps;
-exports.deepClone = deepClone;
-exports.dom = dom;
-exports.effect = effect;
-exports.engine = engine;
-exports.ensureDevtoolsFlagInitialized = ensureDevtoolsFlagInitialized;
-exports.errorHandler = errorHandler;
-exports.formatMotifMessage = formatMotifMessage;
-exports.getRaw = getRaw;
-exports.isDevLike = isDevLike;
-exports.isEnabled = isEnabled;
-exports.motifError = motifError;
-exports.on = on;
-exports.reactive = reactive;
-exports.reportError = reportError;
-exports.reportWarning = reportWarning;
-exports.safeCall = safeCall;
-exports.safeCallAsync = safeCallAsync;
-exports.safeCallSilent = safeCallSilent;
-exports.safeCallSilentAsync = safeCallSilentAsync;
-exports.setErrorConsoleLogging = setErrorConsoleLogging;
-exports.setRoutes = setRoutes;
-exports.setUnexpectedErrorHandler = setUnexpectedErrorHandler;
-exports.untracked = untracked;
-exports.useModel = useModel;
-//# sourceMappingURL=core-DXGu4dNE.cjs.map