@expressive/mvc 0.53.5 → 0.54.0

package/dist/index.mjs

@@ -1,906 +0,0 @@
-// src/control.ts
-var onReady = () => null;
-var LISTENERS = /* @__PURE__ */ new WeakMap();
-var PENDING = /* @__PURE__ */ new WeakMap();
-var PENDING_KEYS = /* @__PURE__ */ new WeakMap();
-var DISPATCH = /* @__PURE__ */ new Set();
-var OBSERVER = /* @__PURE__ */ new WeakMap();
-function addListener(subject, callback, select) {
-  let listeners = LISTENERS.get(subject);
-  if (!listeners)
-    LISTENERS.set(subject, listeners = /* @__PURE__ */ new Map([[onReady, void 0]]));
-  const filter = select === void 0 ? void 0 : /* @__PURE__ */ new Set([select]);
-  if (!listeners.has(onReady) && !filter)
-    callback.call(subject, true, subject);
-  listeners.set(callback, filter);
-  return () => listeners.delete(callback);
-}
-function emit(model, key2) {
-  const listeners = LISTENERS.get(model);
-  const notReady = listeners.has(onReady);
-  if (key2 === true && !notReady)
-    return;
-  let pending2 = PENDING.get(model);
-  if (pending2) {
-    pending2.add(key2);
-    return;
-  }
-  PENDING.set(model, pending2 = new Set(notReady ? [true, key2] : [key2]));
-  for (const key3 of pending2)
-    for (const [callback, filter] of listeners)
-      if (!filter || filter.has(key3)) {
-        const after = callback.call(model, key3, model);
-        if (after)
-          enqueue(after);
-        else if (after === null)
-          listeners.delete(callback);
-      }
-  if (key2 === null)
-    listeners.clear();
-  PENDING.delete(model);
-}
-function event(subject, key2, silent) {
-  if (key2 === null)
-    return emit(subject, key2);
-  if (!key2)
-    return emit(subject, true);
-  let pending2 = PENDING_KEYS.get(subject);
-  if (!pending2) {
-    PENDING_KEYS.set(subject, pending2 = /* @__PURE__ */ new Set());
-    if (!silent)
-      enqueue(() => {
-        emit(subject, false);
-        PENDING_KEYS.delete(subject);
-      });
-  }
-  pending2.add(key2);
-  if (!silent)
-    emit(subject, key2);
-}
-function pending(subject) {
-  if (PENDING_KEYS.has(subject))
-    return {
-      then: (res) => new Promise((res2) => {
-        const remove = addListener(subject, (key2) => {
-          if (key2 !== true) {
-            remove();
-            return res2.bind(null, Array.from(PENDING_KEYS.get(subject)));
-          }
-        });
-      }).then(res)
-    };
-}
-function enqueue(eventHandler) {
-  if (!DISPATCH.size)
-    setTimeout(() => {
-      DISPATCH.forEach((event2) => {
-        try {
-          event2();
-        } catch (err) {
-          console.error(err);
-        }
-      });
-      DISPATCH.clear();
-    }, 0);
-  DISPATCH.add(eventHandler);
-}
-function createProxy(from, observer) {
-  const proxy = Object.create(from);
-  OBSERVER.set(proxy, observer);
-  return proxy;
-}
-function watch(from, key2, value) {
-  const access = OBSERVER.get(from);
-  return access ? access(from, key2, value) : value;
-}
-function createEffect(target, callback, requireValues) {
-  const listeners = LISTENERS.get(target);
-  let unset;
-  let reset;
-  function invoke() {
-    let stale;
-    const subscriber = createProxy(target, access);
-    LISTENERS.set(subscriber, listeners);
-    function onUpdate() {
-      if (stale)
-        return null;
-      stale = true;
-      if (reset && unset) {
-        unset(true);
-        unset = void 0;
-      }
-      return reset;
-    }
-    function access(from, key2, value) {
-      if (value === void 0 && requireValues)
-        throw new Error(`${from}.${key2} is required in this context.`);
-      const listeners2 = LISTENERS.get(from);
-      let listener = listeners2.get(onUpdate);
-      if (!listener)
-        listeners2.set(onUpdate, listener = /* @__PURE__ */ new Set());
-      listener.add(key2);
-      const nested = LISTENERS.get(value);
-      if (nested)
-        LISTENERS.set(
-          value = createProxy(value, access),
-          nested
-        );
-      return value;
-    }
-    try {
-      const out = callback.call(subscriber, subscriber);
-      unset = typeof out == "function" ? out : void 0;
-      reset = out === null ? out : invoke;
-    } catch (err) {
-      if (err instanceof Promise) {
-        reset = void 0;
-        err.then(invoke);
-      } else
-        throw err;
-    }
-  }
-  addListener(target, (key2) => {
-    if (key2 === true)
-      invoke();
-    else if (!reset)
-      return reset;
-    if (key2 === null && unset)
-      unset(null);
-  });
-  return () => {
-    if (unset)
-      unset(false);
-    reset = null;
-  };
-}
-
-// src/model.ts
-var define = Object.defineProperty;
-var ID = /* @__PURE__ */ new WeakMap();
-var STATE = /* @__PURE__ */ new WeakMap();
-var NOTIFY = /* @__PURE__ */ new WeakMap();
-var PARENT = /* @__PURE__ */ new WeakMap();
-var METHODS = /* @__PURE__ */ new WeakMap();
-var METHOD = /* @__PURE__ */ new WeakMap();
-var Model = class {
-  constructor(...args) {
-    prepare(this);
-    define(this, "is", { value: this });
-    init(this, args);
-  }
-  get(arg1, arg2) {
-    const self = this.is;
-    if (typeof arg1 == "function") {
-      let pending2 = /* @__PURE__ */ new Set();
-      return createEffect(self, (proxy) => {
-        const cb = arg1.call(proxy, proxy, pending2);
-        return cb === null ? cb : (update2) => {
-          pending2 = PENDING_KEYS.get(self);
-          if (typeof cb == "function")
-            cb(update2);
-        };
-      });
-    }
-    if (arg1 === void 0)
-      return snapshot(self);
-    if (typeof arg2 == "function")
-      return addListener(self, arg2, arg1);
-    return arg1 === null ? Object.isFrozen(STATE.get(self)) : fetch(self, arg1, arg2);
-  }
-  set(arg1, arg2) {
-    const self = this.is;
-    if (typeof arg1 == "function")
-      return addListener(self, (key2) => {
-        if (typeof key2 == "string")
-          return arg1.call(self, key2, self);
-      });
-    if (arg1 && typeof arg1 == "object") {
-      const methods = METHODS.get(self.constructor);
-      for (const key2 in arg1)
-        if (methods.has(key2))
-          self[key2] = arg1[key2];
-        else if (key2 in self)
-          update(self, key2, arg1[key2], arg2 === true);
-    } else
-      event(self, arg1);
-    return pending(self);
-  }
-  /**
-   * Iterate over managed properties in this instance of Model.
-   * 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 model.
-   * 
-   * **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 Model 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(Model.prototype, "toString", {
-  value() {
-    return ID.get(this.is);
-  }
-});
-define(Model, "toString", {
-  value() {
-    return this.name;
-  }
-});
-function prepare(model) {
-  let T = model.constructor;
-  if (T === Model)
-    throw new Error("Cannot create base Model.");
-  const chain = [];
-  let keys2 = /* @__PURE__ */ new Set();
-  ID.set(model, `${T}-${uid()}`);
-  while (T.name) {
-    for (const cb of NOTIFY.get(T) || [])
-      addListener(model, cb);
-    if (T === Model) break;
-    else chain.unshift(T);
-    T = Object.getPrototypeOf(T);
-  }
-  for (const type of chain) {
-    if (METHODS.has(type)) {
-      keys2 = METHODS.get(type);
-      continue;
-    }
-    METHODS.set(type, keys2 = new Set(keys2));
-    for (const [key2, { value }] of Object.entries(
-      Object.getOwnPropertyDescriptors(type.prototype)
-    )) {
-      let bind2 = function(method = value) {
-        const value2 = method.bind(model);
-        METHOD.set(value2, method);
-        define(model, key2, { value: value2, writable: true });
-        return value2;
-      };
-      var bind = bind2;
-      if (!value || key2 == "constructor")
-        continue;
-      keys2.add(key2);
-      define(type.prototype, key2, { get: bind2, set: bind2 });
-    }
-  }
-}
-function init(model, args) {
-  const methods = METHODS.get(model.constructor);
-  const state = {};
-  STATE.set(model, state);
-  args = args.flat().filter((arg) => {
-    if (typeof arg != "string")
-      return true;
-    ID.set(model, arg);
-  });
-  addListener(model, () => {
-    if (!PARENT.has(model))
-      PARENT.set(model, null);
-    args.forEach((arg) => {
-      const use2 = typeof arg == "function" ? arg.call(model, model) : arg;
-      if (use2 instanceof Promise)
-        use2.catch((err) => {
-          console.error(`Async error in constructor for ${model}:`);
-          console.error(err);
-        });
-      else if (typeof use2 == "function")
-        addListener(model, use2, null);
-      else if (typeof use2 == "object") {
-        for (const key2 in use2)
-          if (key2 in model || methods.has(key2))
-            model[key2] = use2[key2];
-      }
-    });
-    for (const key2 in model) {
-      const desc = Object.getOwnPropertyDescriptor(model, key2);
-      if ("value" in desc) {
-        update(model, key2, desc.value, true);
-        define(model, key2, {
-          configurable: false,
-          get() {
-            return watch(this, key2, state[key2]);
-          },
-          set(value) {
-            update(model, key2, value);
-            mayAdopt(model, value);
-          }
-        });
-      }
-    }
-    addListener(model, () => {
-      for (const [_, value] of model)
-        if (value instanceof Model && PARENT.get(value) === model)
-          value.set(null);
-      Object.freeze(state);
-    }, null);
-    return null;
-  });
-}
-function mayAdopt(parent, child) {
-  if (child instanceof Model && !PARENT.has(child)) {
-    PARENT.set(child, parent);
-    event(child);
-  }
-}
-function fetch(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;
-  }
-  const error = new Error(`${subject}.${property} is not yet available.`);
-  const promise = new Promise((resolve, reject) => {
-    addListener(subject, (key2) => {
-      if (key2 === property) {
-        resolve(state[key2]);
-        return null;
-      }
-      if (key2 === null)
-        reject(new Error(`${subject} is destroyed.`));
-    });
-  });
-  throw Object.assign(promise, {
-    toString: () => String(error),
-    name: "Suspense",
-    message: error.message,
-    stack: error.stack
-  });
-}
-var EXPORT;
-function snapshot(model) {
-  const values = {};
-  let isNotRecursive;
-  if (!EXPORT) {
-    isNotRecursive = true;
-    EXPORT = /* @__PURE__ */ new Map([[model, values]]);
-  }
-  for (let [key2, value] of model) {
-    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[key2] = value;
-  }
-  if (isNotRecursive)
-    EXPORT = void 0;
-  return Object.freeze(values);
-}
-function update(subject, key2, value, arg) {
-  const state = STATE.get(subject);
-  if (Object.isFrozen(state))
-    throw new Error(`Tried to update ${String(key2)} but ${subject} is destroyed.`);
-  const previous = state[key2];
-  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)
-    return;
-  state[key2] = value;
-  if (arg !== true)
-    event(subject, key2);
-  return true;
-}
-function uid() {
-  return (0.278 + Math.random() * 0.722).toString(36).substring(2, 8).toUpperCase();
-}
-
-// src/context.ts
-var LOOKUP = /* @__PURE__ */ new WeakMap();
-var KEYS = /* @__PURE__ */ new Map();
-function key(T, upstream) {
-  let K = KEYS.get(T);
-  if (!K)
-    KEYS.set(T, K = Symbol(
-      typeof T == "symbol" ? "get " + T.description : String(T)
-    ));
-  return upstream ? key(K) : K;
-}
-function keys(from, upstream) {
-  const keys2 = /* @__PURE__ */ new Set();
-  do {
-    keys2.add(key(from, upstream));
-  } while ((from = Object.getPrototypeOf(from)) !== Model);
-  return keys2;
-}
-var Context = class _Context {
-  constructor(inputs) {
-    this.layer = /* @__PURE__ */ new Map();
-    this.cleanup = /* @__PURE__ */ new Set();
-    if (inputs)
-      this.include(inputs);
-  }
-  static get(from, callback) {
-    const waiting = LOOKUP.get(from);
-    if (waiting instanceof _Context) {
-      if (callback)
-        callback(waiting);
-      return waiting;
-    }
-    if (callback)
-      if (waiting)
-        waiting.push(callback);
-      else
-        LOOKUP.set(from, [callback]);
-  }
-  /** Run callback when a specified type is registered to a **child** context. */
-  has(Type, callback) {
-    define(this, key(Type, true), { value: callback });
-  }
-  /** Find specified type registered to a parent context. Returns undefined if none are found. */
-  get(Type) {
-    const result = this[key(Type)];
-    if (result === null)
-      throw new Error(`Did find ${Type} in context, but multiple were defined.`);
-    return result;
-  }
-  push(inputs) {
-    const next = Object.create(this);
-    next.layer = /* @__PURE__ */ new Map();
-    next.cleanup = /* @__PURE__ */ new Set();
-    if (inputs)
-      next.include(inputs);
-    return next;
-  }
-  pop() {
-    for (const key2 of Object.getOwnPropertySymbols(this))
-      delete this[key2];
-    this.cleanup.forEach((cb) => cb());
-    this.layer.clear();
-  }
-  include(inputs, forEach) {
-    const init2 = /* @__PURE__ */ new Map();
-    if (typeof inputs == "function" || inputs instanceof Model)
-      inputs = { 0: inputs };
-    Object.entries(inputs).forEach(([K, V]) => {
-      if (Model.is(V) || V instanceof Model)
-        return;
-      if (K && K != V)
-        V = `${V} (as '${K}')`;
-      throw new Error(
-        `Context may only include instance or class \`extends Model\` but got ${V}.`
-      );
-    });
-    for (const key2 in inputs) {
-      const input = inputs[key2];
-      const exists = this.layer.get(key2);
-      if (!exists) {
-        const instance = this.add(input);
-        this.layer.set(key2, input);
-        init2.set(instance, true);
-      } else if (exists !== input) {
-        this.pop();
-        this.id = uid();
-        this.include(inputs);
-      }
-    }
-    for (const [model, explicit] of init2) {
-      model.set();
-      if (typeof forEach == "function")
-        forEach(model, explicit);
-      else if (forEach && explicit)
-        model.set(forEach);
-      for (const [_key, value] of model)
-        if (PARENT.get(value) === model) {
-          this.add(value, true);
-          init2.set(value, false);
-        }
-    }
-  }
-  add(input, implicit) {
-    let T;
-    let I;
-    if (typeof input == "function") {
-      Model.is(input);
-      T = input;
-      I = new input();
-      this.cleanup.add(() => I.set(null));
-    } else {
-      T = input.constructor;
-      I = input;
-    }
-    keys(T, true).forEach((K) => {
-      const result = this[K];
-      if (!result)
-        return;
-      const callback = result(I);
-      if (callback)
-        this.cleanup.add(callback);
-    });
-    keys(T).forEach((K) => {
-      const value = this.hasOwnProperty(K) ? null : I;
-      if (value || this[K] !== I && !implicit)
-        define(this, K, {
-          configurable: true,
-          value
-        });
-    });
-    const waiting = LOOKUP.get(I);
-    if (waiting instanceof Array)
-      waiting.forEach((cb) => cb(this));
-    LOOKUP.set(I, this);
-    return I;
-  }
-};
-
-// src/instruction/use.ts
-var INSTRUCT = /* @__PURE__ */ new Map();
-function use(arg1, arg2) {
-  const token = Symbol("instruction");
-  if (Model.is(arg1)) {
-    const type = arg1;
-    arg1 = (key2, subject) => {
-      const value = new type();
-      const desc = { set: set2 };
-      set2(value);
-      PARENT.set(value, subject);
-      function set2(next) {
-        if (next ? !(next instanceof type) : arg2 !== false)
-          throw new Error(`${subject}.${key2} expected Model of type ${type} but got ${next && next.constructor}.`);
-        update(subject, key2, next);
-        if (next && typeof arg2 == "function")
-          arg2(next);
-        return false;
-      }
-      return desc;
-    };
-  }
-  INSTRUCT.set(token, arg1);
-  return token;
-}
-Model.on((_, model) => {
-  const state = STATE.get(model);
-  for (const key2 in model) {
-    const { value } = Object.getOwnPropertyDescriptor(model, key2);
-    const instruction = INSTRUCT.get(value);
-    if (!instruction) {
-      mayAdopt(model, value);
-      continue;
-    }
-    INSTRUCT.delete(value);
-    delete model[key2];
-    const output = instruction.call(model, key2, model, state);
-    if (!output)
-      continue;
-    const desc = typeof output == "object" ? output : { get: output };
-    if ("value" in desc)
-      state[key2] = desc.value;
-    define(model, key2, {
-      enumerable: desc.enumerable !== false,
-      get() {
-        return watch(
-          this,
-          key2,
-          typeof desc.get == "function" ? desc.get(this) : fetch(model, key2, desc.get)
-        );
-      },
-      set(next) {
-        if (desc.set === false)
-          throw new Error(`${model}.${key2} is read-only.`);
-        update(model, key2, next, desc.set);
-      }
-    });
-  }
-  return null;
-});
-
-// src/instruction/get.ts
-var STALE = /* @__PURE__ */ new WeakSet();
-function get(arg0, arg1) {
-  return use((key2, subject, state) => {
-    if (typeof arg0 == "symbol")
-      throw new Error(`Attempted to use an instruction result (probably use or get) as computed source for ${subject}.${key2}. This is not allowed.`);
-    if (Model.is(arg0)) {
-      let assign2 = function(value) {
-        if (typeof arg1 == "function")
-          value.get((x) => arg1(x, key2));
-        update(subject, key2, value);
-      };
-      var assign = assign2;
-      const hasParent = PARENT.get(subject);
-      if (!hasParent) {
-        if (arg1 === true)
-          throw new Error(`${subject} may only exist as a child of type ${arg0}.`);
-        Context.get(subject, (context) => {
-          const model = context.get(arg0);
-          if (model)
-            assign2(model);
-          else if (arg1 !== false)
-            throw new Error(`Required ${arg0} not found in context for ${subject}.`);
-        });
-      } else if (!arg0 || hasParent instanceof arg0)
-        assign2(hasParent);
-      else
-        throw new Error(`New ${subject} created as child of ${hasParent}, but must be instanceof ${arg0}.`);
-      return {
-        get: arg1 !== false
-      };
-    }
-    let from = subject;
-    if (arg0 instanceof Model) {
-      from = arg0;
-    } else {
-      const fn = METHOD.get(arg0) || arg0;
-      arg1 = (p, k) => fn.call(p, k, p);
-    }
-    const source = (resolve) => resolve(from);
-    const getter = arg1;
-    let reset;
-    let isAsync;
-    let proxy;
-    function connect(model) {
-      reset = createEffect(model, (current) => {
-        proxy = current;
-        if (!(key2 in state) || STALE.delete(compute))
-          compute(!reset);
-        return (didUpdate) => {
-          if (didUpdate) {
-            STALE.add(compute);
-            event(subject, key2, true);
-          }
-        };
-      });
-    }
-    function compute(initial) {
-      let next;
-      try {
-        next = getter.call(proxy, proxy, key2);
-      } catch (err) {
-        console.warn(`An exception was thrown while ${initial ? "initializing" : "refreshing"} ${subject}.${key2}.`);
-        if (initial)
-          throw err;
-        console.error(err);
-      }
-      update(subject, key2, next, !isAsync);
-    }
-    return () => {
-      if (!proxy) {
-        source(connect);
-        isAsync = true;
-      }
-      if (STALE.delete(compute))
-        compute();
-      return fetch(subject, key2, !proxy);
-    };
-  });
-}
-
-// src/instruction/ref.ts
-function ref(arg, arg2) {
-  return use((key2, subject, state) => {
-    let value = {};
-    if (arg === subject)
-      subject.get(() => {
-        for (const key3 in state)
-          if (typeof arg2 == "function")
-            define(value, key3, {
-              configurable: true,
-              get() {
-                const out = arg2(key3);
-                define(value, key3, { value: out });
-                return out;
-              }
-            });
-          else {
-            const get2 = () => state[key3];
-            const set2 = (value2) => {
-              update(subject, key3, value2);
-            };
-            define(set2, "current", { get: get2, set: set2 });
-            define(set2, "get", { value: get2 });
-            define(value, key3, { value: set2 });
-          }
-      });
-    else if (typeof arg == "object")
-      throw new Error("ref instruction does not support object which is not 'this'");
-    else {
-      let unSet;
-      const get2 = () => state[key2];
-      const set2 = (value2) => {
-        if (!update(subject, key2, value2) || !arg)
-          return;
-        if (unSet)
-          unSet = void unSet(value2);
-        if (value2 !== null || arg2 === false) {
-          const out = arg.call(subject, value2);
-          if (typeof out == "function")
-            unSet = out;
-        }
-      };
-      state[key2] = null;
-      value = Object.defineProperties(set2, {
-        current: { get: get2, set: set2 },
-        get: { value: get2 }
-      });
-    }
-    define(subject, key2, { value });
-  });
-}
-
-// src/instruction/set.ts
-function set(value, argument) {
-  return use((key2, subject) => {
-    const property = {};
-    if (typeof value == "function" || value instanceof Promise) {
-      let init3 = function() {
-        if (typeof value == "function")
-          try {
-            value = attempt(value.bind(subject, key2));
-          } catch (err) {
-            console.warn(`Generating initial value for ${subject}.${key2} failed.`);
-            throw err;
-          }
-        property.get = argument === true;
-        if (value instanceof Promise) {
-          value.then((value2) => {
-            update(subject, key2, value2);
-            return value2;
-          }).catch((err) => {
-            event(subject, key2);
-            property.get = () => {
-              throw err;
-            };
-          });
-        } else
-          update(subject, key2, value);
-        if (0 in arguments)
-          return subject[key2];
-      };
-      var init2 = init3;
-      if (argument)
-        init3();
-      else
-        property.get = init3;
-    } else if (value !== void 0)
-      property.value = value;
-    if (typeof argument == "function") {
-      let unSet;
-      property.set = function(value2, previous) {
-        const out = argument.call(this, value2, previous);
-        if (out === false)
-          return out;
-        if (typeof unSet == "function")
-          unSet = void unSet(value2);
-        if (typeof out == "function")
-          unSet = out;
-      };
-    } else
-      property.set = (value2) => {
-        property.get = void 0;
-        update(subject, key2, value2);
-      };
-    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();
-}
-
-// src/instruction/has.ts
-var APPLY = /* @__PURE__ */ new WeakMap();
-function has(arg1, arg2) {
-  return use((key2, subject) => {
-    const applied = /* @__PURE__ */ new Set();
-    const apply = () => {
-      update(subject, key2, Object.freeze(Array.from(applied)));
-    };
-    if (Model.is(arg1))
-      Context.get(subject, (context) => {
-        context.has(arg1, (model) => {
-          let remove;
-          let disconnect;
-          if (applied.has(model))
-            return;
-          const callback = APPLY.get(model);
-          if (callback) {
-            const after = callback(subject);
-            if (after === false)
-              return;
-            if (typeof after == "function")
-              disconnect = after;
-          }
-          if (typeof arg2 == "function") {
-            const done2 = arg2(model, subject);
-            if (done2 === false)
-              return false;
-            remove = () => {
-              if (typeof done2 == "function")
-                done2();
-            };
-          }
-          applied.add(model);
-          apply();
-          const done = () => {
-            ignore();
-            applied.delete(model);
-            apply();
-            if (disconnect)
-              disconnect();
-            if (typeof remove == "function")
-              remove();
-          };
-          const ignore = model.get(null, done);
-          return done;
-        });
-      });
-    else {
-      if (APPLY.has(subject))
-        throw new Error(`'has' callback can only be used once per model.`);
-      APPLY.set(subject, (recipient) => {
-        let remove;
-        if (arg1) {
-          remove = arg1(recipient, subject);
-          if (remove === false)
-            return false;
-        }
-        applied.add(recipient);
-        apply();
-        return () => {
-          applied.delete(recipient);
-          apply();
-          if (typeof remove == "function")
-            remove();
-        };
-      });
-    }
-    return { value: [] };
-  });
-}
-export {
-  Context,
-  Model,
-  addListener,
-  createEffect,
-  createProxy,
-  Model as default,
-  get,
-  has,
-  ref,
-  set,
-  use
-};