@expressive/mvc 0.33.0 → 0.35.0-alpha.0

package/lib/index.esm.js

@@ -1,1052 +0,0 @@
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-
-class Issue extends Error {
-    constructor() {
-        super(...arguments);
-        // drop first line (error factory) in stack trace.
-        this.stack = this.stack.replace(/\n.+/, "");
-    }
-    warn() {
-        console.warn(this.message);
-    }
-}
-function issues(register) {
-    const Library = {};
-    for (const name in register)
-        Library[name] = (...args) => new Issue(register[name].apply(null, args));
-    return Library;
-}
-
-const { assign, create, defineProperties, defineProperty, entries, keys, getPrototypeOf, getOwnPropertyDescriptor, getOwnPropertySymbols, values } = Object;
-
-const Oops$8 = issues({
-    NotFound: (name) => `Could not find ${name} in context.`
-});
-function get$1(argument) {
-    return Control.get((dispatch, context) => {
-        const refresh = () => dispatch(x => x + 1);
-        let onUpdate;
-        let value;
-        if (typeof argument !== "function") {
-            const got = context.get(this);
-            if (got)
-                value = argument === undefined
-                    ? Control.watch(got, k => k ? onUpdate : undefined)
-                    : got;
-            else if (argument !== false)
-                throw Oops$8.NotFound(this);
-            return {
-                mount() {
-                    onUpdate = refresh;
-                    return () => onUpdate = null;
-                },
-                render: () => value
-            };
-        }
-        let compute = argument;
-        let suspense;
-        let getValue;
-        let factory;
-        let proxy;
-        const found = context.get(this);
-        if (!found)
-            throw Oops$8.NotFound(this);
-        function forceUpdate(action) {
-            if (typeof action == "function")
-                action = action();
-            if (getValue)
-                didUpdate(getValue());
-            else
-                refresh();
-            if (action)
-                return action.finally(refresh);
-        }
-        function didUpdate(got) {
-            value = got;
-            if (suspense) {
-                suspense();
-                suspense = undefined;
-            }
-            else
-                refresh();
-        }
-        proxy = Control.watch(found, () => factory ? null : onUpdate);
-        getValue = () => compute.call(proxy, proxy, forceUpdate);
-        value = getValue();
-        if (value === null) {
-            getValue = undefined;
-            onUpdate = null;
-            return;
-        }
-        if (typeof value == "function") {
-            const get = value;
-            Control.watch(proxy, () => onUpdate);
-            factory = true;
-            compute = () => get();
-            value = get();
-        }
-        if (value instanceof Promise) {
-            onUpdate = null;
-            value.then(didUpdate);
-            value = undefined;
-        }
-        else
-            onUpdate = () => {
-                const next = getValue();
-                if (value !== next)
-                    didUpdate(next);
-            };
-        return {
-            mount: () => () => {
-                onUpdate = null;
-            },
-            render: () => {
-                if (value !== undefined)
-                    return value;
-                if (onUpdate)
-                    return null;
-                throw new Promise(res => {
-                    suspense = res;
-                });
-            }
-        };
-    });
-}
-
-function use$1(apply, repeat) {
-    const render = Control.use(dispatch => {
-        const instance = this.new();
-        const local = Control.watch(instance, () => onUpdate);
-        const refresh = () => dispatch(x => x + 1);
-        let onUpdate;
-        let shouldApply = !!apply;
-        return {
-            instance,
-            mount() {
-                onUpdate = refresh;
-                return () => {
-                    onUpdate = null;
-                    instance.null();
-                };
-            },
-            render(props) {
-                if (shouldApply) {
-                    onUpdate = undefined;
-                    if (typeof props == "function")
-                        props(instance);
-                    else if (props)
-                        for (const key in instance)
-                            if (props.hasOwnProperty(key))
-                                instance[key] = props[key];
-                    if (!repeat)
-                        shouldApply = false;
-                    instance.set(0).then(() => onUpdate = refresh);
-                }
-                return local;
-            }
-        };
-    });
-    return render(apply);
-}
-
-const Oops$7 = issues({
-    NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`,
-    Destoryed: () => "Model is destroyed."
-});
-function suspense(source, key) {
-    const error = Oops$7.NotReady(source.subject, key);
-    const watch = source.observers.get(key);
-    const promise = new Promise((resolve, reject) => {
-        function onUpdate(key) {
-            if (key)
-                return () => {
-                    if (source.state[key] !== undefined) {
-                        watch.delete(onUpdate);
-                        resolve();
-                    }
-                };
-            if (key === null)
-                reject(Oops$7.Destoryed());
-        }
-        watch.add(onUpdate);
-    });
-    return assign(promise, {
-        toString: () => String(error),
-        name: "Suspense",
-        message: error.message,
-        stack: error.stack
-    });
-}
-function mayRetry(fn) {
-    const retry = (err) => {
-        if (err instanceof Promise)
-            return err.then(compute);
-        else
-            throw err;
-    };
-    const compute = () => {
-        try {
-            const output = fn();
-            return output instanceof Promise
-                ? output.catch(retry)
-                : output;
-        }
-        catch (err) {
-            return retry(err);
-        }
-    };
-    return compute();
-}
-
-const Oops$6 = issues({
-    BadCallback: () => `Callback for effect-callback may only return a function.`
-});
-function createEffect(source, callback) {
-    return control(source, self => {
-        let { subject } = self;
-        let unSet;
-        let busy = false;
-        function invoke() {
-            if (busy)
-                return;
-            const output = mayRetry(() => {
-                if (typeof unSet == "function")
-                    unSet();
-                unSet = callback.call(subject, subject);
-                if (unSet instanceof Promise)
-                    unSet = undefined;
-                if (unSet && typeof unSet !== "function")
-                    throw Oops$6.BadCallback();
-            });
-            if (output instanceof Promise) {
-                output.finally(() => busy = false);
-                busy = true;
-            }
-        }
-        let refresh;
-        subject = watch(subject, () => refresh);
-        self.followers.add(key => (key === null || refresh === null ? refresh : undefined));
-        invoke();
-        refresh = invoke;
-        return () => refresh = null;
-    });
-}
-function createValueEffect(callback, ignoreNull) {
-    let unSet;
-    return function (value) {
-        if (typeof unSet == "function")
-            unSet = void unSet(value);
-        if (value === null && ignoreNull)
-            return;
-        const out = callback.call(this, value);
-        if (typeof out == "boolean")
-            return out;
-        if (!out || out instanceof Promise)
-            return;
-        if (typeof out == "function")
-            unSet = out;
-        else
-            throw Oops$6.BadCallback();
-    };
-}
-
-function getMethod(argument, callback, once) {
-    if (typeof argument == "function")
-        return createEffect(this, argument);
-    const self = control(this, true);
-    function get(key) {
-        const value = self.state[key];
-        return value instanceof Model ? value.get() : value;
-    }
-    const extract = typeof argument == "string"
-        ? () => get(argument)
-        : () => {
-            const output = {};
-            for (const key of argument || keys(self.state))
-                output[key] = get(key);
-            return output;
-        };
-    if (typeof callback != "function")
-        return extract();
-    const select = typeof argument == "string" ? [argument] : argument;
-    const invoke = () => callback(extract(), self.latest || []);
-    if (select)
-        for (const key of select)
-            try {
-                const value = self.subject[key];
-                if (!(key in self.state))
-                    self.watch(key, { value });
-            }
-            catch (e) {
-                // TODO: should this be caught?
-            }
-    if (once === undefined)
-        invoke();
-    const remove = self.addListener(key => {
-        if (!select || select.includes(key)) {
-            if (once)
-                remove();
-            return invoke;
-        }
-    });
-    return remove;
-}
-function setMethod(arg1, arg2) {
-    const self = control(this, true);
-    const { state } = self;
-    let timeout = 0;
-    switch (typeof arg1) {
-        case "string":
-            if (1 in arguments)
-                if (arg1 in state)
-                    state[arg1] = arg2;
-                else
-                    self.watch(arg1, { value: arg2 });
-            self.update(arg1);
-            break;
-        case "object":
-            for (const key in state)
-                if (key in arg1 && (!arg2 || arg2.includes(key))) {
-                    state[key] = arg1[key];
-                    self.update(key);
-                }
-            break;
-        default:
-            timeout = arg1;
-    }
-    return new Promise((resolve) => {
-        if (!self.frame.size && timeout === 0)
-            resolve(false);
-        const remove = self.addListener(() => {
-            remove();
-            return () => resolve(self.latest);
-        });
-        if (timeout > 0)
-            setTimeout(() => {
-                remove();
-                resolve(false);
-            }, timeout);
-    });
-}
-
-class Model {
-    constructor(id) {
-        new Control(this, id === undefined ? uid() : id);
-    }
-    /** Mark this instance for garbage collection. */
-    null() {
-        control(this, true).clear();
-    }
-    /**
-     * Creates a new instance of this controller.
-     *
-     * Beyond `new this(...)`, method will activate managed-state.
-     *
-     * @param args - arguments sent to constructor
-     */
-    static new(...args) {
-        const instance = new this(...args);
-        control(instance, true);
-        return instance;
-    }
-    /**
-     * Static equivalent of `x instanceof this`.
-     *
-     * Will determine if provided class is a subtype of this one.
-     */
-    static is(maybe) {
-        return (typeof maybe == "function" &&
-            maybe.prototype instanceof this);
-    }
-}
-Model.get = get$1;
-Model.use = use$1;
-defineProperty(Model, "toString", {
-    value() {
-        return this.name;
-    }
-});
-defineProperties(Model.prototype, {
-    get: { value: getMethod },
-    set: { value: setMethod },
-    toString: {
-        configurable: true,
-        value() {
-            return `${this.constructor.name}-${control(this).id}`;
-        }
-    }
-});
-/* TODO: Remove below on 1.0.0 release. */
-defineProperty(Model, "isTypeof", {
-    get() {
-        throw new Error("Model.isTypeof method was renamed. Use Model.is instead.");
-    }
-});
-defineProperties(Model.prototype, {
-    is: {
-        configurable: true,
-        get() {
-            throw new Error("Model.is property is now is only available from a hook.");
-        }
-    },
-    on: {
-        configurable: true,
-        writable: true,
-        value() {
-            throw new Error("Model.on() is deprecated. Use Model.get or Model.set instead.");
-        }
-    }
-});
-/** Random alphanumberic of length 6. Will always start with a letter. */
-function uid() {
-    return (Math.random() * 0.722 + 0.278).toString(36).substring(2, 8).toUpperCase();
-}
-
-const Oops$5 = issues({
-    BadAssignment: (parent, expected, got) => `${parent} expected Model of type ${expected} but got ${got}.`,
-});
-const REGISTER = new WeakMap();
-const OBSERVER = new WeakMap();
-const INSTRUCT = new Map();
-const PENDING$1 = new WeakMap();
-const PARENTS = new WeakMap();
-class Control {
-    constructor(subject, id) {
-        this.state = {};
-        this.frame = new Set();
-        this.followers = new Set();
-        this.observers = new Map([["", this.followers]]);
-        this.id = id;
-        this.subject = subject;
-        REGISTER.set(subject, this);
-        if (id !== false)
-            PENDING$1.set(this, new Set(Control.ready));
-    }
-    add(key) {
-        const { value } = getOwnPropertyDescriptor(this.subject, key);
-        const instruction = INSTRUCT.get(value);
-        if (typeof instruction == "function") {
-            INSTRUCT.delete(value);
-            instruction(this, key);
-        }
-        else if (value instanceof Model)
-            setRecursive(this, key, value);
-        else
-            this.watch(key, { value });
-    }
-    watch(key, output) {
-        const { state } = this;
-        const { set, enumerable = true } = output;
-        const subs = new Set();
-        this.observers.set(key, subs);
-        if ("value" in output)
-            state[key] = output.value;
-        defineProperty(this.subject, key, {
-            enumerable,
-            set: set === false
-                ? undefined
-                : this.ref(key, set),
-            get() {
-                const event = OBSERVER.get(this);
-                if (event)
-                    subs.add(event);
-                const value = output.get
-                    ? output.get(this) : state[key];
-                return event && REGISTER.has(value)
-                    ? watch(value, event)
-                    : value;
-            }
-        });
-    }
-    ref(key, callback) {
-        const { state, subject } = this;
-        return (value) => {
-            if (value !== state[key])
-                switch (callback && callback.call(subject, value)) {
-                    case undefined:
-                        state[key] = value;
-                    case true:
-                        this.update(key);
-                }
-        };
-    }
-    update(key) {
-        const { frame } = this;
-        if (frame.has(key))
-            return;
-        if (!frame.size) {
-            this.latest = undefined;
-            requestUpdateFrame(() => {
-                this.latest = Array.from(frame);
-                this.followers.forEach(cb => {
-                    const notify = cb(undefined, this);
-                    if (notify)
-                        requestUpdateFrame(notify);
-                });
-                frame.clear();
-            });
-        }
-        frame.add(key);
-        for (const k of ["", key]) {
-            const subs = this.observers.get(k);
-            subs && subs.forEach(cb => {
-                const notify = cb(key, this);
-                if (notify === null)
-                    subs.delete(cb);
-                else if (notify)
-                    requestUpdateFrame(notify);
-            });
-        }
-    }
-    addListener(fn) {
-        this.followers.add(fn);
-        return () => this.followers.delete(fn);
-    }
-    clear() {
-        this.observers.forEach(subs => {
-            subs.forEach(fn => {
-                const cb = fn(null, this);
-                cb && cb();
-            });
-        });
-        this.observers.clear();
-    }
-}
-Control.ready = new Set();
-Control.after = new Set();
-Control.before = new Set();
-Control.pending = new Set();
-Control.for = control;
-Control.apply = apply;
-Control.watch = watch;
-function control(subject, ready) {
-    const control = REGISTER.get(subject);
-    const pending = PENDING$1.get(control);
-    if (typeof ready == "function") {
-        if (!pending)
-            return ready(control);
-        let done;
-        pending.add(() => done = ready(control));
-        return () => done && done();
-    }
-    if (pending && ready) {
-        for (const key in control.subject)
-            control.add(key);
-        PENDING$1.delete(control);
-        pending.forEach(cb => cb(control));
-    }
-    return control;
-}
-function requestUpdateFrame(event) {
-    const { after, before, pending } = Control;
-    if (!pending.size)
-        setTimeout(() => {
-            before.forEach(x => x());
-            pending.forEach(notify => {
-                try {
-                    notify();
-                }
-                catch (err) {
-                    console.error(err);
-                }
-            });
-            pending.clear();
-            after.forEach(x => x());
-        }, 0);
-    pending.add(event);
-}
-function setRecursive(on, key, value) {
-    const set = (next) => {
-        if (next instanceof value.constructor) {
-            on.state[key] = next;
-            parent(next, on.subject);
-            control(next, true);
-            return true;
-        }
-        throw Oops$5.BadAssignment(`${on.subject}.${key}`, value.constructor, next);
-    };
-    on.watch(key, { set });
-    set(value);
-}
-function parent(child, assign) {
-    if (!assign)
-        return PARENTS.get(child);
-    PARENTS.set(child, assign);
-}
-function watch(value, cb) {
-    if (!OBSERVER.has(value)) {
-        const control = REGISTER.get(value);
-        value = defineProperty(create(value), "is", { value });
-        REGISTER.set(value, control);
-    }
-    OBSERVER.set(value, cb);
-    return value;
-}
-function apply(instruction) {
-    const placeholder = Symbol("instruction");
-    INSTRUCT.set(placeholder, (onto, key) => {
-        delete onto.subject[key];
-        const output = instruction.call(onto, key, onto);
-        if (output)
-            onto.watch(key, typeof output == "function" ? { get: output } : output);
-    });
-    return placeholder;
-}
-
-const Oops$4 = issues({
-    DuplicatePending: (key) => `Invoked action ${key} but one is already active.`
-});
-function run(task) {
-    return apply((key, control) => {
-        let pending = false;
-        const invoke = (...args) => __awaiter(this, void 0, void 0, function* () {
-            if (pending)
-                return Promise.reject(Oops$4.DuplicatePending(key));
-            pending = true;
-            control.update(key);
-            try {
-                return yield mayRetry(() => (task.apply(control.subject, args)));
-            }
-            finally {
-                pending = false;
-                control.update(key);
-            }
-        });
-        control.state[key] = undefined;
-        defineProperty(invoke, "active", {
-            get: () => pending
-        });
-        return {
-            value: invoke,
-            set: false
-        };
-    });
-}
-
-const Oops$3 = issues({
-    PeerNotAllowed: (model, property) => `Attempted to use an instruction result (probably use or get) as computed source for ${model}.${property}. This is not allowed.`,
-    Failed: (parent, property, initial) => `An exception was thrown while ${initial ? "initializing" : "refreshing"} ${parent}.${property}.`,
-    Required: (expects, child) => `New ${child} created standalone but requires parent of type ${expects}.`,
-    Unexpected: (expects, child, got) => `New ${child} created as child of ${got}, but must be instanceof ${expects}.`,
-    AmbientRequired: (requested, requester) => `Attempted to find an instance of ${requested} in context. It is required by ${requester}, but one could not be found.`
-});
-function get(arg0, arg1) {
-    return apply((key, control) => {
-        let { subject } = control;
-        if (typeof arg0 == "symbol")
-            throw Oops$3.PeerNotAllowed(subject, key);
-        let source = cb => cb(subject);
-        if (arg0 instanceof Model)
-            subject = arg0;
-        else if (Model.is(arg0)) {
-            const hasParent = parent(subject);
-            if (!hasParent) {
-                if (arg1 === true)
-                    throw Oops$3.Required(arg0, subject);
-                const fetch = Control.has(subject);
-                source = got => {
-                    fetch(context => {
-                        const model = context.get(arg0);
-                        if (model)
-                            got(model);
-                        else if (arg1 !== false)
-                            throw Oops$3.AmbientRequired(arg0, subject);
-                    });
-                };
-            }
-            else if (!arg0 || hasParent instanceof arg0)
-                subject = hasParent;
-            else
-                throw Oops$3.Unexpected(arg0, subject, hasParent);
-        }
-        else if (typeof arg0 == "function")
-            arg1 = arg0.call(subject, key, subject);
-        return typeof arg1 == "function"
-            ? computed(control, key, source, arg1)
-            : recursive(control, key, source, arg1);
-    });
-}
-function recursive(parent, key, source, required) {
-    let waiting;
-    if (source)
-        source((got) => {
-            parent.state[key] = got;
-            if (waiting)
-                parent.update(key);
-        });
-    waiting = true;
-    return () => {
-        const value = parent.state[key];
-        if (value)
-            return value;
-        if (required !== false)
-            throw suspense(parent, key);
-    };
-}
-const ORDER = new WeakMap();
-const PENDING = new Set();
-let OFFSET = 0;
-function computed(parent, key, source, setter) {
-    const { state } = parent;
-    let proxy;
-    let active;
-    let isAsync;
-    let reset;
-    function compute(initial) {
-        if (parent.frame.has(key))
-            return;
-        let next;
-        try {
-            next = setter.call(proxy, proxy);
-        }
-        catch (err) {
-            Oops$3.Failed(parent.subject, key, initial).warn();
-            if (initial)
-                throw err;
-            console.error(err);
-        }
-        if (next !== state[key]) {
-            state[key] = next;
-            if (!initial || isAsync)
-                parent.update(key);
-        }
-    }
-    function connect(model) {
-        if (reset)
-            reset();
-        let done;
-        reset = () => done = true;
-        proxy = watch(model, (_, control) => {
-            if (done)
-                return null;
-            if (control !== parent)
-                compute();
-            else
-                PENDING.add(compute);
-        });
-        try {
-            compute(true);
-        }
-        finally {
-            ORDER.set(compute, OFFSET++);
-        }
-    }
-    return () => {
-        if (!active) {
-            active = true;
-            source(connect);
-            isAsync = true;
-        }
-        if (!proxy)
-            throw suspense(parent, key);
-        if (PENDING.delete(compute))
-            compute();
-        return state[key];
-    };
-}
-function flushComputed() {
-    while (PENDING.size) {
-        let compute;
-        for (const item of PENDING)
-            if (!compute || ORDER.get(item) < ORDER.get(compute))
-                compute = item;
-        PENDING.delete(compute);
-        compute();
-    }
-}
-Control.before.add(flushComputed);
-
-const Oops$2 = issues({
-    BadRefObject: () => `ref instruction does not support object which is not 'this'`
-});
-function ref(arg, arg2) {
-    return apply((key, source) => {
-        let value = {};
-        if (typeof arg != "object")
-            value = createRef(source, key, arg && createValueEffect(arg, arg2 !== false));
-        else if (arg !== source.subject)
-            throw Oops$2.BadRefObject();
-        else
-            for (const key in source.state)
-                defineProperty(value, key, typeof arg2 == "function" ? {
-                    configurable: true,
-                    get() {
-                        const out = arg2(key);
-                        defineProperty(value, key, { value: out });
-                        return out;
-                    }
-                } : {
-                    value: createRef(source, key)
-                });
-        source.state[key] = undefined;
-        source.observers.set(key, new Set());
-        defineProperty(source.subject, key, { value });
-    });
-}
-function createRef(src, key, cb) {
-    const refObjectFunction = src.ref(key, cb);
-    defineProperty(refObjectFunction, "current", {
-        set: refObjectFunction,
-        get: () => src.state[key]
-    });
-    return refObjectFunction;
-}
-
-const Oops$1 = issues({
-    ComputeFailed: (model, key) => `Generating initial value for ${model}.${key} failed.`,
-    NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`
-});
-function set(value, argument) {
-    return apply((key, control) => {
-        const { state, subject } = control;
-        if (typeof value == "function" || value instanceof Promise) {
-            const output = {};
-            const init = () => {
-                try {
-                    if (typeof value == "function")
-                        value = mayRetry(value.bind(subject, key, subject));
-                    if (value instanceof Promise) {
-                        const pending = value
-                            .then(value => {
-                            output.get = undefined;
-                            state[key] = value;
-                            return value;
-                        })
-                            .catch(err => {
-                            output.get = () => { throw err; };
-                        })
-                            .finally(() => {
-                            control.update(key);
-                        });
-                        if (argument !== false)
-                            return () => {
-                                const { message, stack } = Oops$1.NotReady(subject, key);
-                                throw assign(pending, { message, stack });
-                            };
-                    }
-                    else
-                        state[key] = value;
-                }
-                catch (err) {
-                    Oops$1.ComputeFailed(subject, key).warn();
-                    throw err;
-                }
-            };
-            if (argument)
-                init();
-            else
-                output.get = () => {
-                    const get = output.get =
-                        key in state ? undefined : init();
-                    return get ? get() : state[key];
-                };
-            return output;
-        }
-        const set = typeof argument == "function"
-            ? createValueEffect(argument)
-            : undefined;
-        if (value !== undefined) {
-            state[key] = value;
-            return { set };
-        }
-        const output = {
-            get() {
-                if (key in state)
-                    return state[key];
-                throw suspense(control, key);
-            }
-        };
-        if (set)
-            output.set = function (value) {
-                output.set = set;
-                state[key] = state[key];
-                return set.call(this, value);
-            };
-        return output;
-    });
-}
-
-function use(input, argument) {
-    return apply((key, source) => {
-        const { state, subject } = source;
-        if (typeof input === "function")
-            input = new input();
-        function set(next) {
-            if (next instanceof Model) {
-                parent(next, subject);
-                control(next, true);
-            }
-            else if (next)
-                next = manage(next);
-            state[key] = next;
-            if (typeof argument == "function")
-                argument(next);
-            return true;
-        }
-        set(input);
-        return { set };
-    });
-}
-function manage(next) {
-    const subject = assign(create(next), {
-        get: getMethod,
-        set: setMethod
-    });
-    const control = new Control(subject, false);
-    for (const key in control.state = next)
-        control.watch(key, {});
-    return subject;
-}
-
-const Oops = issues({
-    MultipleExist: (name) => `Did find ${name} in context, but multiple were defined.`
-});
-class Context {
-    constructor() {
-        this.table = new WeakMap();
-        this.layer = new Map();
-    }
-    has(T) {
-        let key = this.table.get(T);
-        if (!key) {
-            key = Symbol(T.name);
-            this.table.set(T, key);
-        }
-        return key;
-    }
-    get(Type) {
-        const result = this[this.has(Type)];
-        if (result === null)
-            throw Oops.MultipleExist(Type);
-        return result;
-    }
-    include(inputs) {
-        const init = new Map();
-        for (const key in inputs) {
-            const input = inputs[key];
-            const exists = this.layer.get(key);
-            if (!exists) {
-                const instance = this.add(input);
-                this.layer.set(key, input);
-                init.set(instance, true);
-            }
-            // Context must force-reset becasue inputs are no longer safe.
-            else if (exists !== input) {
-                this.pop();
-                this.key = uid();
-                return this.include(inputs);
-            }
-        }
-        for (const [model] of init) {
-            const { state } = control(model, true);
-            Object.values(state).forEach(value => {
-                if (parent(value) === model) {
-                    this.add(value, true);
-                    init.set(value, false);
-                }
-            });
-        }
-        return init;
-    }
-    add(input, implicit) {
-        let writable = true;
-        let T;
-        let I;
-        if (typeof input == "function") {
-            T = input;
-            I = new input();
-        }
-        else {
-            I = control(input).subject;
-            T = I.constructor;
-            writable = false;
-        }
-        do {
-            const key = this.has(T);
-            const value = this.hasOwnProperty(key) ? null : I;
-            if (value || I !== this[key] && !implicit)
-                defineProperty(this, key, {
-                    configurable: true,
-                    value,
-                    writable
-                });
-            T = getPrototypeOf(T);
-        } while (T !== Model);
-        return I;
-    }
-    push() {
-        const next = create(this);
-        next.layer = new Map();
-        return next;
-    }
-    pop() {
-        const items = new Set();
-        for (const key of getOwnPropertySymbols(this)) {
-            const entry = getOwnPropertyDescriptor(this, key);
-            if (entry.writable && entry.value)
-                items.add(entry.value);
-            delete this[key];
-        }
-        for (const model of items)
-            model.null();
-        this.layer.clear();
-    }
-}
-
-const STATE = "__state";
-const UPDATE = "__update";
-const CONTROL = "__control";
-const PARENT = "__parent";
-defineProperties(Model.prototype, {
-    [CONTROL]: {
-        get() {
-            return control(this);
-        }
-    },
-    [STATE]: {
-        get() {
-            return Object.assign({}, control(this).state);
-        }
-    },
-    [UPDATE]: {
-        get() {
-            return control(this).latest;
-        }
-    },
-    [PARENT]: {
-        get() {
-            return parent(this);
-        }
-    }
-});
-const Debug = {
-    CONTROL,
-    STATE,
-    UPDATE,
-    PARENT
-};
-
-export { Context, Control, Debug, Model, Model as default, get, ref, run, set, use };