const builtin = this.module();

Object.defineProperties(this, {

_dirty: {value: new Set},

_updates: {value: new Set},

_precomputes: {value: [], writable: true},

_computing: {value: null, writable: true},

_init: {value: null, writable: true},

_modules: {value: new Map},

_variables: {value: new Set},

_disposed: {value: false, writable: true},

_builtin: {value: builtin},

_global: {value: global}

});

if (builtins) for (const name in builtins) {

(new Variable(TYPE_IMPLICIT, builtin)).define(name, [], builtins[name]);

}

this._computing = Promise.resolve();

this._disposed = true;

this._variables.forEach(v => {

v._invalidate();

v._version = NaN;

});

let module;

if (define === undefined) {

if (module = this._init) {

this._init = null;

return module;

}

return new Module(this);

}

module = this._modules.get(define);

if (module) return module;

this._init = module = new Module(this);

this._modules.set(define, module);

try {

define(this, observer);

} finally {

this._init = null;

}

return module;

let queue = [],

variables,

variable,

precomputes = this._precomputes;

// If there are any paused generators, resume them before computing so they

// can update (if synchronous) before computing downstream variables.

if (precomputes.length) {

this._precomputes = [];

for (const callback of precomputes) callback();

await runtime_defer(3);

}

// Compute the reachability of the transitive closure of dirty variables.

// Any newly-reachable variable must also be recomputed.

// Any no-longer-reachable variable must be terminated.

variables = new Set(this._dirty);

variables.forEach(function(variable) {

variable._inputs.forEach(variables.add, variables);

const reachable = variable_reachable(variable);

if (reachable > variable._reachable) {

this._updates.add(variable);

} else if (reachable < variable._reachable) {

variable._invalidate();

}

variable._reachable = reachable;

}, this);

// Compute the transitive closure of updating, reachable variables.

variables = new Set(this._updates);

variables.forEach(function(variable) {

if (variable._reachable) {

variable._indegree = 0;

variable._outputs.forEach(variables.add, variables);

} else {

variable._indegree = NaN;

variables.delete(variable);

}

});

this._computing = null;

this._updates.clear();

this._dirty.clear();

// Compute the indegree of updating variables.

variables.forEach(function(variable) {

variable._outputs.forEach(variable_increment);

});

do {

// Identify the root variables (those with no updating inputs).

variables.forEach(function(variable) {

if (variable._indegree === 0) {

queue.push(variable);

}

});

// Compute the variables in topological order.

while (variable = queue.pop()) {

variable_compute(variable);

variable._outputs.forEach(postqueue);

variables.delete(variable);

}

// Any remaining variables are circular, or depend on them.

variables.forEach(function(variable) {

if (variable_circular(variable)) {

variable_error(variable, new RuntimeError("circular definition"));

variable._outputs.forEach(variable_decrement);

variables.delete(variable);

}

});

} while (variables.size);

function postqueue(variable) {

if (--variable._indegree === 0) {

queue.push(variable);

}

}

let p = Promise.resolve();

for (let i = 0; i < depth; ++i) p = p.then(() => {});

return p;

const inputs = new Set(variable._inputs);

for (const i of inputs) {

if (i === variable) return true;

i._inputs.forEach(inputs.add, inputs);

}

return false;

return new Promise(function(resolve) {

variable._invalidate = resolve;

});

let node = typeof IntersectionObserver === "function" && variable._observer && variable._observer._node;

let visible = !node, resolve = noop, reject = noop, promise, observer;

if (node) {

observer = new IntersectionObserver(([entry]) => (visible = entry.isIntersecting) && (promise = null, resolve()));

observer.observe(node);

invalidation.then(() => (observer.disconnect(), observer = null, reject()));

}

return function(value) {

if (visible) return Promise.resolve(value);

if (!observer) return Promise.reject();

if (!promise) promise = new Promise((y, n) => (resolve = y, reject = n));

return promise.then(() => value);

};

variable._invalidate();

variable._invalidate = noop;

variable._pending();

const value0 = variable._value;

const version = ++variable._version;

// Lazily-constructed invalidation variable; only constructed if referenced as an input.

let invalidation = null;

// If the variable doesn’t have any inputs, we can optimize slightly.

const promise = variable._promise = (variable._inputs.length

? Promise.all(variable._inputs.map(variable_value)).then(define)

: new Promise(resolve => resolve(variable._definition.call(value0))))

.then(generate);

// Compute the initial value of the variable.

function define(inputs) {

if (variable._version !== version) throw variable_stale;

// Replace any reference to invalidation with the promise, lazily.

for (let i = 0, n = inputs.length; i < n; ++i) {

switch (inputs[i]) {

case variable_invalidation: {

inputs[i] = invalidation = variable_invalidator(variable);

break;

}

case variable_visibility: {

if (!invalidation) invalidation = variable_invalidator(variable);

inputs[i] = variable_intersector(invalidation, variable);

break;

}

case variable_variable: {

inputs[i] = variable;

break;

}

}

}

return variable._definition.apply(value0, inputs);

}

// If the value is a generator, then retrieve its first value, and dispose of

// the generator if the variable is invalidated. Note that the cell may

// already have been invalidated here, in which case we need to terminate the

// generator immediately!

function generate(value) {

if (variable._version !== version) throw variable_stale;

if (generatorish(value)) {

(invalidation || variable_invalidator(variable)).then(variable_return(value));

return variable_generate(variable, version, value);

}

return value;

}

promise.then((value) => {

variable._value = value;

variable._fulfilled(value);

}, (error) => {

if (error === variable_stale || variable._version !== version) return;

variable._value = undefined;

variable._rejected(error);

});

const runtime = variable._module._runtime;

let currentValue; // so that yield resolves to the yielded value

// Retrieve the next value from the generator; if successful, invoke the

// specified callback. The returned promise resolves to the yielded value, or

// to undefined if the generator is done.

function compute(onfulfilled) {

return new Promise(resolve => resolve(generator.next(currentValue))).then(({done, value}) => {

return done ? undefined : Promise.resolve(value).then(onfulfilled);

});

}

// Retrieve the next value from the generator; if successful, fulfill the

// variable, compute downstream variables, and schedule the next value to be

// pulled from the generator at the start of the next animation frame. If not

// successful, reject the variable, compute downstream variables, and return.

function recompute() {

const promise = compute((value) => {

if (variable._version !== version) throw variable_stale;

currentValue = value;

postcompute(value, promise).then(() => runtime._precompute(recompute));

variable._fulfilled(value);

return value;

});

promise.catch((error) => {

if (error === variable_stale || variable._version !== version) return;

postcompute(undefined, promise);

variable._rejected(error);

});

}

// After the generator fulfills or rejects, set its current value, promise,

// and schedule any downstream variables for update.

function postcompute(value, promise) {

variable._value = value;

variable._promise = promise;

variable._outputs.forEach(runtime._updates.add, runtime._updates);

return runtime._compute();

}

// When retrieving the first value from the generator, the promise graph is

// already established, so we only need to queue the next pull.

return compute((value) => {

if (variable._version !== version) throw variable_stale;

currentValue = value;

runtime._precompute(recompute);

return value;

});

variable._invalidate();

variable._invalidate = noop;

variable._pending();

++variable._version;

variable._indegree = NaN;

(variable._promise = Promise.reject(error)).catch(noop);

variable._value = undefined;

variable._rejected(error);

return function() {

generator.return();

};

if (variable._observer !== no_observer) return true; // Directly reachable.

const outputs = new Set(variable._outputs);

for (const output of outputs) {

if (output._observer !== no_observer) return true;

output._outputs.forEach(outputs.add, outputs);

}

return false;