lilact 0.14.2 → 0.15.0

package/src/accessories.jsx

@@ -29,14 +29,11 @@
 */
 
 
-import { useEffect, useLayoutEffect, useMemo, useRef, useState, useImperativeHandle } from "./hooks.jsx";
-import { Children, forwardRef } from "./misc.jsx";
+import { useEffect, useLayoutEffect, useMemo, useRef, useState, useImperativeHandle, useCallback } from "./hooks.jsx";
+import { Children, forwardRef, isThenable } from "./misc.jsx";
 
-
-import {isThenable} from "./misc.jsx"
 import {setTimeout, clearTimeout} from "./timers.jsx"
 import {Component} from "./components.jsx"
-import {useCallback} from './hooks.jsx'
 import {emotion} from "./lilact.jsx"
 const {css,cx} = emotion;
 
@@ -167,7 +164,7 @@ export class Suspense extends Component
 
 /** @ignore */
 	static getDerivedStateFromError(error) {
-		if (Lilact.isThenable(error)) {
+		if (isThenable(error)) {
 			// signal to call componentDidCatch where we handle the thenable
 			return null;
 		}
@@ -177,7 +174,7 @@ export class Suspense extends Component
 
 /** @ignore */
 	componentDidCatch(error) {
-		if (!Lilact.isThenable(error)) return;
+		if (!isThenable(error)) return;
 
 		const promise = error;
 
@@ -191,10 +188,10 @@ export class Suspense extends Component
 			const delay = Math.max(0, this.props.minDelay);
 			// Ensure no leftover timers
 			if (this._delayTimer) {
-				Lilact.clearTimeout(this._delayTimer);
+				clearTimeout(this._delayTimer);
 				this._delayTimer = null;
 			}
-			this._delayTimer = Lilact.setTimeout(() => {
+			this._delayTimer = setTimeout(() => {
 				this._delayTimer = null;
 				this._fallbackShownAt = Date.now();
 				this.setState({ showingFallback: true });
@@ -211,11 +208,11 @@ export class Suspense extends Component
 /** @ignore */
 	_clearTimers() {
 		if (this._delayTimer) {
-			Lilact.clearTimeout(this._delayTimer);
+			clearTimeout(this._delayTimer);
 			this._delayTimer = null;
 		}
 		if (this._minShowTimer) {
-			Lilact.clearTimeout(this._minShowTimer);
+			clearTimeout(this._minShowTimer);
 			this._minShowTimer = null;
 		}
 	}
@@ -228,10 +225,10 @@ export class Suspense extends Component
 		if (this._pending.size === 1) {
 			const delay = Math.max(0, this.props.minDelay);
 			if (this._delayTimer) {
-				Lilact.clearTimeout(this._delayTimer);
+				clearTimeout(this._delayTimer);
 				this._delayTimer = null;
 			}
-			this._delayTimer = Lilact.setTimeout(() => {
+			this._delayTimer = setTimeout(() => {
 				this._delayTimer = null;
 				this._fallbackShownAt = Date.now();
 				this.setState({ showingFallback: true });
@@ -247,7 +244,7 @@ export class Suspense extends Component
 			if (this._pending.size === 0) {
 				// cancel delay if fallback hasn't shown yet
 				if (this._delayTimer) {
-					Lilact.clearTimeout(this._delayTimer);
+					clearTimeout(this._delayTimer);
 					this._delayTimer = null;
 					// fallback never shown; just ensure state is not showing
 					this.setState({ showingFallback: false });
@@ -262,10 +259,10 @@ export class Suspense extends Component
 					this.setState({ showingFallback: false });
 				} else {
 					if (this._minShowTimer) {
-						Lilact.clearTimeout(this._minShowTimer);
+						clearTimeout(this._minShowTimer);
 						this._minShowTimer = null;
 					}
-					this._minShowTimer = Lilact.setTimeout(() => {
+					this._minShowTimer = setTimeout(() => {
 						this._minShowTimer = null;
 						this.setState({ showingFallback: false });
 					}, remaining);
@@ -279,7 +276,7 @@ export class Suspense extends Component
 
 /** @ignore */
 	componentDidCatch(error, info) {
-		if (!Lilact.isThenable(error)) return;
+		if (!isThenable(error)) return;
 		this._attachPromise(error);
 	}
 

package/src/components.jsx

@@ -28,9 +28,8 @@
 
 */
 
-ʔ defineSymbols ( "LILACT", [ "CORE", "COMPONENT", "TEXT", "IS_ZOMBIE", "IDX", "CHILD_CLASS_ADDENDUM", "MEMOIZED"] ) ʔ
-
-import {shallowEqual} from "./misc.jsx";
+import { CORE, COMPONENT, TEXT, IS_ZOMBIE, IDX, CHILD_CLASS_ADDENDUM, MEMOIZED } from "./symbols.jsx"
+import { shallowEqual } from "./misc.jsx";
 
 /* 
 ComponentCache is for internal use. It is the heart of the JSX runtime,
@@ -163,7 +162,7 @@ class ComponentCore
 		// }
 
 		/*if(do_rerender)*/ {
-ʔ if(DEBUG) {
+if(DEBUG) {
 
 			if(this.entity?.propTypes) {
 				Lilact.PropTypes.checkPropTypes(this.entity.propTypes, this.props, 'prop', this.entity.name);
@@ -172,7 +171,7 @@ class ComponentCore
 				Lilact.PropTypes.checkPropTypes(this.component.propTypes, this.props, 'prop', this.component.name);
 			}
 
-ʔ }	
+}	
 			if(typeof(next_state)==='function') next_state = next_state(this.state);
 
 			if(this.component.constructor.defaultProps) {
@@ -473,9 +472,9 @@ class ComponentCore
 			this.element.onsubmit = undefined;
 		}
 
-ʔ if(DEBUG) {
+if(DEBUG) {
 		//this.element.setAttribute('key', this.props.key);
-ʔ }		
+}		
 
 		this.updateElementClass(patch);
 	}

package/src/hooks.jsx

@@ -28,7 +28,9 @@
 
 */
 
-ʔ defineSymbols ( "LILACT", [ "CORE", "COMPONENT" ] ) ʔ
+import { isEmpty } from "./misc.jsx"
+
+import { CORE, COMPONENT } from "./symbols.jsx"
 
 
 /**
@@ -57,9 +59,9 @@ export function useHook()
  */
 export function useState(initialValue)
 {
-	const hk = Lilact.useHook();
+	const hk = useHook();
 
-	if( Lilact.isEmpty(hk) ) {
+	if( isEmpty(hk) ) {
 		if(typeof(initialValue)==='function') hk.value = initialValue();
 		else hk.value = initialValue;
 		
@@ -88,9 +90,9 @@ export function useCallback(callback, deps=undefined)
 		throw new Error("Callback dependencies must be an array or omitted.");
 	}
 
-	const hk = Lilact.useHook();
+	const hk = useHook();
 
-	if( !Lilact.isEmpty(hk) ) {
+	if( !isEmpty(hk) ) {
 		if(deps!==undefined && hk?.deps!==undefined && Lilact.shallowEqual(deps, hk.deps)) {
 			return hk.callback;
 		}
@@ -154,9 +156,9 @@ export function useContext(context)
  */
 export function useId(prefix="N")
 {
-	const hk = Lilact.useHook();
+	const hk = useHook();
 
-	if( Lilact.isEmpty(hk) ) {
+	if( isEmpty(hk) ) {
 		hk.id = prefix+Lilact.id_num++;
 	}
 
@@ -170,9 +172,9 @@ export function useId(prefix="N")
  */
 export function useTransition()
 {
-	const hk = Lilact.useHook();
+	const hk = useHook();
 
-	if( Lilact.isEmpty(hk) ) {
+	if( isEmpty(hk) ) {
 		hk.count=0;
 
 		hk.func =
@@ -210,7 +212,7 @@ export function useTransition()
 export function useLocalStorage(key, initialValue)
 {
 
-	const hk = Lilact.useHook();
+	const hk = useHook();
 	let val;
 
 	try {
@@ -225,7 +227,7 @@ export function useLocalStorage(key, initialValue)
 		localStorage[key] = JSON.stringify(val);
 	}
 
-	if( Lilact.isEmpty(hk) ) {
+	if( isEmpty(hk) ) {
 		hk.value = val;
 		hk.set_func = function(core, hk, val) {
 
@@ -253,9 +255,9 @@ export function useLocalStorage(key, initialValue)
  */
 export function useRef(initialValue = null)
 {
-	const hk = Lilact.useHook();
+	const hk = useHook();
 
-	if( Lilact.isEmpty(hk) ) {
+	if( isEmpty(hk) ) {
 		hk.current = initialValue;
 	}
 
@@ -275,9 +277,9 @@ export function useLayoutEffect(effect, deps=undefined)
 		throw new Error("Layout effect dependencies must be an array or omitted.");
 	}
 
-	const hk = Lilact.useHook();
+	const hk = useHook();
 
-	if( !Lilact.isEmpty(hk) ) {
+	if( !isEmpty(hk) ) {
 		if(deps!==undefined && hk?.deps!==undefined && Lilact.shallowEqual(deps, hk.deps)) return;
 	}
 
@@ -303,9 +305,9 @@ export function useEffect(effect, deps=undefined)
 		throw new Error("Effect dependencies must be an array or omitted.");
 	}
 
-	const hk = Lilact.useHook();
+	const hk = useHook();
 
-	if( !Lilact.isEmpty(hk) ) {
+	if( !isEmpty(hk) ) {
 		if(deps!==undefined && hk?.deps!==undefined && Lilact.shallowEqual(deps, hk.deps)) return;
 	}
 
@@ -331,9 +333,9 @@ export function useMemo(factory,deps=undefined)
 		throw new Error("Memo dependencies must be an array or omitted.");
 	}
 
-	const hk = Lilact.useHook();
+	const hk = useHook();
 
-	if( !Lilact.isEmpty(hk) ) {
+	if( !isEmpty(hk) ) {
 		if(deps!==undefined && hk?.deps!==undefined && Lilact.shallowEqual(deps, hk.deps)) {
 			return hk.value;
 		}
@@ -354,10 +356,10 @@ export function useMemo(factory,deps=undefined)
  */
 export function useActionState(action, initialState)
 {
-	const hk = Lilact.useHook();
+	const hk = useHook();
 	const [is_pending, tran_start_func] = Lilact.useTransition();
 
-	if( Lilact.isEmpty(hk) ) {
+	if( isEmpty(hk) ) {
 
 		hk.state = initialState;
 
@@ -389,9 +391,9 @@ export function useActionState(action, initialState)
  */
 export function useReducer(reducer, initialArg, init)
 {
-	const hk = Lilact.useHook();
+	const hk = useHook();
 
-	if( Lilact.isEmpty(hk) ) {
+	if( isEmpty(hk) ) {
 		hk.reducer = reducer;
 		hk.state = init?init(initialArg):initialArg;
 		hk.dispatch = function(core, hk, action) {
@@ -400,7 +402,6 @@ export function useReducer(reducer, initialArg, init)
 				hk.state = newst;
 				core.component.forceUpdate();
 			}
-
 		}.bind(undefined, Lilact.current_component[0], hk);
 	}
 

package/src/lilact.jsx

@@ -92,7 +92,7 @@ export {transpileJSX, transpilerConfig} from "./jsx";
 export const Lilact = 
 {	
 
-	VERSION: "beta.14",
+	VERSION: "beta.15",
 	
 	// Configuration
 
@@ -132,16 +132,16 @@ document.addEventListener('DOMContentLoaded', () => {
   Lilact.runScripts();
 });
 
-ʔ if(DEBUG) {
-window.addEventListener('error', (e) => {
-	Lilact.globalErrorHandler(e);
-});
-ʔ }
+if(DEBUG) {
+	window.addEventListener('error', (e) => {
+		Lilact.globalErrorHandler(e);
+	});
+}
 
-ʔ if(DEBUG) {
+if(DEBUG) {
 	console.log(`Lilact (Version: ${Lilact.VERSION}) - Debug Mode`);
 	console.log(`Copyright(C) 2024-2026 Arash Kazemi <contact.arash.kazemi@gmail.com>`);
-ʔ }
+}
 
 export default Lilact;
 

package/src/loader.cjs

@@ -43,7 +43,7 @@ module.exports = function loader(source) {
 	// 										transpilerConfig
 	// 									});
 
-	console.log("Transpiling", DEBUG, this.resource);
+	console.log("Transpiling", this.resource);
 	source = transpileJSX(source,
 								{ 
 									path: this.resource,

package/src/misc.jsx

@@ -31,7 +31,7 @@
 import Lilact from './lilact.jsx';
 
 
-ʔ defineSymbols ( "LILACT", [ "CORE", "COMPONENT", "MEMOIZED"] ) ʔ
+import { CORE, COMPONENT, MEMOIZED } from "./symbols.jsx"
 
 
 const typeOf = (input) => {
@@ -338,9 +338,6 @@ export function toBool(value) {
 
 // Internals
 
-/** @ignore */
-export const required_scripts = {};
-
 /** @ignore */
 export let update_timeout = undefined;
 /** @ignore */

package/src/redux.jsx

@@ -28,8 +28,10 @@
 
 */
 
+import { createContext, useContext, useRef, useState, useEffect } from './hooks.jsx'
+import { shallowEqual } from './misc.jsx'
 
-ʔ defineSymbols ( "LILACT", [ "CORE" ] ) ʔ
+import { CORE } from "./symbols.jsx"
 
 let ReduxContext;
 
@@ -42,7 +44,7 @@ let ReduxContext;
  */
 export function Provider({ store, children }) 
 {
-	ReduxContext ??= Lilact.createContext(null);
+	ReduxContext ??= createContext(null);
 	return (
 		<ReduxContext.Provider value={store}>{children}</ReduxContext.Provider>
 	);
@@ -55,7 +57,7 @@ export function Provider({ store, children })
  */
 export function useStore() 
 {
-	const store = Lilact.useContext(ReduxContext);
+	const store = useContext(ReduxContext);
 	if (!store) {
 		throw new Error("Could not find Redux store in context. <Provider> is missing.");
 	}
@@ -70,7 +72,7 @@ export function useStore()
  */
 export function useDispatch() 
 {
-	const store = Lilact.useStore();
+	const store = useStore();
 	return store.dispatch;
 }
 
@@ -82,17 +84,17 @@ export function useDispatch()
  * @returns The selected slice of state.
  */
 export function useSelector(selector, equalityFn = (a, b) => a === b) {
-  const store = Lilact.useStore();
-  const latestSelected = Lilact.useRef();
-  const selectorRef = Lilact.useRef(selector);
+  const store = useStore();
+  const latestSelected = useRef();
+  const selectorRef = useRef(selector);
   selectorRef.current = selector;
 
-  const [selected, setSelected] = Lilact.useState(() => selector(store.getState()));
+  const [selected, setSelected] = useState(() => selector(store.getState()));
 
   // Keep ref in sync for the subscription callback
   latestSelected.current = selected;
 
-  Lilact.useEffect(() => {
+  useEffect(() => {
     function checkForUpdates() {
       const nextSelected = selectorRef.current(store.getState());
       if (!equalityFn(latestSelected.current, nextSelected)) {
@@ -127,7 +129,7 @@ export function connect(mapStateToProps, mapDispatchToProps)
 	return function wrapWithConnect(WrappedComponent) {
 
 		function ConnectedComponent(props) {
-			const store = Lilact.useStore();
+			const store = useStore();
 
 			let dispatchProps = { dispatch: store.dispatch };
 
@@ -148,7 +150,7 @@ export function connect(mapStateToProps, mapDispatchToProps)
 				const selector = (state) => mapStateToProps(state, props);
 
 				// todo: is shallowEqual enough?
-				stateProps = Lilact.useSelector(selector, Lilact.shallowEqual) || {};
+				stateProps = useSelector(selector, shallowEqual) || {};
 			}
 
 			const mergedProps = { ...props, ...stateProps, ...dispatchProps };

package/src/router.jsx

@@ -28,7 +28,7 @@
 
 */
 
-ʔ defineSymbols ( "LILACT", [ "CORE", "COMPONENT" ] ) ʔ
+import { CORE, COMPONENT } from "./symbols.jsx"
 
 import {createContext, useContext, useState, useCallback, useEffect} from "./hooks.jsx"
 import {Children} from "./misc.jsx"

package/src/run.jsx

@@ -27,10 +27,13 @@
 	THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 */
+import Lilact from './lilact.jsx';
 
-ʔ defineSymbols ( "LILACT", [ "CORE", "COMPONENT", "LAZY" ] ) ʔ
+import { CORE, COMPONENT, LAZY } from "./symbols.jsx"
 
-import Lilact from './lilact.jsx';
+
+/** @ignore */
+export const required_scripts = {};
 
 
 /**
@@ -49,7 +52,7 @@ export function run(jsx, path=`InlineJSX-${++Lilact.eval_num}`, is_inline=true)
 	let processed;
 
 
-	Lilact.required_scripts[path] = { 	
+	required_scripts[path] = { 	
 		mappings,
 		module,
 		is_inline,
@@ -76,9 +79,9 @@ export function run(jsx, path=`InlineJSX-${++Lilact.eval_num}`, is_inline=true)
 		throw e;
 	}
 
-ʔ if(DEBUG) {
-		Lilact.required_scripts[path].processed = processed;
-ʔ }		
+if(DEBUG) {
+		required_scripts[path].processed = processed;
+}		
 	
 	processed += "\n//# sourceURL=eval:/" + path;
 
@@ -105,11 +108,11 @@ export function run(jsx, path=`InlineJSX-${++Lilact.eval_num}`, is_inline=true)
 /**
  * Loads a jsx script from a path. All scripts can access Lilact namespace as a global object. 
  * 
- * `Lilact.require` loads synchronously, as it is expected to be loaded on the next instruction.
+ * `require` loads synchronously, as it is expected to be loaded on the next instruction.
  * 
  * As running the transpiled scripts rely on `new Function`, it is not possible to use module imports 
  * and exports. So to import you should use `const {useState} = Lilact` convention. And to 
- * export, you should use `module.exports = ...`. `Lilact.require` returns `module.exports` value
+ * export, you should use `module.exports = ...`. `require` returns `module.exports` value
  * so you can import different modules using the convention above.
  * 
  * If the path is in the format #id, it will query the document for a script element with the given 
@@ -126,14 +129,14 @@ export function run(jsx, path=`InlineJSX-${++Lilact.eval_num}`, is_inline=true)
  */
 export function require(path, forceUpdate)
 {
-	if(Lilact.required_scripts[path] && !forceUpdate) return Lilact.required_scripts[path].module.exports;
+	if(required_scripts[path] && !forceUpdate) return required_scripts[path].module.exports;
 	
 	if(path[0]==='#') {
 
 		const el = document.getElementById(path);
 
 		if(el) {
-			return Lilact.run(el.innerText, path);
+			return run(el.innerText, path);
 		}
 
 	}
@@ -146,7 +149,7 @@ export function require(path, forceUpdate)
 				return res.text();
 			})
 			.then(res => {
-				res = Lilact.run(res, path, false);
+				res = run(res, path, false);
 				// todo: this is for the lazy, so we detect default, should we do it in sync mode too?
 				return res?.default ?? res;
 			})
@@ -162,7 +165,7 @@ export function require(path, forceUpdate)
 		request.open("GET", path, false);
 		request.send(null);
 		if (request.status === 200) {
-			return Lilact.run(request.responseText, path, false);
+			return run(request.responseText, path, false);
 		}
 	}
 
@@ -230,8 +233,8 @@ function scanScriptTagsWithType() {
  * Scans the whole documents and runs all the script elements with type `text/jsx`.
  * It is automatically attached to document.onload when Lilact is loaded.
  * 
- * If element src is set, it will be loaded via `Lilact.require`.
- * If element has inner content, it will be executed via `Lilact.run`.
+ * If element src is set, it will be loaded via `require`.
+ * If element has inner content, it will be executed via `run`.
  * 
  * If both are present, first the src is loaded and then the inner content is executed.
  *
@@ -244,8 +247,8 @@ export function runScripts()
 	const scripts = scanScriptTagsWithType();
 
 	for(const s of scripts) {
-		if(s.src) Lilact.require(s.src);
-		if(s.content) Lilact.run(s.content);
+		if(s.src) require(s.src);
+		if(s.content) run(s.content);
 	}
 }
 

package/src/symbols.jsx

@@ -0,0 +1,64 @@
+/*
+
+	Lilact
+	Copyright (C) 2024-2026 Arash Kazemi <contact.arash.kazemi@gmail.com>
+	All rights reserved.
+
+	BSD-2-Clause
+
+	Redistribution and use in source and binary forms, with or without
+	modification, are permitted provided that the following conditions are met:
+
+	* Redistributions of source code must retain the above copyright
+		notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+		notice, this list of conditions and the following disclaimer in the
+		documentation and/or other materials provided with the distribution.
+
+	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+	AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+	IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+	ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+	DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+	(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+	LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+	ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+	(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+	THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+
+export const [ 	
+				CORE,
+				COMPONENT,
+				TEXT,
+				IS_ZOMBIE,
+				IDX,
+				CHILD_CLASS_ADDENDUM,
+				MEMOIZED,
+				LAZY,
+
+				DUE,
+				REPEAT,
+				CLEARED,
+				INTERVAL,
+				CALLBACK,
+				ARGS 
+			] = 
+			[
+				Symbol.for('LILACT:CORE'),
+				Symbol.for('LILACT:COMPONENT'),
+				Symbol.for('LILACT:TEXT'),
+				Symbol.for('LILACT:IS_ZOMBIE'),
+				Symbol.for('LILACT:IDX'),
+				Symbol.for('LILACT:CHILD_CLASS_ADDENDUM'),
+				Symbol.for('LILACT:MEMOIZED'),
+
+				Symbol.for('LILACT:TIMERS:DUE'),
+				Symbol.for('LILACT:TIMERS:REPEAT'),
+				Symbol.for('LILACT:TIMERS:CLEARED'),
+				Symbol.for('LILACT:TIMERS:INTERVAL'),
+				Symbol.for('LILACT:TIMERS:CALLBACK'),
+				Symbol.for('LILACT:TIMERS:ARGS')
+			];

package/src/timers.jsx

@@ -33,7 +33,7 @@
 //ʔ outputJS('./dist/timers.js');
 
 
-ʔ defineSymbols("LILACT:TIMERS", ["CORE", "IDX", "DUE", "REPEAT", "CLEARED", "INTERVAL", "CALLBACK", "ARGS"] ) ʔ
+import  { IDX, DUE, REPEAT, CLEARED, INTERVAL, CALLBACK, ARGS } from "./symbols.jsx"
 
 /**
  * Timer helpers for a promise-friendly timer framework.
@@ -254,10 +254,10 @@ export function clearInterval(id)
  */
 export function grabTimers()
 {
-	globalThis.setTimeout = this.setTimeout;
-	globalThis.setInterval = this.setInterval;
-	globalThis.clearTimeout = this.clearTimeout;
-	globalThis.clearInterval = this.clearInterval;
+	globalThis.setTimeout = Lilact.setTimeout;
+	globalThis.setInterval = Lilact.setInterval;
+	globalThis.clearTimeout = Lilact.clearTimeout;
+	globalThis.clearInterval = Lilact.clearInterval;
 }
 
 /**
@@ -277,7 +277,7 @@ export function releaseTimers()
  * @param {number} duration - Delay in milliseconds.
  * @returns {Promise} Promise that resolves after the delay.
  */
-export function timeoutPromise(duration=0, timerSource=this) 
+export function timeoutPromise(duration=0, timerSource=Lilact) 
 {	
 	let id, resolve, reject;
 

package/src/transition.jsx

@@ -27,8 +27,11 @@
 	THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 */
+import { setTimeout, clearTimeout } from "./timers.jsx"
+import { Children } from "./misc.jsx"
+import { useEffect, useLayoutEffect, useMemo, useRef, useState } from "./hooks.jsx"
 
-ʔ defineSymbols ( "LILACT", [ "CORE", "COMPONENT", "CHILD_CLASS_ADDENDUM" ] ) ʔ
+import { CORE, COMPONENT, CHILD_CLASS_ADDENDUM } from "./symbols.jsx"
 
 /* States */
 const UNMOUNTED = "unmounted";
@@ -37,9 +40,6 @@ const ENTERING =  "entering";
 const ENTERED =   "entered";
 const EXITING =   "exiting";
 
-import { setTimeout, clearTimeout} from "./timers.jsx"
-import { Children } from "./misc.jsx"
-import { useEffect, useLayoutEffect, useMemo, useRef, useState } from "./hooks.jsx"
 
 /**
  * Transition component that manages enter/exit lifecycle and calls callbacks based on state changes.