feat(web): Backdrops, the engine in Rust and WASM, and the dashboard's Your sky (refs #157) 17ca6cddc534

/**

 * Start the dashboard's sky on `canvas` with the page's `data`. `still`

 * is the viewer's choice of a still backdrop; reduced motion asks for

 * one too. Without WebGL2 there is no backdrop, and nothing breaks.

 * @param {HTMLCanvasElement} canvas

 * @param {any} data

 * @param {boolean} still

 */

export function start(canvas, data, still) {

    const ret = wasm.start(canvas, data, still);

    if (ret[1]) {

        throw takeFromExternrefTable0(ret[0]);

    }

}

function __wbg_get_imports() {

    const import0 = {

        __proto__: null,

        __wbg___wbindgen_boolean_get_5b446f51afd21013: function(arg0) {

            const v = arg0;

            const ret = typeof(v) === 'boolean' ? v : undefined;

            return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;

        },

        __wbg___wbindgen_is_undefined_8865fb403f8fe9d8: function(arg0) {

            const ret = arg0 === undefined;

            return ret;

        },

        __wbg___wbindgen_number_get_2e0e7dee9f701a71: function(arg0, arg1) {

            const obj = arg1;

            const ret = typeof(obj) === 'number' ? obj : undefined;

            getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);

            getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);

        },

        __wbg___wbindgen_string_get_0380ccaa2f57f0d9: function(arg0, arg1) {

            const obj = arg1;

            const ret = typeof(obj) === 'string' ? obj : undefined;

            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);

            var len1 = WASM_VECTOR_LEN;

            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);

            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);

        },

        __wbg___wbindgen_throw_41e9ee4f547fc59a: function(arg0, arg1) {

            throw new Error(getStringFromWasm0(arg0, arg1));

        },

        __wbg__wbg_cb_unref_dcc1a90847f04c41: function(arg0) {

            arg0._wbg_cb_unref();

        },

        __wbg_addEventListener_4d0db17c671ea324: function() { return handleError(function (arg0, arg1, arg2, arg3) {

            arg0.addEventListener(getStringFromWasm0(arg1, arg2), arg3);

        }, arguments); },

        __wbg_appendChild_fb8c52e7dd8484ea: function() { return handleError(function (arg0, arg1) {

            const ret = arg0.appendChild(arg1);

            return ret;

        }, arguments); },

        __wbg_attachShader_9567ae57af6746d5: function(arg0, arg1, arg2) {

            arg0.attachShader(arg1, arg2);

        },

        __wbg_bindBuffer_0324f62b876c4403: function(arg0, arg1, arg2) {

            arg0.bindBuffer(arg1 >>> 0, arg2);

        },

        __wbg_bindVertexArray_f58af0a346185ec5: function(arg0, arg1) {

            arg0.bindVertexArray(arg1);

        },

        __wbg_blendFunc_589e4252bb396484: function(arg0, arg1, arg2) {

            arg0.blendFunc(arg1 >>> 0, arg2 >>> 0);

        },

        __wbg_body_e549239eaff082e1: function(arg0) {

            const ret = arg0.body;

            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);

        },

        __wbg_bufferData_5fa44d94fe7a3878: function(arg0, arg1, arg2, arg3) {

            arg0.bufferData(arg1 >>> 0, arg2, arg3 >>> 0);

        },

        __wbg_clearColor_796427e8ac60fe14: function(arg0, arg1, arg2, arg3, arg4) {

            arg0.clearColor(arg1, arg2, arg3, arg4);

        },

        __wbg_clear_cb96796cc568b7c8: function(arg0, arg1) {

            arg0.clear(arg1 >>> 0);

        },

        __wbg_clientX_5075231ed45e8ef5: function(arg0) {

            const ret = arg0.clientX;

            return ret;

        },

        __wbg_clientY_846c39814ce02ab2: function(arg0) {

            const ret = arg0.clientY;

            return ret;

        },

        __wbg_compileShader_c2b53ff3a8851f60: function(arg0, arg1) {

            arg0.compileShader(arg1);

        },

        __wbg_createBuffer_ffe613371d42cfd3: function(arg0) {

            const ret = arg0.createBuffer();

            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);

        },

        __wbg_createElement_74049073a11f9c31: function() { return handleError(function (arg0, arg1, arg2) {

            const ret = arg0.createElement(getStringFromWasm0(arg1, arg2));

            return ret;

        }, arguments); },

        __wbg_createProgram_cbf448e6f18a9402: function(arg0) {

            const ret = arg0.createProgram();

            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);

        },

        __wbg_createShader_6c1a2295587878a5: function(arg0, arg1) {

            const ret = arg0.createShader(arg1 >>> 0);

            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);

        },

        __wbg_createVertexArray_b223ea69dd08fcab: function(arg0) {

            const ret = arg0.createVertexArray();

            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);

        },

        __wbg_devicePixelRatio_7d39e9af5448d3d4: function(arg0) {

            const ret = arg0.devicePixelRatio;

            return ret;

        },

        __wbg_document_9854e03c05fc8834: function(arg0) {

            const ret = arg0.document;

            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);

        },

        __wbg_drawArraysInstanced_9b44aa78a087154d: function(arg0, arg1, arg2, arg3, arg4) {

            arg0.drawArraysInstanced(arg1 >>> 0, arg2, arg3, arg4);

        },

        __wbg_drawArrays_08872e02fb57b847: function(arg0, arg1, arg2, arg3) {

            arg0.drawArrays(arg1 >>> 0, arg2, arg3);

        },

        __wbg_enableVertexAttribArray_d52693866bc8b8dd: function(arg0, arg1) {

            arg0.enableVertexAttribArray(arg1 >>> 0);

        },

        __wbg_enable_cb4fc19b51148c37: function(arg0, arg1) {

            arg0.enable(arg1 >>> 0);

        },

        __wbg_from_296ca31f8d0f1c52: function(arg0) {

            const ret = Array.from(arg0);

            return ret;

        },

        __wbg_getComputedStyle_dd0f456804795fd6: function() { return handleError(function (arg0, arg1) {

            const ret = arg0.getComputedStyle(arg1);

            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);

        }, arguments); },

        __wbg_getContext_051324720aa5b7e8: function() { return handleError(function (arg0, arg1, arg2, arg3) {

            const ret = arg0.getContext(getStringFromWasm0(arg1, arg2), arg3);

            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);

        }, arguments); },

        __wbg_getProgramInfoLog_3276b294d6d42fe2: function(arg0, arg1, arg2) {

            const ret = arg1.getProgramInfoLog(arg2);

            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);

            var len1 = WASM_VECTOR_LEN;

            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);

            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);

        },

        __wbg_getProgramParameter_fc7124bb9fb7c675: function(arg0, arg1, arg2) {

            const ret = arg0.getProgramParameter(arg1, arg2 >>> 0);

            return ret;

        },

        __wbg_getPropertyValue_e90a3628c2de4fb6: function() { return handleError(function (arg0, arg1, arg2, arg3) {

            const ret = arg1.getPropertyValue(getStringFromWasm0(arg2, arg3));

            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);

            const len1 = WASM_VECTOR_LEN;

            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);

            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);

        }, arguments); },

        __wbg_getShaderInfoLog_7e0cbba353ca95da: function(arg0, arg1, arg2) {

            const ret = arg1.getShaderInfoLog(arg2);

            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);

            var len1 = WASM_VECTOR_LEN;

            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);

            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);

        },

        __wbg_getShaderParameter_745acf10b8e45e31: function(arg0, arg1, arg2) {

            const ret = arg0.getShaderParameter(arg1, arg2 >>> 0);

            return ret;

        },

        __wbg_getUniformLocation_50ba45dade572703: function(arg0, arg1, arg2, arg3) {

            const ret = arg0.getUniformLocation(arg1, getStringFromWasm0(arg2, arg3));

            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);

        },

        __wbg_get_31af05bd4842a84f: function() { return handleError(function (arg0, arg1) {

            const ret = Reflect.get(arg0, arg1);

            return ret;

        }, arguments); },

        __wbg_get_6c896e0571ddae51: function(arg0, arg1) {

            const ret = arg0[arg1 >>> 0];

            return ret;

        },

        __wbg_get_unchecked_288889d017702237: function(arg0, arg1) {

            const ret = arg0[arg1 >>> 0];

            return ret;

        },

        __wbg_hidden_2ba371ecafe013fa: function(arg0) {

            const ret = arg0.hidden;

            return ret;

        },

        __wbg_innerHeight_7f20e0f1a7c5a573: function() { return handleError(function (arg0) {

            const ret = arg0.innerHeight;

            return ret;

        }, arguments); },

        __wbg_innerWidth_1bc526614080537c: function() { return handleError(function (arg0) {

            const ret = arg0.innerWidth;

            return ret;

        }, arguments); },

        __wbg_instanceof_HtmlElement_32fb153a5a0e2349: function(arg0) {

            let result;

            try {

                result = arg0 instanceof HTMLElement;

            } catch (_) {

                result = false;

            }

            const ret = result;

            return ret;

        },

        __wbg_instanceof_WebGl2RenderingContext_64c994c14c0790fb: function(arg0) {

            let result;

            try {

                result = arg0 instanceof WebGL2RenderingContext;

            } catch (_) {

                result = false;

            }

            const ret = result;

            return ret;

        },

        __wbg_instanceof_Window_82d71df4eddf88bc: function(arg0) {

            let result;

            try {

                result = arg0 instanceof Window;

            } catch (_) {

                result = false;

            }

            const ret = result;

            return ret;

        },

        __wbg_length_d4bdea10311bd9cf: function(arg0) {

            const ret = arg0.length;

            return ret;

        },

        __wbg_linkProgram_acdc299c43d734a0: function(arg0, arg1) {

            arg0.linkProgram(arg1);

        },

        __wbg_matchMedia_8a4857f947f11f82: function() { return handleError(function (arg0, arg1, arg2) {

            const ret = arg0.matchMedia(getStringFromWasm0(arg1, arg2));

            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);

        }, arguments); },

        __wbg_matches_778d0873b064b1bf: function(arg0) {

            const ret = arg0.matches;

            return ret;

        },

        __wbg_new_617a8cdb8bb1130e: function() {

            const ret = new Object();

            return ret;

        },

        __wbg_now_d0b7f4bea9f38490: function(arg0) {

            const ret = arg0.now();

            return ret;

        },

        __wbg_performance_d0d7b03fc649b694: function(arg0) {

            const ret = arg0.performance;

            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);

        },

        __wbg_relatedTarget_520fe88b1de28b43: function(arg0) {

            const ret = arg0.relatedTarget;

            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);

        },

        __wbg_requestAnimationFrame_7b526ab7aa550c74: function() { return handleError(function (arg0, arg1) {

            const ret = arg0.requestAnimationFrame(arg1);

            return ret;

        }, arguments); },

        __wbg_setAttribute_9e7d603908f63705: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {

            arg0.setAttribute(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));

        }, arguments); },

        __wbg_setProperty_097bc3d55ce44513: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {

            arg0.setProperty(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));

        }, arguments); },

        __wbg_set_145a351398b48c65: function() { return handleError(function (arg0, arg1, arg2) {

            const ret = Reflect.set(arg0, arg1, arg2);

            return ret;

        }, arguments); },

        __wbg_set_className_541fce5cd31918aa: function(arg0, arg1, arg2) {

            arg0.className = getStringFromWasm0(arg1, arg2);

        },

        __wbg_set_height_c9789c1c77eaedff: function(arg0, arg1) {

            arg0.height = arg1 >>> 0;

        },

        __wbg_set_textContent_6d6fc559f198055f: function(arg0, arg1, arg2) {

            arg0.textContent = arg1 === 0 ? undefined : getStringFromWasm0(arg1, arg2);

        },

        __wbg_set_width_b0e1267db4b196b5: function(arg0, arg1) {

            arg0.width = arg1 >>> 0;

        },

        __wbg_shaderSource_c8812639b47d87b9: function(arg0, arg1, arg2, arg3) {

            arg0.shaderSource(arg1, getStringFromWasm0(arg2, arg3));

        },

        __wbg_static_accessor_GLOBAL_266715b9d96ba635: function() {

            const ret = typeof global === 'undefined' ? null : global;

            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);

        },

        __wbg_static_accessor_GLOBAL_THIS_10fb7dc1ae063179: function() {

            const ret = typeof globalThis === 'undefined' ? null : globalThis;

            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);

        },

        __wbg_static_accessor_SELF_0b583911f537483a: function() {

            const ret = typeof self === 'undefined' ? null : self;

            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);

        },

        __wbg_static_accessor_WINDOW_d7f903d1508cbdc4: function() {

            const ret = typeof window === 'undefined' ? null : window;

            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);

        },

        __wbg_style_4bce24230e493a7c: function(arg0) {

            const ret = arg0.style;

            return ret;

        },

        __wbg_uniform2f_a92b5bb95dc5b4d9: function(arg0, arg1, arg2, arg3) {

            arg0.uniform2f(arg1, arg2, arg3);

        },

        __wbg_useProgram_e075c2902e420761: function(arg0, arg1) {

            arg0.useProgram(arg1);

        },

        __wbg_vertexAttribDivisor_7575d382215322f7: function(arg0, arg1, arg2) {

            arg0.vertexAttribDivisor(arg1 >>> 0, arg2 >>> 0);

        },

        __wbg_vertexAttribPointer_24b495e18df325dc: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {

            arg0.vertexAttribPointer(arg1 >>> 0, arg2, arg3 >>> 0, arg4 !== 0, arg5, arg6);

        },

        __wbg_viewport_16936692526e2ce6: function(arg0, arg1, arg2, arg3, arg4) {

            arg0.viewport(arg1, arg2, arg3, arg4);

        },

        __wbindgen_generic_0000000000000001: function(arg0, arg1) {

            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [F64], shim_idx: 6, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.

            const ret = makeMutClosure(arg0, arg1, wasm_bindgen_ef67fbc5f0a8b406___convert__closures_____invoke___f64______true_);

            return ret;

        },

        __wbindgen_generic_0000000000000002: function(arg0, arg1) {

            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("MouseEvent")], shim_idx: 5, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.

            const ret = makeMutClosure(arg0, arg1, wasm_bindgen_ef67fbc5f0a8b406___convert__closures_____invoke___web_sys_793942649ef82f98___features__gen_MouseEvent__MouseEvent______true_);

            return ret;

        },

        __wbindgen_generic_0000000000000003: function(arg0, arg1) {

            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 4, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.

            const ret = makeMutClosure(arg0, arg1, wasm_bindgen_ef67fbc5f0a8b406___convert__closures_____invoke_______true_);

            return ret;

        },

        __wbindgen_generic_0000000000000004: function(arg0, arg1) {

            // Cast intrinsic for `Ref(Slice(F32)) -> NamedExternref("Float32Array")`.

            const ret = getArrayF32FromWasm0(arg0, arg1);

            return ret;

        },

        __wbindgen_generic_0000000000000005: function(arg0, arg1) {

            // Cast intrinsic for `Ref(String) -> Externref`.

            const ret = getStringFromWasm0(arg0, arg1);

            return ret;

        },

        __wbindgen_init_externref_table: function() {

            const table = wasm.__wbindgen_externrefs;

            const offset = table.grow(4);

            table.set(0, undefined);

            table.set(offset + 0, undefined);

            table.set(offset + 1, null);

            table.set(offset + 2, true);

            table.set(offset + 3, false);

        },

    };

    return {

        __proto__: null,

        "./backdrop_bg.js": import0,

    };

}

function wasm_bindgen_ef67fbc5f0a8b406___convert__closures_____invoke_______true_(arg0, arg1) {

    wasm.wasm_bindgen_ef67fbc5f0a8b406___convert__closures_____invoke_______true_(arg0, arg1);

}

function wasm_bindgen_ef67fbc5f0a8b406___convert__closures_____invoke___web_sys_793942649ef82f98___features__gen_MouseEvent__MouseEvent______true_(arg0, arg1, arg2) {

    wasm.wasm_bindgen_ef67fbc5f0a8b406___convert__closures_____invoke___web_sys_793942649ef82f98___features__gen_MouseEvent__MouseEvent______true_(arg0, arg1, arg2);

}

function wasm_bindgen_ef67fbc5f0a8b406___convert__closures_____invoke___f64______true_(arg0, arg1, arg2) {

    wasm.wasm_bindgen_ef67fbc5f0a8b406___convert__closures_____invoke___f64______true_(arg0, arg1, arg2);

}

function addToExternrefTable0(obj) {

    const idx = wasm.__externref_table_alloc();

    wasm.__wbindgen_externrefs.set(idx, obj);

    return idx;

}

const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')

    ? { register: () => {}, unregister: () => {} }

    : new FinalizationRegistry(state => wasm.__wbindgen_destroy_closure(state.a, state.b));

function getArrayF32FromWasm0(ptr, len) {

    ptr = ptr >>> 0;

    return getFloat32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);

}

let cachedDataViewMemory0 = null;

function getDataViewMemory0() {

    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {

        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);

    }

    return cachedDataViewMemory0;

}

let cachedFloat32ArrayMemory0 = null;

function getFloat32ArrayMemory0() {

    if (cachedFloat32ArrayMemory0 === null || cachedFloat32ArrayMemory0.byteLength === 0) {

        cachedFloat32ArrayMemory0 = new Float32Array(wasm.memory.buffer);

    }

    return cachedFloat32ArrayMemory0;

}

function getStringFromWasm0(ptr, len) {

    return decodeText(ptr >>> 0, len);

}

let cachedUint8ArrayMemory0 = null;

function getUint8ArrayMemory0() {

    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {

        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);

    }

    return cachedUint8ArrayMemory0;

}

function handleError(f, args) {

    try {

        return f.apply(this, args);

    } catch (e) {

        const idx = addToExternrefTable0(e);

        wasm.__wbindgen_exn_store(idx);

    }

}

function isLikeNone(x) {

    return x === undefined || x === null;

}

function makeMutClosure(arg0, arg1, f) {

    const state = { a: arg0, b: arg1, cnt: 1 };

    const real = (...args) => {

        // First up with a closure we increment the internal reference

        // count. This ensures that the Rust closure environment won't

        // be deallocated while we're invoking it.

        state.cnt++;

        const a = state.a;

        state.a = 0;

        try {

            return f(a, state.b, ...args);

        } finally {

            state.a = a;

            real._wbg_cb_unref();

        }

    };

    real._wbg_cb_unref = () => {

        if (--state.cnt === 0) {

            wasm.__wbindgen_destroy_closure(state.a, state.b);

            state.a = 0;

            CLOSURE_DTORS.unregister(state);

        }

    };

    CLOSURE_DTORS.register(real, state, state);

    return real;

}

function passStringToWasm0(arg, malloc, realloc) {

    if (realloc === undefined) {

        const buf = cachedTextEncoder.encode(arg);

        const ptr = malloc(buf.length, 1) >>> 0;

        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);

        WASM_VECTOR_LEN = buf.length;

        return ptr;

    }

    let len = arg.length;

    let ptr = malloc(len, 1) >>> 0;

    const mem = getUint8ArrayMemory0();

    let offset = 0;

    for (; offset < len; offset++) {

        const code = arg.charCodeAt(offset);

        if (code > 0x7F) break;

        mem[ptr + offset] = code;

    }

    if (offset !== len) {

        if (offset !== 0) {

            arg = arg.slice(offset);

        }

        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;

        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);

        const ret = cachedTextEncoder.encodeInto(arg, view);

        offset += ret.written;

        ptr = realloc(ptr, len, offset, 1) >>> 0;

    }

    WASM_VECTOR_LEN = offset;

    return ptr;

}

function takeFromExternrefTable0(idx) {

    const value = wasm.__wbindgen_externrefs.get(idx);

    wasm.__externref_table_dealloc(idx);

    return value;

}

let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });

cachedTextDecoder.decode();

const MAX_SAFARI_DECODE_BYTES = 2146435072;

let numBytesDecoded = 0;

function decodeText(ptr, len) {

    numBytesDecoded += len;

    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {

        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });

        cachedTextDecoder.decode();

        numBytesDecoded = len;

    }

    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));

}

const cachedTextEncoder = new TextEncoder();

if (!('encodeInto' in cachedTextEncoder)) {

    cachedTextEncoder.encodeInto = function (arg, view) {

        const buf = cachedTextEncoder.encode(arg);

        view.set(buf);

        return {

            read: arg.length,

            written: buf.length

        };

    };

}

let WASM_VECTOR_LEN = 0;

let wasmModule, wasmInstance, wasm;

function __wbg_finalize_init(instance, module) {

    wasmInstance = instance;

    wasm = instance.exports;

    wasmModule = module;

    cachedDataViewMemory0 = null;

    cachedFloat32ArrayMemory0 = null;

    cachedUint8ArrayMemory0 = null;

    wasm.__wbindgen_start();

    return wasm;

}

async function __wbg_load(module, imports) {

    if (typeof Response === 'function' && module instanceof Response) {

        if (!module.ok) {

            throw new Error(`failed to fetch Wasm: ${module.status} ${module.statusText} fetching '${module.url}'`);

        }

        if (typeof WebAssembly.instantiateStreaming === 'function') {

            try {

                return await WebAssembly.instantiateStreaming(module, imports);

            } catch (e) {

                const validResponse = expectedResponseType(module.type);

                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {

                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);

                } else { throw e; }

            }

        }

        const bytes = await module.arrayBuffer();

        return await WebAssembly.instantiate(bytes, imports);

    } else {

        const instance = await WebAssembly.instantiate(module, imports);

        if (instance instanceof WebAssembly.Instance) {

            return { instance, module };

        } else {

            return instance;

        }

    }

    function expectedResponseType(type) {

        switch (type) {

            case 'basic': case 'cors': case 'default': return true;

        }

        return false;

    }

}

function initSync(module) {

    if (wasm !== undefined) return wasm;

    if (module !== undefined) {

        if (Object.getPrototypeOf(module) === Object.prototype) {

            ({module} = module)

        } else {

            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')

        }

    }

    const imports = __wbg_get_imports();

    if (!(module instanceof WebAssembly.Module)) {

        module = new WebAssembly.Module(module);

    }

    const instance = new WebAssembly.Instance(module, imports);

    return __wbg_finalize_init(instance, module);

}

async function __wbg_init(module_or_path) {

    if (wasm !== undefined) return wasm;

    if (module_or_path !== undefined) {

        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {

            ({module_or_path} = module_or_path)

        } else {

            console.warn('using deprecated parameters for the initialization function; pass a single object instead')

        }

    }

    if (module_or_path === undefined) {

        module_or_path = new URL('backdrop_bg.wasm', import.meta.url);

    }

    const imports = __wbg_get_imports();

    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {

        module_or_path = fetch(module_or_path);

    }

    const { instance, module } = await __wbg_load(await module_or_path, imports);

    return __wbg_finalize_init(instance, module);

}

export { initSync, __wbg_init as default };

# This file is automatically @generated by Cargo.

# It is not intended for manual editing.

version = 4

[[package]]

name = "backdrop"

version = "0.1.0"

dependencies = [

 "js-sys",

 "wasm-bindgen",

 "web-sys",

]

[[package]]

name = "bumpalo"

version = "3.20.3"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649"

[[package]]

name = "cfg-if"

version = "1.0.5"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600"

[[package]]

name = "futures-core"

version = "0.3.34"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "92d699e522242e69e3003b94ecc1f960f3a5e015aa7c5d7486e65ad01dd94f5e"

[[package]]

name = "futures-task"

version = "0.3.34"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "cd417de3d1d015fc3bfd2b1ea46dfc7bab72ef86f1cc7cc9c78e728b34a6d1fd"

[[package]]

name = "futures-util"

version = "0.3.34"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "0d50a92467f8ba5dd6e3ee5d4bd04d73ab2e4e1c44474a0674821dfce14b79bc"

dependencies = [

 "futures-core",

 "futures-task",

 "pin-project-lite",

 "slab",

]

[[package]]

name = "js-sys"

version = "0.3.106"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "7883d941dae510fb2d978fc3fe018c71c9e2892fd38854de3e8b92c2e5ad9cc5"

dependencies = [

 "cfg-if",

 "futures-util",

 "wasm-bindgen",

]

[[package]]

name = "once_cell"

version = "1.21.4"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"

[[package]]

name = "pin-project-lite"

version = "0.2.17"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"

[[package]]

name = "proc-macro2"

version = "1.0.107"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"

dependencies = [

 "unicode-ident",

]

[[package]]

name = "quote"

version = "1.0.47"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"

dependencies = [

 "proc-macro2",

]

[[package]]

name = "rustversion"

version = "1.0.23"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f"

[[package]]

name = "slab"

version = "0.4.12"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"

[[package]]

name = "syn"

version = "3.0.9"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "d78c8dee4c7bf0e14673097256fed6142ce9d3b85a408189d07482442145823b"

dependencies = [

 "proc-macro2",

 "quote",

 "unicode-ident",

]

[[package]]

name = "unicode-ident"

version = "1.0.27"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "a2c754d6c33795a1c324727428e5a7dedb5b06195f9890bdbcba760d3e246563"

[[package]]

name = "wasm-bindgen"

version = "0.2.129"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "9bb54f33acc68fd454578d9820b0bde1a1a3d17aa17bb7b6595806d02886d409"

dependencies = [

 "cfg-if",

 "once_cell",

 "rustversion",

 "wasm-bindgen-macro",

 "wasm-bindgen-shared",

]

[[package]]

name = "wasm-bindgen-macro"

version = "0.2.129"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "2e29d0c35b16e224a7eeb5cd2d25e3e1968fbd65604117b44d3b789d00ee8535"

dependencies = [

 "quote",

 "wasm-bindgen-macro-support",

]

[[package]]

name = "wasm-bindgen-macro-support"

version = "0.2.129"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "6f501a8bc3719dba86ef8ae4728879c08001bea749eb1333ac5b91e040e2a6b7"

dependencies = [

 "bumpalo",

 "proc-macro2",

 "quote",

 "syn",

 "wasm-bindgen-shared",

]

[[package]]

name = "wasm-bindgen-shared"

version = "0.2.129"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "23f0c9c52aa7cd7d77769a4cfe2a9adb1b331f489a41d912ce14513d5ab995c6"

dependencies = [

 "unicode-ident",

]

[[package]]

name = "web-sys"

version = "0.3.106"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "88261b9deccee56594c11a3460c462c41f58d148598fe70ad77070126a68aba4"

dependencies = [

 "js-sys",

 "wasm-bindgen",

]

# The backdrop engine (docs/backgrounds.md): Rust compiled to WebAssembly,

# drawing with WebGL2. A workspace of its own, outside the hub's, so the hub

# build and its offline CI never need the wasm toolchain: `make backdrop`

# builds it and writes assets/backdrop/, which the hub embeds.

[package]

name = "backdrop"

version = "0.1.0"

edition = "2021"

license = "MIT"

publish = false

[lib]

crate-type = ["cdylib", "rlib"]

[dependencies]

wasm-bindgen = "0.2"

js-sys = "0.3"

[dependencies.web-sys]

version = "0.3"

features = [

    "CssStyleDeclaration",

    "Document",

    "DomRect",

    "Element",

    "Event",

    "EventTarget",

    "HtmlCanvasElement",

    "HtmlElement",

    "MediaQueryList",

    "MouseEvent",

    "Performance",

    "WebGl2RenderingContext",

    "WebGlBuffer",

    "WebGlProgram",

    "WebGlShader",

    "WebGlUniformLocation",

    "WebGlVertexArrayObject",

    "Window",

]

[profile.release]

opt-level = "z"

lto = true

codegen-units = 1

panic = "abort"

[workspace]

//! Drawing a sky with WebGL2 (docs/backgrounds.md §6): every mark in one

//! instanced draw, every link in one line buffer. Shaders are here as

//! string literals; marks are drawn as signed-distance shapes, so they

//! stay crisp at any device pixel ratio.

use wasm_bindgen::prelude::*;

use web_sys::{WebGl2RenderingContext as Gl, WebGlBuffer, WebGlProgram, WebGlShader, WebGlUniformLocation, WebGlVertexArrayObject};

const MARK_VS: &str = r#"#version 300 es

layout(location = 0) in vec2 corner;

layout(location = 1) in vec2 center;

layout(location = 2) in float size;

layout(location = 3) in float shape;

layout(location = 4) in vec4 colour;

uniform vec2 view;

out vec2 uv;

out float vshape;

out vec4 vcolour;

out float px;

void main() {

    float r = size + 1.5;

    vec2 p = center + corner * r;

    uv = corner * r / size;

    vshape = shape;

    vcolour = colour;

    px = 1.0 / size;

    gl_Position = vec4(p.x / view.x * 2.0 - 1.0, 1.0 - p.y / view.y * 2.0, 0.0, 1.0);

}

"#;

const MARK_FS: &str = r#"#version 300 es

precision mediump float;

in vec2 uv;

in float vshape;

in vec4 vcolour;

in float px;

out vec4 frag;

void main() {

    vec2 a = abs(uv);

    float d;

    if (vshape < 0.5) {

        d = length(uv) - 1.0;                       // a push: a dot

    } else if (vshape < 1.5) {

        d = (a.x + a.y) * 0.85 - 1.0;               // a proposal: a diamond

    } else if (vshape < 2.5) {

        d = abs(length(uv) - 0.72) - 0.28;          // an issue: a ring

    } else if (vshape < 3.5) {

        d = min(a.x + 3.5 * a.y, 3.5 * a.x + a.y) * 0.5 - 0.5;  // a release: a star

    } else {

        d = abs(length(uv) - 0.85) - 0.12;          // a repository: a thin ring

    }

    float cover = 1.0 - smoothstep(-px, px, d);

    frag = vcolour * cover;

}

"#;

const LINE_VS: &str = r#"#version 300 es

layout(location = 0) in vec2 pos;

layout(location = 1) in vec4 colour;

uniform vec2 view;

out vec4 vcolour;

void main() {

    vcolour = colour;

    gl_Position = vec4(pos.x / view.x * 2.0 - 1.0, 1.0 - pos.y / view.y * 2.0, 0.0, 1.0);

}

"#;

const LINE_FS: &str = r#"#version 300 es

precision mediump float;

in vec4 vcolour;

out vec4 frag;

void main() { frag = vcolour; }

"#;

/// Floats per mark instance and per line vertex (sky::Sky's layouts).

const MARK_FLOATS: i32 = 8;

const LINE_FLOATS: i32 = 6;

pub struct Renderer {

    gl: Gl,

    marks: WebGlProgram,

    lines: WebGlProgram,

    mark_view: Option<WebGlUniformLocation>,

    line_view: Option<WebGlUniformLocation>,

    mark_vao: WebGlVertexArrayObject,

    line_vao: WebGlVertexArrayObject,

    instances: WebGlBuffer,

    line_buf: WebGlBuffer,

}

fn shader(gl: &Gl, kind: u32, src: &str) -> Result<WebGlShader, JsValue> {

    let s = gl.create_shader(kind).ok_or("no shader")?;

    gl.shader_source(&s, src);

    gl.compile_shader(&s);

    if gl.get_shader_parameter(&s, Gl::COMPILE_STATUS).as_bool() == Some(true) {

        Ok(s)

    } else {

        Err(gl.get_shader_info_log(&s).unwrap_or_default().into())

    }

}

fn program(gl: &Gl, vs: &str, fs: &str) -> Result<WebGlProgram, JsValue> {

    let p = gl.create_program().ok_or("no program")?;

    gl.attach_shader(&p, &shader(gl, Gl::VERTEX_SHADER, vs)?);

    gl.attach_shader(&p, &shader(gl, Gl::FRAGMENT_SHADER, fs)?);

    gl.link_program(&p);

    if gl.get_program_parameter(&p, Gl::LINK_STATUS).as_bool() == Some(true) {

        Ok(p)

    } else {

        Err(gl.get_program_info_log(&p).unwrap_or_default().into())

    }

}

fn float_attrib(gl: &Gl, loc: u32, size: i32, stride: i32, offset: i32, divisor: u32) {

    gl.enable_vertex_attrib_array(loc);

    gl.vertex_attrib_pointer_with_i32(loc, size, Gl::FLOAT, false, stride * 4, offset * 4);

    gl.vertex_attrib_divisor(loc, divisor);

}

impl Renderer {

    pub fn new(gl: Gl) -> Result<Renderer, JsValue> {

        let marks = program(&gl, MARK_VS, MARK_FS)?;

        let lines = program(&gl, LINE_VS, LINE_FS)?;

        let mark_view = gl.get_uniform_location(&marks, "view");

        let line_view = gl.get_uniform_location(&lines, "view");

        // Marks: one shared quad, and one instance per mark.

        let mark_vao = gl.create_vertex_array().ok_or("no vertex array")?;

        gl.bind_vertex_array(Some(&mark_vao));

        let quad = gl.create_buffer().ok_or("no buffer")?;

        gl.bind_buffer(Gl::ARRAY_BUFFER, Some(&quad));

        let corners: [f32; 8] = [-1.0, -1.0, 1.0, -1.0, -1.0, 1.0, 1.0, 1.0];

        // Safety: the view is used at once, before anything can allocate.

        unsafe {

            let view = js_sys::Float32Array::view(&corners);

            gl.buffer_data_with_array_buffer_view(Gl::ARRAY_BUFFER, &view, Gl::STATIC_DRAW);

        }

        float_attrib(&gl, 0, 2, 2, 0, 0);

        let instances = gl.create_buffer().ok_or("no buffer")?;

        gl.bind_buffer(Gl::ARRAY_BUFFER, Some(&instances));

        float_attrib(&gl, 1, 2, MARK_FLOATS, 0, 1);

        float_attrib(&gl, 2, 1, MARK_FLOATS, 2, 1);

        float_attrib(&gl, 3, 1, MARK_FLOATS, 3, 1);

        float_attrib(&gl, 4, 4, MARK_FLOATS, 4, 1);

        // Links: plain lines, two vertices each.

        let line_vao = gl.create_vertex_array().ok_or("no vertex array")?;

        gl.bind_vertex_array(Some(&line_vao));

        let line_buf = gl.create_buffer().ok_or("no buffer")?;

        gl.bind_buffer(Gl::ARRAY_BUFFER, Some(&line_buf));

        float_attrib(&gl, 0, 2, LINE_FLOATS, 0, 0);

        float_attrib(&gl, 1, 4, LINE_FLOATS, 2, 0);

        gl.bind_vertex_array(None);

        gl.enable(Gl::BLEND);

        // Colours are premultiplied.

        gl.blend_func(Gl::ONE, Gl::ONE_MINUS_SRC_ALPHA);

        Ok(Renderer { gl, marks, lines, mark_view, line_view, mark_vao, line_vao, instances, line_buf })

    }

    /// Draw one frame: `instances` and `lines` as sky::Sky lays them out,

    /// in a view of `w` by `h` CSS pixels on a canvas of `pw` by `ph`.

    pub fn draw(&self, w: f32, h: f32, pw: i32, ph: i32, instances: &[f32], lines: &[f32]) {

        let gl = &self.gl;

        gl.viewport(0, 0, pw, ph);

        gl.clear_color(0.0, 0.0, 0.0, 0.0);

        gl.clear(Gl::COLOR_BUFFER_BIT);

        if !lines.is_empty() {

            gl.use_program(Some(&self.lines));

            gl.uniform2f(self.line_view.as_ref(), w, h);

            gl.bind_vertex_array(Some(&self.line_vao));

            gl.bind_buffer(Gl::ARRAY_BUFFER, Some(&self.line_buf));

            // Safety: as above, the view does not outlive this call.

            unsafe {

                let view = js_sys::Float32Array::view(lines);

                gl.buffer_data_with_array_buffer_view(Gl::ARRAY_BUFFER, &view, Gl::STREAM_DRAW);

            }

            gl.draw_arrays(Gl::LINES, 0, lines.len() as i32 / LINE_FLOATS);

        }

        if !instances.is_empty() {

            gl.use_program(Some(&self.marks));

            gl.uniform2f(self.mark_view.as_ref(), w, h);

            gl.bind_vertex_array(Some(&self.mark_vao));

            gl.bind_buffer(Gl::ARRAY_BUFFER, Some(&self.instances));

            unsafe {

                let view = js_sys::Float32Array::view(instances);

                gl.buffer_data_with_array_buffer_view(Gl::ARRAY_BUFFER, &view, Gl::STREAM_DRAW);

            }

            gl.draw_arrays_instanced(Gl::TRIANGLE_STRIP, 0, 4, instances.len() as i32 / MARK_FLOATS);

        }

        gl.bind_vertex_array(None);

    }

}

//! Backdrops (docs/backgrounds.md): the quiet, moving pictures behind

//! some of OxygenHub's pages, in Rust compiled to WebAssembly and drawn

//! with WebGL2. `sky` is the scene and its motion, with no browser in it;

//! `gl` draws it; this module is the browser around them: the frame loop,

//! the cursor, the window's size, the page's colours and when to stop.

pub mod gl;

pub mod sky;

use sky::{Colours, Event, Kind, Repo, Sky};

use std::cell::RefCell;

use std::rc::Rc;

use wasm_bindgen::prelude::*;

use wasm_bindgen::JsCast;

use web_sys::{HtmlCanvasElement, HtmlElement, WebGl2RenderingContext, Window};

/// The highest device pixel ratio drawn at: sharp enough, and cheap.

const MAX_DPR: f64 = 1.5;

/// After this long without input a moving backdrop draws its last frame

/// and stops until the next movement (§6).

const STOP_AFTER_S: f64 = 120.0;

/// A still cursor drops the frame rate to half after this long.

const HALF_RATE_AFTER_S: f64 = 3.0;

struct Engine {

    window: Window,

    canvas: HtmlCanvasElement,

    renderer: gl::Renderer,

    sky: Sky,

    colours: Colours,

    colours_at: f64,

    probe: HtmlElement,

    label: HtmlElement,

    label_text: String,

    inst: Vec<f32>,

    lines: Vec<f32>,

    last: Option<f64>,

    frame: u64,

    running: bool,

    input_at: f64,

    pw: i32,

    ph: i32,

}

type Frame = Rc<RefCell<Option<Closure<dyn FnMut(f64)>>>>;

impl Engine {

    fn now(&self) -> f64 {

        self.window.performance().map(|p| p.now()).unwrap_or(0.0)

    }

    /// Fit the canvas to the window.

    fn fit(&mut self) {

        let w = self.window.inner_width().ok().and_then(|v| v.as_f64()).unwrap_or(0.0);

        let h = self.window.inner_height().ok().and_then(|v| v.as_f64()).unwrap_or(0.0);

        let dpr = self.window.device_pixel_ratio().clamp(1.0, MAX_DPR);

        self.pw = (w * dpr).round() as i32;

        self.ph = (h * dpr).round() as i32;

        self.canvas.set_width(self.pw.max(1) as u32);

        self.canvas.set_height(self.ph.max(1) as u32);

        self.sky.resize(w as f32, h as f32);

    }

    /// The page's backdrop tokens, as the browser computes them, so a

    /// theme switch shows within a second.

    fn read_colours(&mut self) {

        let read = |token: &str, fallback: sky::Rgba| -> sky::Rgba {

            let _ = self.probe.style().set_property("color", &format!("var({token})"));

            self.window

                .get_computed_style(&self.probe)

                .ok()

                .flatten()

                .and_then(|s| s.get_property_value("color").ok())

                .and_then(|c| sky::parse_colour(&c))

                .unwrap_or(fallback)

        };

        self.colours = Colours {

            mark: read("--bd-mark", [0.5, 0.5, 0.55, 0.16]),

            lit: read("--bd-lit", [0.04, 0.41, 0.85, 0.7]),

            link: read("--bd-link", [0.04, 0.41, 0.85, 0.22]),

        };

    }

    /// One animation frame at time `t`; whether another is wanted.

    fn tick(&mut self, t: f64) -> bool {

        if self.window.document().is_some_and(|d| d.hidden()) {

            self.last = None;

            return false;

        }

        let idle = (t - self.input_at) / 1000.0;

        self.frame += 1;

        if !self.sky.still && idle > HALF_RATE_AFTER_S && self.frame % 2 == 1 {

            return true;

        }

        let dt = self.last.map(|l| ((t - l) / 1000.0) as f32).unwrap_or(0.0);

        self.last = Some(t);

        if t - self.colours_at > 1000.0 {

            self.read_colours();

            self.colours_at = t;

        }

        self.sky.step(dt);

        self.sky.instances(&self.colours, &mut self.inst);

        self.sky.links(&self.colours, &mut self.lines);

        self.renderer.draw(self.sky.w, self.sky.h, self.pw, self.ph, &self.inst, &self.lines);

        self.show_label();

        if self.sky.still {

            self.sky.busy()

        } else {

            idle < STOP_AFTER_S || self.sky.busy()

        }

    }

    /// The name beside a resting cursor (§4): faded in and out by CSS.

    fn show_label(&mut self) {

        let next = self.sky.label().map(|(name, x, y)| (name.to_string(), x, y));

        let style = self.label.style();

        match next {

            Some((name, x, y)) => {

                if name != self.label_text {

                    self.label.set_text_content(Some(&name));

                    self.label_text = name;

                }

                let _ = style.set_property("left", &format!("{}px", (x + 12.0) as i32));

                let _ = style.set_property("top", &format!("{}px", (y - 8.0) as i32));

                let _ = style.set_property("opacity", "1");

            }

            None => {

                let _ = style.set_property("opacity", "0");

            }

        }

    }

}

/// Ask for a frame unless the loop is already running.

fn wake(engine: &Rc<RefCell<Engine>>, frame: &Frame) {

    let mut e = engine.borrow_mut();

    if e.running {

        return;

    }

    e.running = true;

    if let Some(f) = frame.borrow().as_ref() {

        let _ = e.window.request_animation_frame(f.as_ref().unchecked_ref());

    }

}

fn get(v: &JsValue, key: &str) -> JsValue {

    js_sys::Reflect::get(v, &JsValue::from_str(key)).unwrap_or(JsValue::UNDEFINED)

}

/// The page's data (§5): `{now, repos: [name], events: [[repo, kind, at_ms]]}`.

fn read_data(data: &JsValue) -> (Vec<Repo>, Vec<Event>) {

    let now = get(data, "now").as_f64().unwrap_or(0.0);

    let repos: Vec<Repo> =

        js_sys::Array::from(&get(data, "repos")).iter().filter_map(|v| v.as_string()).map(|name| Repo { name }).collect();

    let events: Vec<Event> = js_sys::Array::from(&get(data, "events"))

        .iter()

        .filter_map(|v| {

            let e = js_sys::Array::from(&v);

            let repo = e.get(0).as_f64()? as usize;

            let kind = Kind::from_code(e.get(1).as_f64()? as u32);

            let at = e.get(2).as_f64()?;

            Some(Event { repo, kind, age_days: ((now - at) / 86_400_000.0).max(0.0) as f32 })

        })

        .collect();

    (repos, events)

}

/// Start the dashboard's sky on `canvas` with the page's `data`. `still`

/// is the viewer's choice of a still backdrop; reduced motion asks for

/// one too. Without WebGL2 there is no backdrop, and nothing breaks.

#[wasm_bindgen]

pub fn start(canvas: HtmlCanvasElement, data: JsValue, still: bool) -> Result<(), JsValue> {

    let window = web_sys::window().ok_or("no window")?;

    let document = window.document().ok_or("no document")?;

    let reduced = window.match_media("(prefers-reduced-motion: reduce)").ok().flatten().is_some_and(|m| m.matches());

    let still = still || reduced;

    let options = js_sys::Object::new();

    js_sys::Reflect::set(&options, &"alpha".into(), &true.into())?;

    js_sys::Reflect::set(&options, &"premultipliedAlpha".into(), &true.into())?;

    js_sys::Reflect::set(&options, &"antialias".into(), &false.into())?;

    js_sys::Reflect::set(&options, &"powerPreference".into(), &"low-power".into())?;

    let gl: WebGl2RenderingContext = canvas.get_context_with_context_options("webgl2", &options)?.ok_or("no WebGL2")?.dyn_into()?;

    let renderer = gl::Renderer::new(gl)?;

    let body = document.body().ok_or("no body")?;

    let probe: HtmlElement = document.create_element("span")?.dyn_into()?;

    probe.set_attribute("style", "position:fixed;visibility:hidden;pointer-events:none")?;

    probe.set_attribute("aria-hidden", "true")?;

    body.append_child(&probe)?;

    let label: HtmlElement = document.create_element("div")?.dyn_into()?;

    label.set_class_name("bd-label");

    label.set_attribute("aria-hidden", "true")?;

    body.append_child(&label)?;

    let (repos, events) = read_data(&data);

    let sky = Sky::new(&repos, &events, 0.0, 0.0, still);

    let colours = Colours { mark: [0.0; 4], lit: [0.0; 4], link: [0.0; 4] };

    let engine = Rc::new(RefCell::new(Engine {

        window: window.clone(),

        canvas,

        renderer,

        sky,

        colours,

        colours_at: f64::NEG_INFINITY,

        probe,

        label,

        label_text: String::new(),

        inst: Vec::new(),

        lines: Vec::new(),

        last: None,

        frame: 0,

        running: false,

        input_at: 0.0,

        pw: 0,

        ph: 0,

    }));

    {

        let mut e = engine.borrow_mut();

        e.fit();

        e.input_at = e.now();

    }

    // The frame loop: each frame asks for the next while it is wanted.

    let frame: Frame = Rc::new(RefCell::new(None));

    {

        let (engine, again) = (engine.clone(), frame.clone());

        *frame.borrow_mut() = Some(Closure::new(move |t: f64| {

            let more = engine.borrow_mut().tick(t);

            let mut e = engine.borrow_mut();

            if more {

                if let Some(f) = again.borrow().as_ref() {

                    let _ = e.window.request_animation_frame(f.as_ref().unchecked_ref());

                }

            } else {

                e.running = false;

            }

        }));

    }

    // The cursor lights marks; it never moves them.

    {

        let (engine, frame) = (engine.clone(), frame.clone());

        let moved = Closure::<dyn FnMut(web_sys::MouseEvent)>::new(move |ev: web_sys::MouseEvent| {

            {

                let mut e = engine.borrow_mut();

                e.sky.point(Some((ev.client_x() as f32, ev.client_y() as f32)));

                e.input_at = e.now();

            }

            wake(&engine, &frame);

        });

        window.add_event_listener_with_callback("mousemove", moved.as_ref().unchecked_ref())?;

        moved.forget();

    }

    {

        let (engine, frame) = (engine.clone(), frame.clone());

        let left = Closure::<dyn FnMut(web_sys::MouseEvent)>::new(move |ev: web_sys::MouseEvent| {

            if ev.related_target().is_none() {

                engine.borrow_mut().sky.point(None);

                wake(&engine, &frame);