@expressive/mvc 0.73.0 → 0.78.0

package/dist/index.js

@@ -1,872 +1,11 @@
-Object.defineProperty(exports, '__esModule', { value: true });
-
-//#region src/observable.ts
-const Observable = Symbol("observe");
-/** Placeholder event determines if state is initialized or not. */
-const onReady = () => null;
-const LISTENERS = /* @__PURE__ */ new WeakMap();
-/** Events pending for a given object. */
-const PENDING = /* @__PURE__ */ new WeakMap();
-/** Update register. */
-const PENDING_KEYS = /* @__PURE__ */ new WeakMap();
-/** Central event dispatch. Bunches all updates to occur at same time. */
-const DISPATCH = /* @__PURE__ */ new Set();
-function addListener(subject, callback, select) {
-	let listeners = LISTENERS.get(subject);
-	if (!listeners) LISTENERS.set(subject, listeners = new Map([[onReady, void 0]]));
-	if (select !== void 0 && !(select instanceof Set)) select = new Set([select]);
-	if (!listeners.has(onReady) && !select) callback.call(subject, true, subject);
-	listeners.set(callback, select);
-	return () => listeners.delete(callback);
-}
-function emit(state, key) {
-	const listeners = LISTENERS.get(state);
-	const notReady = listeners.has(onReady);
-	if (key === true && !notReady) return;
-	let pending = PENDING.get(state);
-	if (pending) {
-		pending.add(key);
-		return;
-	}
-	PENDING.set(state, pending = new Set(notReady ? [true, key] : [key]));
-	for (const key of pending) for (const [callback, filter] of listeners) if (!filter || filter.has(key)) {
-		const after = callback.call(state, key, state);
-		if (after) enqueue(after);
-		else if (after === null) listeners.delete(callback);
-	}
-	if (key === null) listeners.clear();
-	PENDING.delete(state);
-}
-function event(subject, key, silent) {
-	if (key === null) return emit(subject, key);
-	if (!key) return emit(subject, true);
-	let pending = PENDING_KEYS.get(subject);
-	if (!pending) {
-		PENDING_KEYS.set(subject, pending = /* @__PURE__ */ new Set());
-		if (!silent) enqueue(() => {
-			emit(subject, false);
-			PENDING_KEYS.delete(subject);
-		});
-	}
-	pending.add(key);
-	if (!silent) emit(subject, key);
-}
-function enqueue(eventHandler) {
-	if (!DISPATCH.size) setTimeout(() => {
-		DISPATCH.forEach((event) => {
-			try {
-				event();
-			} catch (err) {
-				console.error(err);
-			}
-		});
-		DISPATCH.clear();
-	}, 0);
-	DISPATCH.add(eventHandler);
-}
-function watch(target, callback, argument) {
-	let unset;
-	let reset;
-	function invoke() {
-		let ignore = true;
-		function onUpdate() {
-			if (ignore || reset === null) return;
-			ignore = true;
-			if (reset && unset) {
-				unset(true);
-				unset = void 0;
-			}
-			enqueue(invoke);
-			return { then: enqueue };
-		}
-		try {
-			const exit = argument === false ? void 0 : scope();
-			const output = callback(target[Observable](onUpdate, argument === true));
-			const flush = exit ? exit() : () => {};
-			ignore = false;
-			reset = output === null ? null : invoke;
-			unset = (key) => {
-				if (typeof output == "function") output(key);
-				flush();
-			};
-		} catch (err) {
-			if (err instanceof Promise) {
-				reset = void 0;
-				err.then(invoke);
-			} else throw err;
-		}
-	}
-	function cleanup() {
-		if (unset) unset(false);
-		reset = null;
-	}
-	if (EffectContext && argument !== false) EffectContext.add(cleanup);
-	addListener(target, (key) => {
-		if (key === true) invoke();
-		else if (!reset) return reset;
-		if (key === null && unset) unset(null);
-	});
-	return cleanup;
-}
-let EffectContext;
-function scope() {
-	const last = EffectContext;
-	const context = EffectContext = /* @__PURE__ */ new Set();
-	return () => {
-		EffectContext = last;
-		return () => context.forEach((fn) => fn());
-	};
-}
-
-//#endregion
-//#region src/state.ts
-const define = Object.defineProperty;
-/** Register for all active states via string identifiers (usually unique). */
-const ID = /* @__PURE__ */ new WeakMap();
-/** Internal state assigned to states. */
-const STATE = /* @__PURE__ */ new WeakMap();
-/** External listeners for any given State. */
-const NOTIFY = /* @__PURE__ */ new WeakMap();
-/** Parent-child relationships. */
-const PARENT = /* @__PURE__ */ new WeakMap();
-/** List of methods defined by a given type. */
-const METHODS = /* @__PURE__ */ new WeakMap();
-/** Reference bound instance methods to real ones. */
-const METHOD = /* @__PURE__ */ new WeakMap();
-/** Currently accumulating export. Stores real values of placeholder properties such as ref() or child states. */
-let EXPORT;
-var State = class {
-	constructor(...args) {
-		prepare(this);
-		define(this, "is", { value: this });
-		init$1(this, ...args, (x) => x.new && x.new());
-	}
-	[Observable](callback, required) {
-		const watch = /* @__PURE__ */ new Set();
-		const proxy = Object.create(this);
-		addListener(this, (key) => {
-			if (watch.has(key)) callback();
-		});
-		OBSERVER.set(proxy, (key, value) => {
-			if (value === void 0 && required) throw new Error(`${this}.${key} is required in this context.`);
-			watch.add(key);
-			if (value instanceof Object && Observable in value) return value[Observable](callback, required) || value;
-			return value;
-		});
-		return proxy;
-	}
-	get(arg1, arg2) {
-		const self = this.is;
-		if (arg1 === void 0) return values(self);
-		if (typeof arg1 == "function") return effect(self, arg1);
-		if (typeof arg2 == "function") return addListener(self, arg2, arg1);
-		if (arg1 === null) return Object.isFrozen(STATE.get(self));
-		return access(self, arg1, arg2);
-	}
-	set(arg1, arg2, arg3) {
-		const self = this.is;
-		if (typeof arg1 == "function") return addListener(self, (key) => {
-			if (arg2 === key || arg2 === void 0 && typeof key == "string") return arg1.call(self, key, self);
-		});
-		if (arg1 && typeof arg1 == "object") assign(self, arg1, arg2 === true);
-		else if (!arg2) event(self, arg1);
-		else if (arg3) manage(self, arg1, arg2);
-		else update(self, arg1, arg2);
-		const pending = PENDING_KEYS.get(this);
-		if (pending) return { then: (resolve) => new Promise((res) => {
-			const remove = addListener(this, (key) => {
-				if (key !== true) {
-					remove();
-					return () => res(Array.from(pending));
-				}
-			});
-		}).then(resolve) };
-	}
-	/**
-	* Iterate over managed properties in this instance of State.
-	* Yeilds the key and current value for each property.
-	*/
-	[Symbol.iterator]() {
-		return Object.entries(STATE.get(this.is))[Symbol.iterator]();
-	}
-	/**
-	* Create and activate a new instance of this state.
-	*
-	* **Important** - Unlike `new this(...)` - this method also activates state.
-	*
-	* @param args - arguments sent to constructor
-	*/
-	static new(...args) {
-		const instance = new this(...args);
-		event(instance);
-		return instance;
-	}
-	/**
-	* Static equivalent of `x instanceof this`.
-	* Determines if provided class is a subtype of this one.
-	* If so, language server will make available all static
-	* methods and properties of this class.
-	*/
-	static is(maybe) {
-		return maybe === this || typeof maybe == "function" && maybe.prototype instanceof this;
-	}
-	/**
-	* Register a callback to run when any instance of this State is updated.
-	*/
-	static on(listener) {
-		let notify = NOTIFY.get(this);
-		if (!notify) NOTIFY.set(this, notify = /* @__PURE__ */ new Set());
-		notify.add(listener);
-		return () => notify.delete(listener);
-	}
-};
-define(State.prototype, "toString", { value() {
-	return ID.get(this.is);
-} });
-define(State, "toString", { value() {
-	return this.name;
-} });
-function assign(subject, data, silent) {
-	const methods = METHODS.get(subject.constructor);
-	for (const key in data) {
-		const bind = methods.get(key);
-		if (bind) bind.call(subject, data[key]);
-		else if (key in subject && key !== "is") {
-			const desc = Object.getOwnPropertyDescriptor(subject, key);
-			const set = desc && desc.set;
-			if (set) set.call(subject, data[key], silent);
-			else subject[key] = data[key];
-		}
-	}
-}
-/** Apply instructions and inherited event listeners. Ensure class metadata is ready. */
-function prepare(state) {
-	let T = state.constructor;
-	if (T === State) throw new Error("Cannot create base State.");
-	const chain = [];
-	let keys = /* @__PURE__ */ new Map();
-	ID.set(state, `${T}-${uid()}`);
-	while (T.name) {
-		for (const cb of NOTIFY.get(T) || []) addListener(state, cb);
-		if (T === State) break;
-		else chain.unshift(T);
-		T = Object.getPrototypeOf(T);
-	}
-	for (const type of chain) {
-		if (METHODS.has(type)) {
-			keys = METHODS.get(type);
-			continue;
-		}
-		METHODS.set(type, keys = new Map(keys));
-		for (const [key, { value }] of Object.entries(Object.getOwnPropertyDescriptors(type.prototype))) {
-			if (!value || key == "constructor") continue;
-			function bind(original) {
-				const { is } = this;
-				if (is.hasOwnProperty(key) && !original) return value;
-				const fn = original || value;
-				const bound = fn.bind(is);
-				METHOD.set(bound, fn);
-				define(is, key, {
-					value: bound,
-					writable: true
-				});
-				return bound;
-			}
-			keys.set(key, bind);
-			define(type.prototype, key, {
-				get: bind,
-				set: bind
-			});
-		}
-	}
-}
-/**
-* Apply state arguemnts, run callbacks and observe properties.
-* Accumulate and handle cleanup events.
-**/
-function init$1(self, ...args) {
-	const state = {};
-	STATE.set(self, state);
-	args = args.flat().filter((arg) => {
-		if (typeof arg == "string") ID.set(self, arg);
-		else return true;
-	});
-	addListener(self, () => {
-		if (!PARENT.has(self)) PARENT.set(self, null);
-		for (const key in self) {
-			const desc = Object.getOwnPropertyDescriptor(self, key);
-			if ("value" in desc) manage(self, key, desc.value, true);
-		}
-		for (const arg of args) {
-			const use = typeof arg == "function" ? arg.call(self, self) : arg;
-			if (use instanceof Promise) use.catch((err) => {
-				console.error(`Async error in constructor for ${self}:`);
-				console.error(err);
-			});
-			else if (Array.isArray(use)) args.push(...use);
-			else if (typeof use == "function") addListener(self, use, null);
-			else if (typeof use == "object") assign(self, use, true);
-		}
-		addListener(self, () => {
-			for (const [_, value] of self) if (value instanceof State && PARENT.get(value) === self) value.set(null);
-			Object.freeze(state);
-		}, null);
-		return null;
-	});
-}
-function manage(target, key, value, silent) {
-	const state = STATE.get(target);
-	function get() {
-		return follow(this, key, state[key]);
-	}
-	function set(value, silent) {
-		update(target, key, value, silent);
-		if (value instanceof State && !PARENT.has(value)) {
-			PARENT.set(value, target);
-			event(value);
-		}
-	}
-	define(target, key, {
-		set,
-		get
-	});
-	set(value, silent);
-}
-function effect(target, fn) {
-	const effect = METHOD.get(fn) || fn;
-	let pending = /* @__PURE__ */ new Set();
-	return watch(target, (proxy) => {
-		const cb = effect.call(proxy, proxy, pending);
-		if (cb === null) return cb;
-		return (update) => {
-			pending = PENDING_KEYS.get(target);
-			if (typeof cb == "function") cb(update);
-		};
-	});
-}
-function values(target) {
-	const values = {};
-	let isNotRecursive;
-	if (!EXPORT) {
-		isNotRecursive = true;
-		EXPORT = new Map([[target, values]]);
-	}
-	for (let [key, value] of target) {
-		if (EXPORT.has(value)) value = EXPORT.get(value);
-		else if (value && typeof value == "object" && "get" in value && typeof value.get === "function") EXPORT.set(value, value = value.get());
-		values[key] = value;
-	}
-	if (isNotRecursive) EXPORT = void 0;
-	return Object.freeze(values);
-}
-const OBSERVER = /* @__PURE__ */ new WeakMap();
-function follow(from, key, value) {
-	const observe = OBSERVER.get(from);
-	return observe ? observe(key, value) : value;
-}
-function access(subject, property, required) {
-	const state = STATE.get(subject);
-	if (property in state || required === false) {
-		const value = state[property];
-		if (value !== void 0 || !required) return value;
-	}
-	if (METHODS.get(subject.constructor).has(property)) return METHOD.get(subject[property]);
-	const error = /* @__PURE__ */ new Error(`${subject}.${property} is not yet available.`);
-	const promise = new Promise((resolve, reject) => {
-		addListener(subject, (key) => {
-			if (key === property) {
-				resolve(state[key]);
-				return null;
-			}
-			if (key === null) reject(/* @__PURE__ */ new Error(`${subject} is destroyed.`));
-		});
-	});
-	throw Object.assign(promise, {
-		toString: () => String(error),
-		name: "Suspense",
-		message: error.message,
-		stack: error.stack
-	});
-}
-function update(subject, key, value, arg) {
-	const state = STATE.get(subject);
-	if (Object.isFrozen(state)) throw new Error(`Tried to update ${subject}.${String(key)} but state is destroyed.`);
-	const previous = state[key];
-	if (typeof arg == "function") {
-		const out = arg.call(subject, value, previous);
-		if (out === false) return false;
-		if (typeof out == "function") value = out();
-	}
-	if (value === previous && key in state) return;
-	state[key] = value;
-	if (arg !== true) event(subject, key);
-	return true;
-}
-/** Random alphanumberic of length 6; always starts with a letter. */
-function uid() {
-	return (.278 + Math.random() * .722).toString(36).substring(2, 8).toUpperCase();
-}
-
-//#endregion
-//#region src/instruction/use.ts
-const INSTRUCTION = /* @__PURE__ */ new Map();
-function use(arg1, arg2) {
-	if (State.is(arg1)) arg1 = childInstruction(arg1, arg2);
-	const token = Symbol("instruction-" + uid());
-	INSTRUCTION.set(token, arg1);
-	return token;
-}
-function childInstruction(type, arg2) {
-	return (key, subject) => {
-		function set(next) {
-			if (next ? !(next instanceof type) : arg2 !== false) throw new Error(`${subject}.${key} expected State of type ${type} but got ${next && next.constructor}.`);
-			update(subject, key, next);
-			if (next && typeof arg2 == "function") arg2(next);
-			return false;
-		}
-		const value = new type();
-		set(value);
-		PARENT.set(value, subject);
-		value.set();
-		return { set };
-	};
-}
-function init() {
-	const state = STATE.get(this);
-	for (const key in this) {
-		const { value } = Object.getOwnPropertyDescriptor(this, key);
-		const instruction = INSTRUCTION.get(value);
-		if (!instruction) continue;
-		INSTRUCTION.delete(value);
-		delete this[key];
-		const output = instruction.call(this, key, this, state);
-		if (!output) continue;
-		const desc = typeof output == "object" ? output : { get: output };
-		if ("value" in desc) state[key] = desc.value;
-		const self = this;
-		Object.defineProperty(self, key, {
-			enumerable: desc.enumerable !== false,
-			get() {
-				return follow(this, key, typeof desc.get == "function" ? desc.get(this) : access(self, key, desc.get));
-			},
-			set(next) {
-				if (desc.set === false) throw new Error(`${self}.${key} is read-only.`);
-				update(self, key, next, desc.set);
-			}
-		});
-	}
-	return null;
-}
-State.on(init);
-
-//#endregion
-//#region src/context.ts
-const LOOKUP = /* @__PURE__ */ new WeakMap();
-const KEYS = /* @__PURE__ */ new Map();
-function key(T, upstream) {
-	let K = KEYS.get(T);
-	if (!K) {
-		K = Symbol(typeof T == "symbol" ? "get " + T.description : String(T));
-		KEYS.set(T, K);
-	}
-	return upstream ? key(K) : K;
-}
-function keys(from, upstream) {
-	const keys = /* @__PURE__ */ new Set();
-	do {
-		keys.add(key(from, upstream));
-		from = Object.getPrototypeOf(from);
-	} while (from !== State);
-	return keys;
-}
-var Context = class Context {
-	static get({ is }, callback) {
-		const context = LOOKUP.get(is);
-		if (context instanceof Context) {
-			if (callback) callback(context);
-			return context;
-		}
-		if (callback) if (context) context.push(callback);
-		else LOOKUP.set(is, [callback]);
-	}
-	constructor(inputs) {
-		this.id = uid();
-		this.inputs = {};
-		this.cleanup = /* @__PURE__ */ new Set();
-		if (inputs) this.use(inputs);
-	}
-	get(Type, arg2) {
-		if (typeof arg2 == "function") {
-			const k = key(Type, true);
-			Object.defineProperty(this, k, {
-				value: arg2,
-				configurable: true
-			});
-			return () => {
-				delete this[k];
-			};
-		}
-		const result = this[key(Type)];
-		if (result === null) throw new Error(`Did find ${Type} in context, but multiple were defined.`);
-		if (result) return result;
-		if (arg2) throw new Error(`Could not find ${Type} in context.`);
-	}
-	/**
-	* Adds a State to this context.
-	*/
-	add(input, implicit) {
-		const cleanup = /* @__PURE__ */ new Set();
-		let T;
-		let I;
-		if (typeof input == "function") {
-			T = input;
-			I = new input();
-		} else {
-			T = input.constructor;
-			I = input;
-		}
-		keys(T, true).forEach((K) => {
-			const expects = this[K];
-			if (expects) addListener(I, (event) => {
-				if (event === true) {
-					const cb = expects(I);
-					if (cb) cleanup.add(cb);
-				}
-				return null;
-			});
-		});
-		keys(T).forEach((K) => {
-			const value = this.hasOwnProperty(K) ? null : I;
-			if (value || this[K] !== I && !implicit) Object.defineProperty(this, K, {
-				configurable: true,
-				value
-			});
-		});
-		this.cleanup.add(() => {
-			cleanup.forEach((cb) => cb());
-			if (I !== input) event(I, null);
-		});
-		const waiting = LOOKUP.get(I);
-		if (waiting instanceof Array) waiting.forEach((cb) => cb(this));
-		LOOKUP.set(I, this);
-		return I;
-	}
-	/**
-	* Register one or more States to this context.
-	*
-	* Context will add or remove States as needed to keep with provided input.
-	*
-	* @param inputs State, State class, or map of States / State classes to register.
-	* @param forEach Optional callback to run for each State registered.
-	*/
-	use(inputs, forEach) {
-		const init = /* @__PURE__ */ new Map();
-		if (typeof inputs == "function" || inputs instanceof State) inputs = { [0]: inputs };
-		for (const [K, V] of Object.entries(inputs)) {
-			if (!(State.is(V) || V instanceof State)) throw new Error(`Context may only include instance or class \`extends State\` but got ${K == "0" || K == String(V) ? V : `${V} (as '${K}')`}.`);
-			const exists = this.inputs[K];
-			if (!exists) init.set(this.add(V), true);
-			else if (exists !== V) {
-				this.pop();
-				this.use(inputs);
-				this.id = uid();
-				return;
-			}
-		}
-		for (const [state, explicit] of init) {
-			state.set();
-			if (explicit && forEach) forEach(state);
-			for (const [_key, value] of state) if (PARENT.get(value) === state) {
-				this.add(value, true);
-				init.set(value, false);
-			}
-		}
-		this.inputs = inputs;
-	}
-	/**
-	* Create a child context, optionally registering one or more States to it.
-	*
-	* @param inputs State, State class, or map of States / State classes to register.
-	*/
-	push(inputs) {
-		const next = Object.create(this);
-		this.cleanup = new Set([() => next.pop(), ...this.cleanup]);
-		next.inputs = {};
-		next.cleanup = /* @__PURE__ */ new Set();
-		if (inputs) next.use(inputs);
-		return next;
-	}
-	/**
-	* Remove all States from this context.
-	*
-	* Will also run any cleanup callbacks registered when States were added.
-	*/
-	pop() {
-		for (const key of Object.getOwnPropertySymbols(this)) delete this[key];
-		this.cleanup.forEach((cb) => cb());
-		this.cleanup.clear();
-		this.inputs = {};
-	}
-};
-Object.defineProperty(Context.prototype, "toString", { value() {
-	return `Context-${this.id}`;
-} });
-
-//#endregion
-//#region src/instruction/get.ts
-function get(Type, arg1, arg2) {
-	const isDownstream = arg1 === true;
-	const isOptional = arg1 === false;
-	return use((key, subject) => {
-		if (isDownstream) {
-			const callback = typeof arg2 === "function" ? arg2 : void 0;
-			const applied = /* @__PURE__ */ new Set();
-			const reset = () => {
-				update(subject, key, Object.freeze(Array.from(applied)));
-			};
-			Context.get(subject, (context) => {
-				context.get(Type, (state) => {
-					let remove;
-					let flush;
-					if (applied.has(state)) return;
-					if (callback) {
-						const exit = scope();
-						try {
-							const done = callback(state, subject);
-							if (done === false) return false;
-							if (typeof done == "function") remove = done;
-						} finally {
-							flush = exit();
-						}
-					}
-					applied.add(state);
-					reset();
-					const done = () => {
-						if (flush) flush();
-						ignore();
-						applied.delete(state);
-						reset();
-						if (typeof remove == "function") remove();
-						remove = void 0;
-					};
-					const ignore = state.set(done, null);
-					return done;
-				});
-			});
-			return {
-				value: [],
-				enumerable: false
-			};
-		}
-		const hasParent = PARENT.get(subject);
-		function assign(value) {
-			if (typeof arg1 === "function") {
-				const result = arg1(value, subject);
-				if (typeof result === "function") subject.set(result, null);
-			}
-			update(subject, key, value);
-		}
-		if (hasParent && hasParent instanceof Type) {
-			assign(hasParent);
-			return {};
-		}
-		Context.get(subject, (context) => {
-			const self = context.get(Type);
-			if (self) assign(self);
-			else if (!isOptional) throw new Error(`Required ${Type} not found in context for ${subject}.`);
-		});
-		return {
-			get: !isOptional,
-			enumerable: false
-		};
-	});
-}
-
-//#endregion
-//#region src/instruction/set.ts
-const STALE = /* @__PURE__ */ new WeakSet();
-function set(value, argument) {
-	return use((key, subject, state) => {
-		if (typeof value == "symbol") throw new Error(`Attempted to use an instruction result (probably use or get) as computed source for ${subject}.${key}. This is not allowed.`);
-		const property = {};
-		if (value instanceof State || value === true) {
-			let from = subject;
-			let getter;
-			if (value instanceof State) {
-				from = value;
-				getter = argument;
-			} else {
-				const fn = METHOD.get(argument) || argument;
-				getter = ((p, k) => fn.call(p, k, p));
-			}
-			const source = (resolve) => resolve(from);
-			let reset;
-			let isAsync;
-			let proxy;
-			function connect(self) {
-				reset = watch(self, (current) => {
-					proxy = current;
-					if (!(key in state) || STALE.delete(compute)) compute(!reset);
-					return (didUpdate) => {
-						if (didUpdate) {
-							STALE.add(compute);
-							event(subject, key, true);
-						}
-					};
-				}, false);
-			}
-			function compute(initial) {
-				let next;
-				try {
-					next = getter.call(proxy, proxy, key);
-				} catch (err) {
-					console.warn(`An exception was thrown while ${initial ? "initializing" : "refreshing"} ${subject}.${key}.`);
-					if (initial) throw err;
-					console.error(err);
-				}
-				update(subject, key, next, !isAsync);
-			}
-			return () => {
-				if (!proxy) {
-					source(connect);
-					isAsync = true;
-				}
-				if (STALE.delete(compute)) compute();
-				return access(subject, key, !proxy);
-			};
-		}
-		if (typeof value == "function" || value instanceof Promise) {
-			function init() {
-				if (typeof value == "function") try {
-					value = attempt(value.bind(subject, key));
-				} catch (err) {
-					console.warn(`Generating initial value for ${subject}.${key} failed.`);
-					throw err;
-				}
-				property.get = argument !== false;
-				const set = (value) => subject[key] = value;
-				if (value instanceof Promise) value.then(set, (error) => {
-					event(subject, key);
-					property.get = () => {
-						throw error;
-					};
-				});
-				else set(value);
-				if (argument) return null;
-				return subject[key];
-			}
-			if (argument) addListener(subject, init, true);
-			else property.get = init;
-		} else if (value !== void 0) property.value = value;
-		if (typeof argument == "function") {
-			let unset;
-			property.set = function(value, previous) {
-				const exit = scope();
-				const returns = argument.call(this, value, previous);
-				const flush = exit();
-				if (returns === false) return false;
-				if (typeof unset == "function") unset(value);
-				unset = (next) => {
-					if (typeof returns == "function") returns(next);
-					flush();
-				};
-			};
-		} else property.set = (value) => {
-			property.get = void 0;
-			update(subject, key, value);
-		};
-		return property;
-	});
-}
-function attempt(fn) {
-	function retry(err) {
-		if (err instanceof Promise) return err.then(compute);
-		else throw err;
-	}
-	function compute() {
-		try {
-			const output = fn();
-			return output instanceof Promise ? output.catch(retry) : output;
-		} catch (err) {
-			return retry(err);
-		}
-	}
-	return compute();
-}
-
-//#endregion
-//#region src/instruction/ref.ts
-const { defineProperty, defineProperties } = Object;
-function ref(arg, arg2) {
-	return use((key, subject, state) => {
-		let value = {};
-		const method = (key, from) => (callback) => callback ? addListener(subject, () => callback(from[key]), key) : from[key];
-		if (arg === subject) addListener(subject, () => {
-			for (const key in subject) if (typeof arg2 == "function") defineProperty(value, key, {
-				configurable: true,
-				get() {
-					const out = arg2(key);
-					defineProperty(value, key, { value: out });
-					return out;
-				}
-			});
-			else {
-				const get = method(key, subject);
-				const set = (x) => subject[key] = x;
-				defineProperties(set, {
-					current: {
-						get,
-						set
-					},
-					get: { value: get },
-					is: { value: subject },
-					key: { value: key }
-				});
-				defineProperty(value, key, { value: set });
-			}
-			return null;
-		}, true);
-		else if (typeof arg == "object") throw new Error("ref instruction does not support object which is not 'this'");
-		else {
-			let unset;
-			const get = method(key, state);
-			const set = (value) => {
-				if (!update(subject, key, value) || !arg) return;
-				if (unset) unset = void unset(value);
-				if (value === null && arg2 !== false) return;
-				const exit = scope();
-				const out = arg.call(subject, value);
-				const flush = exit();
-				unset = (key) => {
-					if (typeof out == "function") out(key);
-					flush();
-				};
-			};
-			state[key] = null;
-			value = defineProperty({
-				get,
-				key,
-				is: subject
-			}, "current", {
-				get,
-				set
-			});
-		}
-		defineProperty(subject, key, { value });
-	});
-}
-
-//#endregion
-exports.Context = Context;
-exports.METHOD = METHOD;
-exports.Observable = Observable;
-exports.State = State;
-exports.addListener = addListener;
-exports.default = State;
-exports.event = event;
-exports.get = get;
-exports.ref = ref;
-exports.set = set;
-exports.use = use;
-exports.watch = watch;
-//# sourceMappingURL=index.js.map
+import { Observer, event, listener, observer, touch, watch } from "./observable.js";
+import { State, unbind } from "./state.js";
+import { Context } from "./context.js";
+import { def } from "./field/def.js";
+import { set } from "./field/set.js";
+import { Component } from "./component.js";
+import { get } from "./field/get.js";
+import { hot } from "./field/hot.js";
+import { ref } from "./field/ref.js";
+
+export { Component, Context, Observer, State, def, State as default, event, get, hot, listener, observer, ref, set, touch, unbind, watch };