@oidoid/void 0.1.7 → 0.1.8

package/dist/src/input/input.test.js

@@ -0,0 +1,1146 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { afterEach, beforeEach, test } from 'node:test';
+import { Cam } from "../graphics/cam.js";
+import { assert } from "../test/assert.js";
+import { DevicePixelRatioMock } from "../test/device-pixel-ratio-mock.js";
+import { SecureContextMock } from "../test/secure-context-mock.js";
+import { TestElement } from "../test/test-element.js";
+import { KeyTestEvent, PointerTestEvent, WheelTestEvent } from "../test/test-event.js";
+import { Input } from "./input.js";
+beforeEach(() => {
+    globalThis.addEventListener = () => { };
+    globalThis.removeEventListener = () => { };
+});
+afterEach(() => {
+    delete globalThis.addEventListener;
+    delete globalThis.removeEventListener;
+});
+test('init', async (ctx) => {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const secureContext = __addDisposableResource(env_1, new SecureContextMock(), false);
+        secureContext.secure = false;
+        const dpr = __addDisposableResource(env_1, new DevicePixelRatioMock(), false);
+        dpr.ratio = 1;
+        const target = TestElement();
+        const input = __addDisposableResource(env_1, DefaultInput(DefaultCam(), target).register('add'), false);
+        await ctx.test('no update', () => {
+            assert(input.on, []);
+            assert(input.handled, false);
+            assert(input.invalid, false);
+            assert(input.gestured, false);
+            assert(input.held, false);
+            assert(input.started, false);
+            assertButton(input, 'U', 'Off');
+            assertCombo(input, [['U']], 'Unequal');
+            assert(input.point, undefined);
+            assert(input.wheel, undefined);
+        });
+        await ctx.test('no change after update', () => {
+            input.update(16);
+            assert(input.on, []);
+            assert(input.handled, false);
+            assert(input.invalid, false);
+            assert(input.gestured, false);
+            assert(input.held, false);
+            assert(input.started, false);
+            assertButton(input, 'U', 'Off');
+            assertCombo(input, [['U']], 'Unequal');
+            assert(input.point, undefined);
+            assert(input.wheel, undefined);
+        });
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        __disposeResources(env_1);
+    }
+});
+test('held off', () => {
+    const env_2 = { stack: [], error: void 0, hasError: false };
+    try {
+        const secureContext = __addDisposableResource(env_2, new SecureContextMock(), false);
+        secureContext.secure = false;
+        const dpr = __addDisposableResource(env_2, new DevicePixelRatioMock(), false);
+        dpr.ratio = 1;
+        const target = TestElement();
+        const input = __addDisposableResource(env_2, DefaultInput(DefaultCam(), target).register('add'), false);
+        input.update((input.comboMaxIntervalMillis + 1));
+        assert(input.on, []);
+        assert(input.invalid, false);
+        assert(input.gestured, false);
+        assert(input.held, true);
+        assert(input.started, false);
+        assertButton(input, 'U', 'Off');
+        assertCombo(input, [['U']], 'Unequal');
+    }
+    catch (e_2) {
+        env_2.error = e_2;
+        env_2.hasError = true;
+    }
+    finally {
+        __disposeResources(env_2);
+    }
+});
+test('pressed buttons', async (ctx) => {
+    const env_3 = { stack: [], error: void 0, hasError: false };
+    try {
+        const secureContext = __addDisposableResource(env_3, new SecureContextMock(), false);
+        secureContext.secure = false;
+        const dpr = __addDisposableResource(env_3, new DevicePixelRatioMock(), false);
+        dpr.ratio = 1;
+        const target = TestElement();
+        const input = __addDisposableResource(env_3, DefaultInput(DefaultCam(), target).register('add'), false);
+        await ctx.test('pressed are active and triggered', () => {
+            target.dispatchEvent(KeyTestEvent('keydown', { code: 'ArrowUp' }));
+            input.update(16);
+            assert(input.on, ['U']);
+            assert(input.invalid, true);
+            assert(input.gestured, true);
+            assert(input.held, false);
+            assert(input.started, true);
+            assertButton(input, 'U', 'On', 'Start');
+            assertCombo(input, [['U']], 'Equal', 'Start');
+            assert(input.combo, [['U']]);
+        });
+        await ctx.test('unpressed are inactive and not triggered', () => {
+            assertButton(input, 'D', 'Off');
+            assertCombo(input, [['D']], 'Unequal');
+            assertCombo(input, [['D', 'U']], 'Unequal');
+            assertCombo(input, [['D'], ['U']], 'Unequal');
+        });
+        await ctx.test('pressed are triggered for one frame only', () => {
+            input.update(16);
+            assert(input.on, ['U']);
+            assert(input.invalid, false);
+            assert(input.gestured, true);
+            assert(input.held, false);
+            assert(input.started, false);
+            assertButton(input, 'U', 'On');
+            assertCombo(input, [['U']], 'Equal');
+            assert(input.combo, [['U']]);
+        });
+        await ctx.test('released are off and triggered', () => {
+            target.dispatchEvent(KeyTestEvent('keyup', { code: 'ArrowUp' }));
+            input.update(16);
+            assert(input.on, []);
+            assert(input.invalid, true);
+            assert(input.gestured, true);
+            assert(input.held, false);
+            assert(input.started, true);
+            assertButton(input, 'U', 'Off', 'Start');
+            assertCombo(input, [['U']], 'Equal');
+            assert(input.combo, [['U']]);
+        });
+        await ctx.test('pressed are held on', () => {
+            target.dispatchEvent(KeyTestEvent('keydown', { code: 'ArrowUp' }));
+            input.update(input.minHeldMillis);
+            assert(input.on, ['U']);
+            assert(input.invalid, true);
+            assert(input.gestured, true);
+            assert(input.held, true);
+            assert(input.started, true);
+            assertButton(input, 'U', 'On', 'Start');
+            assertCombo(input, [['U']], 'EndsWith', 'Start');
+            assertCombo(input, [['U'], ['U']], 'Equal', 'Start');
+            assert(input.combo, [['U'], ['U']]);
+        });
+        await ctx.test('expired allow current combo to stay on but discontinue next', () => {
+            input.update((input.comboMaxIntervalMillis + 1));
+            assert(input.on, ['U']);
+            assert(input.invalid, false);
+            assert(input.gestured, true);
+            assert(input.held, true);
+            assert(input.started, false);
+            assertButton(input, 'U', 'On');
+            assertCombo(input, [['U']], 'EndsWith');
+            assertCombo(input, [['U'], ['U']], 'Equal');
+            assert(input.combo, [['U'], ['U']]);
+        });
+        await ctx.test('expired start new combo', () => {
+            target.dispatchEvent(KeyTestEvent('keyup', { code: 'ArrowUp' }));
+            input.update(16);
+            target.dispatchEvent(KeyTestEvent('keydown', { code: 'ArrowUp' }));
+            input.update(16);
+            assert(input.on, ['U']);
+            assert(input.invalid, true);
+            assert(input.gestured, true);
+            assert(input.held, false);
+            assert(input.started, true);
+            assertButton(input, 'U', 'On', 'Start');
+            assertCombo(input, [['U']], 'Equal', 'Start');
+            assertCombo(input, [['U'], ['U']], 'Unequal');
+            assert(input.combo, [['U']]);
+        });
+    }
+    catch (e_3) {
+        env_3.error = e_3;
+        env_3.hasError = true;
+    }
+    finally {
+        __disposeResources(env_3);
+    }
+});
+test('combos require gaps between presses', async (ctx) => {
+    const env_4 = { stack: [], error: void 0, hasError: false };
+    try {
+        const secureContext = __addDisposableResource(env_4, new SecureContextMock(), false);
+        secureContext.secure = false;
+        const dpr = __addDisposableResource(env_4, new DevicePixelRatioMock(), false);
+        dpr.ratio = 1;
+        const target = TestElement();
+        const input = __addDisposableResource(env_4, DefaultInput(DefaultCam(), target).register('add'), false);
+        await ctx.test('Up', () => {
+            target.dispatchEvent(KeyTestEvent('keydown', { code: 'ArrowUp' }));
+            input.update(16);
+            assert(input.on, ['U']);
+            assert(input.invalid, true);
+            assert(input.gestured, true);
+            assert(input.held, false);
+            assert(input.started, true);
+            assertButton(input, 'U', 'On', 'Start');
+            assertButton(input, 'D', 'Off');
+            assertCombo(input, [['U']], 'Equal', 'Start');
+            assertCombo(input, [['U'], ['D']], 'Unequal');
+            assertCombo(input, [['U'], ['D'], ['U']], 'Unequal');
+        });
+        await ctx.test('Up, Down', () => {
+            target.dispatchEvent(KeyTestEvent('keyup', { code: 'ArrowUp' }));
+            input.update(16);
+            target.dispatchEvent(KeyTestEvent('keydown', { code: 'ArrowDown' }));
+            input.update(16);
+            assert(input.on, ['D']);
+            assert(input.invalid, true);
+            assert(input.gestured, true);
+            assert(input.held, false);
+            assert(input.started, true);
+            assertButton(input, 'U', 'Off');
+            assertButton(input, 'D', 'On', 'Start');
+            assertCombo(input, [['U']], 'Unequal');
+            assertCombo(input, [['U'], ['D']], 'Equal', 'Start');
+            assertCombo(input, [['U'], ['D'], ['U']], 'Unequal');
+        });
+        await ctx.test('Up, Down, Up', () => {
+            target.dispatchEvent(KeyTestEvent('keyup', { code: 'ArrowDown' }));
+            target.dispatchEvent(KeyTestEvent('keydown', { code: 'ArrowUp' }));
+            input.update(16);
+            assert(input.on, ['U']);
+            assert(input.invalid, true);
+            assert(input.gestured, true);
+            assert(input.held, false);
+            assert(input.started, true);
+            assertButton(input, 'U', 'On', 'Start');
+            assertButton(input, 'D', 'Off', 'Start');
+            assertCombo(input, [['U']], 'Equal', 'Start');
+            assertCombo(input, [['U'], ['D']], 'Unequal');
+            assertCombo(input, [['U'], ['D'], ['U']], 'Unequal');
+        });
+    }
+    catch (e_4) {
+        env_4.error = e_4;
+        env_4.hasError = true;
+    }
+    finally {
+        __disposeResources(env_4);
+    }
+});
+test('around-the-world combo', () => {
+    const env_5 = { stack: [], error: void 0, hasError: false };
+    try {
+        const secureContext = __addDisposableResource(env_5, new SecureContextMock(), false);
+        secureContext.secure = false;
+        const dpr = __addDisposableResource(env_5, new DevicePixelRatioMock(), false);
+        dpr.ratio = 1;
+        const target = TestElement();
+        const input = __addDisposableResource(env_5, DefaultInput(DefaultCam(), target).register('add'), false);
+        const sets = [
+            ['ArrowUp'],
+            ['ArrowUp', 'ArrowRight'],
+            ['ArrowRight'],
+            ['ArrowRight', 'ArrowDown'],
+            ['ArrowDown'],
+            ['ArrowDown', 'ArrowLeft'],
+            ['ArrowLeft'],
+            ['ArrowUp', 'ArrowLeft']
+        ];
+        for (const set of sets) {
+            input.update(16);
+            for (const code of set)
+                target.dispatchEvent(KeyTestEvent('keydown', { code }));
+            input.update(16);
+            for (const code of set)
+                target.dispatchEvent(KeyTestEvent('keyup', { code }));
+        }
+        assertCombo(input, [
+            ['U'],
+            ['U', 'R'],
+            ['R'],
+            ['D', 'R'],
+            ['D'],
+            ['D', 'L'],
+            ['L'],
+            ['U', 'L']
+        ], 'Equal', 'Start');
+    }
+    catch (e_5) {
+        env_5.error = e_5;
+        env_5.hasError = true;
+    }
+    finally {
+        __disposeResources(env_5);
+    }
+});
+test('Up, Up, Down, Down, Left', async (ctx) => {
+    const env_6 = { stack: [], error: void 0, hasError: false };
+    try {
+        const secureContext = __addDisposableResource(env_6, new SecureContextMock(), false);
+        secureContext.secure = false;
+        const dpr = __addDisposableResource(env_6, new DevicePixelRatioMock(), false);
+        dpr.ratio = 1;
+        const target = TestElement();
+        const input = __addDisposableResource(env_6, DefaultInput(DefaultCam(), target).register('add'), false);
+        await ctx.test('Up', () => {
+            target.dispatchEvent(KeyTestEvent('keydown', { code: 'ArrowUp' }));
+            input.update(16);
+            assert(input.on, ['U']);
+            assert(input.invalid, true);
+            assert(input.gestured, true);
+            assert(input.held, false);
+            assert(input.started, true);
+            assertButton(input, 'U', 'On', 'Start');
+            assertButton(input, 'D', 'Off');
+            assertButton(input, 'L', 'Off');
+            assertCombo(input, [['U']], 'Equal', 'Start');
+            assertCombo(input, [['U'], ['U']], 'Unequal');
+            assertCombo(input, [['U'], ['U'], ['D']], 'Unequal');
+            assertCombo(input, [['U'], ['U'], ['D'], ['D']], 'Unequal');
+            assertCombo(input, [['U'], ['U'], ['D'], ['D'], ['L']], 'Unequal');
+        });
+        await ctx.test('Up, Up', () => {
+            target.dispatchEvent(KeyTestEvent('keyup', { code: 'ArrowUp' }));
+            input.update(16);
+            target.dispatchEvent(KeyTestEvent('keydown', { code: 'ArrowUp' }));
+            input.update(16);
+            assert(input.on, ['U']);
+            assert(input.invalid, true);
+            assert(input.gestured, true);
+            assert(input.held, false);
+            assert(input.started, true);
+            assertButton(input, 'U', 'On', 'Start');
+            assertButton(input, 'D', 'Off');
+            assertButton(input, 'L', 'Off');
+            assertCombo(input, [['U']], 'EndsWith', 'Start');
+            assertCombo(input, [['U'], ['U']], 'Equal', 'Start');
+            assertCombo(input, [['U'], ['U'], ['D']], 'Unequal');
+            assertCombo(input, [['U'], ['U'], ['D'], ['D']], 'Unequal');
+            assertCombo(input, [['U'], ['U'], ['D'], ['D'], ['L']], 'Unequal');
+        });
+        await ctx.test('Up, Up, Down', () => {
+            target.dispatchEvent(KeyTestEvent('keyup', { code: 'ArrowUp' }));
+            input.update(16);
+            target.dispatchEvent(KeyTestEvent('keydown', { code: 'ArrowDown' }));
+            input.update(16);
+            assert(input.on, ['D']);
+            assert(input.invalid, true);
+            assert(input.gestured, true);
+            assert(input.held, false);
+            assert(input.started, true);
+            assertButton(input, 'U', 'Off');
+            assertButton(input, 'D', 'On', 'Start');
+            assertButton(input, 'L', 'Off');
+            assertCombo(input, [['U']], 'Unequal');
+            assertCombo(input, [['U'], ['U']], 'Unequal');
+            assertCombo(input, [['U'], ['U'], ['D']], 'Equal', 'Start');
+            assertCombo(input, [['U'], ['U'], ['D'], ['D']], 'Unequal');
+            assertCombo(input, [['U'], ['U'], ['D'], ['D'], ['L']], 'Unequal');
+        });
+        await ctx.test('Up, Up, Down, Down', () => {
+            target.dispatchEvent(KeyTestEvent('keyup', { code: 'ArrowDown' }));
+            input.update(16);
+            target.dispatchEvent(KeyTestEvent('keydown', { code: 'ArrowDown' }));
+            input.update(16);
+            assert(input.on, ['D']);
+            assert(input.invalid, true);
+            assert(input.gestured, true);
+            assert(input.held, false);
+            assert(input.started, true);
+            assertButton(input, 'U', 'Off');
+            assertButton(input, 'D', 'On', 'Start');
+            assertButton(input, 'L', 'Off');
+            assertCombo(input, [['U']], 'Unequal');
+            assertCombo(input, [['U'], ['U']], 'Unequal');
+            assertCombo(input, [['U'], ['U'], ['D']], 'Unequal');
+            assertCombo(input, [['U'], ['U'], ['D'], ['D']], 'Equal', 'Start');
+            assertCombo(input, [['U'], ['U'], ['D'], ['D'], ['L']], 'Unequal');
+        });
+        await ctx.test('Up, Up, Down, Down, Left', () => {
+            target.dispatchEvent(KeyTestEvent('keyup', { code: 'ArrowDown' }));
+            input.update(16);
+            target.dispatchEvent(KeyTestEvent('keydown', { code: 'ArrowLeft' }));
+            input.update(16);
+            assert(input.on, ['L']);
+            assert(input.invalid, true);
+            assert(input.gestured, true);
+            assert(input.held, false);
+            assert(input.started, true);
+            assertButton(input, 'U', 'Off');
+            assertButton(input, 'D', 'Off');
+            assertButton(input, 'L', 'On', 'Start');
+            assertCombo(input, [['U']], 'Unequal');
+            assertCombo(input, [['U'], ['U']], 'Unequal');
+            assertCombo(input, [['U'], ['U'], ['D']], 'Unequal');
+            assertCombo(input, [['U'], ['U'], ['D'], ['D']], 'Unequal');
+            assertCombo(input, [['U'], ['U'], ['D'], ['D'], ['L']], 'Equal', 'Start');
+        });
+    }
+    catch (e_6) {
+        env_6.error = e_6;
+        env_6.hasError = true;
+    }
+    finally {
+        __disposeResources(env_6);
+    }
+});
+test('held combos stay active past expiry', async (ctx) => {
+    const env_7 = { stack: [], error: void 0, hasError: false };
+    try {
+        const secureContext = __addDisposableResource(env_7, new SecureContextMock(), false);
+        secureContext.secure = false;
+        const dpr = __addDisposableResource(env_7, new DevicePixelRatioMock(), false);
+        dpr.ratio = 1;
+        const target = TestElement();
+        const input = __addDisposableResource(env_7, DefaultInput(DefaultCam(), target).register('add'), false);
+        await ctx.test('Up, Up', () => {
+            target.dispatchEvent(KeyTestEvent('keydown', { code: 'ArrowUp' }));
+            input.update(16);
+            target.dispatchEvent(KeyTestEvent('keyup', { code: 'ArrowUp' }));
+            input.update(16);
+            target.dispatchEvent(KeyTestEvent('keydown', { code: 'ArrowUp' }));
+            input.update(16);
+            assert(input.on, ['U']);
+            assert(input.invalid, true);
+            assert(input.gestured, true);
+            assert(input.held, false);
+            assert(input.started, true);
+            assertButton(input, 'U', 'On', 'Start');
+            assertCombo(input, [['U']], 'EndsWith', 'Start');
+            assertCombo(input, [['U'], ['U']], 'Equal', 'Start');
+        });
+        await ctx.test('held', () => {
+            input.update((input.comboMaxIntervalMillis + 1));
+            assert(input.on, ['U']);
+            assert(input.invalid, false);
+            assert(input.gestured, true);
+            assert(input.held, true);
+            assert(input.started, false);
+            assertButton(input, 'U', 'On');
+            assertCombo(input, [['U']], 'EndsWith');
+            assertCombo(input, [['U'], ['U']], 'Equal');
+        });
+    }
+    catch (e_7) {
+        env_7.error = e_7;
+        env_7.hasError = true;
+    }
+    finally {
+        __disposeResources(env_7);
+    }
+});
+test('combo sequences can have multiple buttons', async (ctx) => {
+    const env_8 = { stack: [], error: void 0, hasError: false };
+    try {
+        const secureContext = __addDisposableResource(env_8, new SecureContextMock(), false);
+        secureContext.secure = false;
+        const dpr = __addDisposableResource(env_8, new DevicePixelRatioMock(), false);
+        dpr.ratio = 1;
+        const target = TestElement();
+        const input = __addDisposableResource(env_8, DefaultInput(DefaultCam(), target).register('add'), false);
+        await ctx.test('Up Left', () => {
+            target.dispatchEvent(KeyTestEvent('keydown', { code: 'ArrowUp' }));
+            target.dispatchEvent(KeyTestEvent('keydown', { code: 'ArrowLeft' }));
+            input.update(16);
+            assert(input.on, ['L', 'U']);
+            assert(input.invalid, true);
+            assert(input.gestured, true);
+            assert(input.held, false);
+            assert(input.started, true);
+            assertButton(input, 'U', 'On', 'Start');
+            assertButton(input, 'D', 'Off');
+            assertButton(input, 'L', 'On', 'Start');
+            assertButton(input, 'R', 'Off');
+            assertCombo(input, [['U']], 'Unequal');
+            assertCombo(input, [['D']], 'Unequal');
+            assertCombo(input, [['L']], 'Unequal');
+            assertCombo(input, [['R']], 'Unequal');
+            assertCombo(input, [['U', 'L']], 'Equal', 'Start');
+            assertCombo(input, [['D', 'R']], 'Unequal');
+            assertCombo(input, [['U', 'L'], ['D', 'R']], // biome-ignore format:;
+            'Unequal');
+        });
+        await ctx.test('Up Left, Down Right', () => {
+            target.dispatchEvent(KeyTestEvent('keyup', { code: 'ArrowUp' }));
+            target.dispatchEvent(KeyTestEvent('keyup', { code: 'ArrowLeft' }));
+            input.update(16);
+            target.dispatchEvent(KeyTestEvent('keydown', { code: 'ArrowDown' }));
+            target.dispatchEvent(KeyTestEvent('keydown', { code: 'ArrowRight' }));
+            input.update(16);
+            assert(input.on, ['D', 'R']);
+            assert(input.invalid, true);
+            assert(input.gestured, true);
+            assert(input.held, false);
+            assert(input.started, true);
+            assertButton(input, 'U', 'Off');
+            assertButton(input, 'D', 'On', 'Start');
+            assertButton(input, 'L', 'Off');
+            assertButton(input, 'R', 'On', 'Start');
+            assertCombo(input, [['U']], 'Unequal');
+            assertCombo(input, [['D']], 'Unequal');
+            assertCombo(input, [['L']], 'Unequal');
+            assertCombo(input, [['R']], 'Unequal');
+            assertCombo(input, [['U', 'L']], 'Unequal');
+            assertCombo(input, [['D', 'R']], 'EndsWith', 'Start');
+            assertCombo(input, [['U', 'L'], ['D', 'R']], // biome-ignore format:;
+            'Equal', 'Start');
+        });
+    }
+    catch (e_8) {
+        env_8.error = e_8;
+        env_8.hasError = true;
+    }
+    finally {
+        __disposeResources(env_8);
+    }
+});
+test('handled', () => {
+    const env_9 = { stack: [], error: void 0, hasError: false };
+    try {
+        const secureContext = __addDisposableResource(env_9, new SecureContextMock(), false);
+        secureContext.secure = false;
+        const dpr = __addDisposableResource(env_9, new DevicePixelRatioMock(), false);
+        dpr.ratio = 1;
+        const target = TestElement();
+        const input = __addDisposableResource(env_9, DefaultInput(DefaultCam(), target).register('add'), false);
+        assert(input.invalid, false);
+        assert(input.gestured, false);
+        assert(input.held, false);
+        assert(input.started, false);
+        assertButton(input, 'U', 'Off');
+        assertCombo(input, [['U']], 'Unequal');
+        input.handled = true;
+        assert(input.on, []);
+        assert(input.invalid, false);
+        assert(input.gestured, false);
+        assert(input.held, false);
+        assert(input.started, false);
+        assert(input.isAnyOn('U'), false);
+        assert(input.isAnyOnStart('U'), false);
+        assert(input.isOn('U'), false);
+        assert(input.isOnStart('U'), false);
+        assert(input.isOff('U'), false);
+        assert(input.isOffStart('U'), false);
+        assert(input.isComboEndsWith(['U']), false);
+        assert(input.isComboEndsWithStart(['U']), false);
+        assert(input.isCombo(['U']), false);
+        assert(input.isComboStart(['U']), false);
+        target.dispatchEvent(KeyTestEvent('keydown', { code: 'ArrowUp' }));
+        input.update(input.minHeldMillis);
+        assert(input.on, ['U']);
+        assert(input.invalid, true);
+        assert(input.gestured, true);
+        assert(input.held, true);
+        assert(input.started, true);
+        assertButton(input, 'U', 'On', 'Start');
+        assertCombo(input, [['U']], 'Equal', 'Start');
+        input.handled = true;
+        assert(input.invalid, true);
+        assert(input.gestured, true);
+        assert(input.held, false);
+        assert(input.started, false);
+        assert(input.isAnyOn('U'), false);
+        assert(input.isAnyOnStart('U'), false);
+        assert(input.isOn('U'), false);
+        assert(input.isOnStart('U'), false);
+        assert(input.isOff('U'), false);
+        assert(input.isOffStart('U'), false);
+        assert(input.isComboEndsWith(['U']), false);
+        assert(input.isComboEndsWithStart(['U']), false);
+        assert(input.isCombo(['U']), false);
+        assert(input.isComboStart(['U']), false);
+    }
+    catch (e_9) {
+        env_9.error = e_9;
+        env_9.hasError = true;
+    }
+    finally {
+        __disposeResources(env_9);
+    }
+});
+test('isAnyOn() / isAnyOnStart()', () => {
+    const env_10 = { stack: [], error: void 0, hasError: false };
+    try {
+        const secureContext = __addDisposableResource(env_10, new SecureContextMock(), false);
+        secureContext.secure = false;
+        const dpr = __addDisposableResource(env_10, new DevicePixelRatioMock(), false);
+        dpr.ratio = 1;
+        const target = TestElement();
+        const input = __addDisposableResource(env_10, DefaultInput(DefaultCam(), target).register('add'), false);
+        target.dispatchEvent(KeyTestEvent('keydown', { code: 'ArrowUp' }));
+        input.update(16);
+        assert(input.started, true);
+        assert(input.isAnyOn('U'), true);
+        assert(input.isAnyOnStart('U'), true);
+        assert(input.isAnyOn('U', 'D'), true);
+        assert(input.isAnyOnStart('U', 'D'), true);
+        assert(input.isAnyOn('D'), false);
+        assert(input.isAnyOnStart('D'), false);
+        assert(input.isAnyOn('D', 'R'), false);
+        assert(input.isAnyOnStart('D', 'R'), false);
+    }
+    catch (e_10) {
+        env_10.error = e_10;
+        env_10.hasError = true;
+    }
+    finally {
+        __disposeResources(env_10);
+    }
+});
+test('started', () => {
+    const env_11 = { stack: [], error: void 0, hasError: false };
+    try {
+        const secureContext = __addDisposableResource(env_11, new SecureContextMock(), false);
+        secureContext.secure = false;
+        const dpr = __addDisposableResource(env_11, new DevicePixelRatioMock(), false);
+        dpr.ratio = 1;
+        const target = TestElement();
+        const input = __addDisposableResource(env_11, DefaultInput(DefaultCam(), target).register('add'), false);
+        assert(input.started, false);
+        target.dispatchEvent(KeyTestEvent('keydown', { code: 'ArrowUp' }));
+        input.update(16);
+        assert(input.started, true);
+        input.update(16);
+        assert(input.started, false);
+        target.dispatchEvent(KeyTestEvent('keyup', { code: 'ArrowUp' }));
+        input.update(16);
+        assert(input.started, true);
+        input.update(16);
+        assert(input.started, false);
+    }
+    catch (e_11) {
+        env_11.error = e_11;
+        env_11.hasError = true;
+    }
+    finally {
+        __disposeResources(env_11);
+    }
+});
+test('isOnStart() requires the tested button to change state', () => {
+    const env_12 = { stack: [], error: void 0, hasError: false };
+    try {
+        const secureContext = __addDisposableResource(env_12, new SecureContextMock(), false);
+        secureContext.secure = false;
+        const dpr = __addDisposableResource(env_12, new DevicePixelRatioMock(), false);
+        dpr.ratio = 1;
+        const target = TestElement();
+        const input = __addDisposableResource(env_12, DefaultInput(DefaultCam(), target).register('add'), false);
+        target.dispatchEvent(KeyTestEvent('keydown', { code: 'ArrowUp' }));
+        input.update(16);
+        assert(input.isOnStart('U'), true);
+        target.dispatchEvent(KeyTestEvent('keydown', { code: 'ArrowRight' }));
+        input.update(16);
+        assert(input.isOnStart('U'), false);
+        target.dispatchEvent(KeyTestEvent('keyup', { code: 'ArrowRight' }));
+        input.update(16);
+        assert(input.isOnStart('U'), false);
+        target.dispatchEvent(KeyTestEvent('keyup', { code: 'ArrowUp' }));
+        input.update(16);
+        assert(input.isOnStart('U'), false);
+        target.dispatchEvent(KeyTestEvent('keydown', { code: 'ArrowUp' }));
+        input.update(16);
+        assert(input.isOnStart('U'), true);
+    }
+    catch (e_12) {
+        env_12.error = e_12;
+        env_12.hasError = true;
+    }
+    finally {
+        __disposeResources(env_12);
+    }
+});
+test('pointer movements update position', async (ctx) => {
+    const env_13 = { stack: [], error: void 0, hasError: false };
+    try {
+        const secureContext = __addDisposableResource(env_13, new SecureContextMock(), false);
+        secureContext.secure = false;
+        const dpr = __addDisposableResource(env_13, new DevicePixelRatioMock(), false);
+        dpr.ratio = 1;
+        const target = TestElement();
+        const input = __addDisposableResource(env_13, DefaultInput(DefaultCam(), target).register('add'), false);
+        await ctx.test('move', () => {
+            target.dispatchEvent(PointerTestEvent('pointermove', {
+                offsetX: 1,
+                offsetY: 2
+            }));
+            input.update(16);
+            assert(input.point?.client, { x: 1, y: 2 });
+            assert(input.point?.type, 'Mouse');
+            assert(input.point?.invalid, true);
+        });
+        await ctx.test('and position is not lost on update', () => {
+            input.update(16);
+            assert(input.point?.client, { x: 1, y: 2 });
+            assert(input.point?.type, 'Mouse');
+            assert(input.point?.invalid, false);
+        });
+    }
+    catch (e_13) {
+        env_13.error = e_13;
+        env_13.hasError = true;
+    }
+    finally {
+        __disposeResources(env_13);
+    }
+});
+test('pointer clicks are buttons', () => {
+    const env_14 = { stack: [], error: void 0, hasError: false };
+    try {
+        const secureContext = __addDisposableResource(env_14, new SecureContextMock(), false);
+        secureContext.secure = false;
+        const dpr = __addDisposableResource(env_14, new DevicePixelRatioMock(), false);
+        dpr.ratio = 1;
+        const target = TestElement();
+        const input = __addDisposableResource(env_14, DefaultInput(DefaultCam(), target).register('add'), false);
+        target.dispatchEvent(PointerTestEvent('pointerdown', { buttons: 1, offsetX: 1, offsetY: 2 }));
+        input.update(16);
+        assertButton(input, 'A', 'On', 'Start');
+        assertCombo(input, [['A']], 'Equal', 'Start');
+        assert(input.point?.invalid, true);
+    }
+    catch (e_14) {
+        env_14.error = e_14;
+        env_14.hasError = true;
+    }
+    finally {
+        __disposeResources(env_14);
+    }
+});
+test('pointer secondary clicks are buttons', () => {
+    const env_15 = { stack: [], error: void 0, hasError: false };
+    try {
+        const secureContext = __addDisposableResource(env_15, new SecureContextMock(), false);
+        secureContext.secure = false;
+        const dpr = __addDisposableResource(env_15, new DevicePixelRatioMock(), false);
+        dpr.ratio = 1;
+        const target = TestElement();
+        const input = __addDisposableResource(env_15, DefaultInput(DefaultCam(), target).register('add'), false);
+        target.dispatchEvent(PointerTestEvent('pointerdown', { buttons: 2, offsetX: 1, offsetY: 2 }));
+        input.update(16);
+        assertButton(input, 'B', 'On', 'Start');
+        assertCombo(input, [['B']], 'Equal', 'Start');
+        assert(input.point?.invalid, true);
+    }
+    catch (e_15) {
+        env_15.error = e_15;
+        env_15.hasError = true;
+    }
+    finally {
+        __disposeResources(env_15);
+    }
+});
+test('a pointer click can become a drag', async (ctx) => {
+    const env_16 = { stack: [], error: void 0, hasError: false };
+    try {
+        const secureContext = __addDisposableResource(env_16, new SecureContextMock(), false);
+        secureContext.secure = false;
+        const dpr = __addDisposableResource(env_16, new DevicePixelRatioMock(), false);
+        dpr.ratio = 1;
+        const target = TestElement();
+        const input = __addDisposableResource(env_16, DefaultInput(DefaultCam(), target).register('add'), false);
+        await ctx.test('init', () => {
+            assert(input.point?.drag.on, undefined);
+            assert(input.point?.drag.start, undefined);
+            assert(input.point?.drag.end, undefined);
+            assert(input.point?.click, undefined);
+            assert(input.point?.invalid, undefined);
+        });
+        await ctx.test('click', () => {
+            target.dispatchEvent(PointerTestEvent('pointerdown', { buttons: 1, offsetX: 1, offsetY: 2 }));
+            input.update(16);
+            assertButton(input, 'A', 'On', 'Start');
+            assertCombo(input, [['A']], 'Equal', 'Start');
+            assert(input.point?.drag.on, false);
+            assert(input.point?.drag.start, false);
+            assert(input.point?.drag.end, false);
+            assert.partialDeepStrictEqual(input.point?.click, { x: 1, y: 2 });
+            assert(input.point?.invalid, true);
+        });
+        await ctx.test('drag', () => {
+            target.dispatchEvent(PointerTestEvent('pointermove', { buttons: 1, offsetX: 6, offsetY: 2 }));
+            input.update(16);
+            assertButton(input, 'A', 'On');
+            assertCombo(input, [['A']], 'Equal');
+            assert(input.point?.drag.on, true);
+            assert(input.point?.drag.start, true);
+            assert(input.point?.drag.end, false);
+            assert.partialDeepStrictEqual(input.point?.click, { x: 1, y: 2 });
+            assert(input.point?.invalid, true);
+        });
+        await ctx.test('pause', () => {
+            input.update(16);
+            assertButton(input, 'A', 'On');
+            assertCombo(input, [['A']], 'Equal');
+            assert(input.point?.drag.on, true);
+            assert(input.point?.drag.start, false);
+            assert(input.point?.drag.end, false);
+            assert.partialDeepStrictEqual(input.point?.click, { x: 1, y: 2 });
+            assert(input.point?.invalid, false);
+        });
+        await ctx.test('move', () => {
+            target.dispatchEvent(PointerTestEvent('pointermove', { buttons: 1, offsetX: 16, offsetY: 12 }));
+            input.update(16);
+            assertButton(input, 'A', 'On');
+            assertCombo(input, [['A']], 'Equal');
+            assert(input.point?.drag.on, true);
+            assert(input.point?.drag.start, false);
+            assert(input.point?.drag.end, false);
+            assert.partialDeepStrictEqual(input.point?.click, { x: 1, y: 2 });
+            assert(input.point?.invalid, true);
+        });
+        await ctx.test('release', () => {
+            target.dispatchEvent(PointerTestEvent('pointerup', {}));
+            input.update(16);
+            assertButton(input, 'A', 'Off', 'Start');
+            assertCombo(input, [['A']], 'Equal');
+            assert(input.point?.drag.on, false);
+            assert(input.point?.drag.start, false);
+            assert(input.point?.drag.end, true);
+            assert.partialDeepStrictEqual(input.point?.click, undefined);
+            assert(input.point?.invalid, true);
+        });
+        await ctx.test('pause again', () => {
+            input.update(16);
+            assertButton(input, 'A', 'Off');
+            assertCombo(input, [['A']], 'Equal');
+            assert(input.point?.drag.on, false);
+            assert(input.point?.drag.start, false);
+            assert(input.point?.drag.end, false);
+            assert.partialDeepStrictEqual(input.point?.click, undefined);
+            assert(input.point?.invalid, false);
+        });
+    }
+    catch (e_16) {
+        env_16.error = e_16;
+        env_16.hasError = true;
+    }
+    finally {
+        __disposeResources(env_16);
+    }
+});
+test('a pointer click can become a drag or a pinch', async (ctx) => {
+    const env_17 = { stack: [], error: void 0, hasError: false };
+    try {
+        const secureContext = __addDisposableResource(env_17, new SecureContextMock(), false);
+        secureContext.secure = false;
+        const dpr = __addDisposableResource(env_17, new DevicePixelRatioMock(), false);
+        dpr.ratio = 1;
+        const target = TestElement();
+        const input = __addDisposableResource(env_17, DefaultInput(DefaultCam(), target).register('add'), false);
+        await ctx.test('init', () => {
+            assert(input.point?.drag.on, undefined);
+            assert(input.point?.drag.start, undefined);
+            assert(input.point?.drag.end, undefined);
+            assert.partialDeepStrictEqual(input.point?.click, undefined);
+            assert(input.point?.pinch?.xy, undefined);
+            assert(input.point?.center, undefined);
+            assert(input.point?.invalid, undefined);
+        });
+        await ctx.test('click', () => {
+            target.dispatchEvent(PointerTestEvent('pointerdown', { buttons: 1, offsetX: 1, offsetY: 2 }));
+            input.update(16);
+            assertButton(input, 'A', 'On', 'Start');
+            assertCombo(input, [['A']], 'Equal', 'Start');
+            assert(input.point?.drag.on, false);
+            assert(input.point?.drag.start, false);
+            assert(input.point?.drag.end, false);
+            assert.partialDeepStrictEqual(input.point?.click, { x: 1, y: 2 });
+            assert(input.point?.pinch?.xy, undefined);
+            assert.partialDeepStrictEqual(input.point?.center, { x: 1, y: 2 });
+            assert(input.point?.invalid, true);
+        });
+        await ctx.test('drag', () => {
+            target.dispatchEvent(PointerTestEvent('pointermove', { buttons: 1, offsetX: 6, offsetY: 2 }));
+            input.update(16);
+            assertButton(input, 'A', 'On');
+            assertCombo(input, [['A']], 'Equal');
+            assert(input.point?.drag.on, true);
+            assert(input.point?.drag.start, true);
+            assert(input.point?.drag.end, false);
+            assert.partialDeepStrictEqual(input.point?.click, { x: 1, y: 2 });
+            assert(input.point?.pinch?.xy, undefined);
+            assert.partialDeepStrictEqual(input.point?.center, { x: 6, y: 2 });
+            assert(input.point?.invalid, true);
+        });
+        await ctx.test('pinch', () => {
+            target.dispatchEvent(PointerTestEvent('pointerdown', {
+                buttons: 1,
+                offsetX: 10,
+                offsetY: 10,
+                pointerId: 2
+            }));
+            input.update(16);
+            assertButton(input, 'A', 'On');
+            assertCombo(input, [['A']], 'Equal');
+            assert(input.point?.drag.on, false);
+            assert(input.point?.drag.start, false);
+            assert(input.point?.drag.end, true);
+            assert.partialDeepStrictEqual(input.point?.click, { x: 1, y: 2 });
+            assert(input.point?.pinch?.xy, { x: 0, y: 0 });
+            assert.partialDeepStrictEqual(input.point?.center, { x: 8, y: 6 });
+            assert(input.point?.invalid, true);
+        });
+        await ctx.test('expand', () => {
+            target.dispatchEvent(PointerTestEvent('pointermove', {
+                buttons: 1,
+                offsetX: 20,
+                offsetY: 20,
+                pointerId: 2
+            }));
+            input.update(16);
+            assertButton(input, 'A', 'On');
+            assertCombo(input, [['A']], 'Equal');
+            assert(input.point?.drag.on, false);
+            assert(input.point?.drag.start, false);
+            assert(input.point?.drag.end, false);
+            assert.partialDeepStrictEqual(input.point?.click, { x: 1, y: 2 });
+            assert(input.point?.pinch?.xy, { x: 10, y: 10 });
+            assert.partialDeepStrictEqual(input.point?.center, { x: 13, y: 11 });
+            assert(input.point?.invalid, true);
+        });
+    }
+    catch (e_17) {
+        env_17.error = e_17;
+        env_17.hasError = true;
+    }
+    finally {
+        __disposeResources(env_17);
+    }
+});
+test('center', async (ctx) => {
+    const env_18 = { stack: [], error: void 0, hasError: false };
+    try {
+        const secureContext = __addDisposableResource(env_18, new SecureContextMock(), false);
+        secureContext.secure = false;
+        const dpr = __addDisposableResource(env_18, new DevicePixelRatioMock(), false);
+        dpr.ratio = 1;
+        const target = TestElement();
+        const input = __addDisposableResource(env_18, DefaultInput(DefaultCam(), target).register('add'), false);
+        await ctx.test('init', () => assert.partialDeepStrictEqual(input.point?.center, undefined));
+        await ctx.test('click', () => {
+            target.dispatchEvent(PointerTestEvent('pointerdown', { buttons: 1, offsetX: 1, offsetY: 2 }));
+            input.update(16);
+            assert.partialDeepStrictEqual(input.point?.center, { x: 1, y: 2 });
+            assert(input.point?.invalid, true);
+        });
+        await ctx.test('drag', () => {
+            target.dispatchEvent(PointerTestEvent('pointermove', { buttons: 1, offsetX: 10, offsetY: 10 }));
+            input.update(16);
+            assert.partialDeepStrictEqual(input.point?.center, { x: 10, y: 10 });
+            assert(input.point?.invalid, true);
+        });
+        await ctx.test('secondary click', () => {
+            target.dispatchEvent(PointerTestEvent('pointerdown', {
+                buttons: 1,
+                offsetX: 20,
+                offsetY: 20,
+                pointerId: 2
+            }));
+            input.update(16);
+            assert.partialDeepStrictEqual(input.point?.center, { x: 15, y: 15 });
+            assert(input.point?.invalid, true);
+        });
+        await ctx.test('primary unclick', () => {
+            target.dispatchEvent(PointerTestEvent('pointerup', { offsetX: 30, offsetY: 30 }));
+            input.update(16);
+            assert.partialDeepStrictEqual(input.point?.center, { x: 20, y: 20 });
+            assert(input.point?.invalid, true);
+        });
+    }
+    catch (e_18) {
+        env_18.error = e_18;
+        env_18.hasError = true;
+    }
+    finally {
+        __disposeResources(env_18);
+    }
+});
+test('pinch', async (ctx) => {
+    const env_19 = { stack: [], error: void 0, hasError: false };
+    try {
+        const secureContext = __addDisposableResource(env_19, new SecureContextMock(), false);
+        secureContext.secure = false;
+        const dpr = __addDisposableResource(env_19, new DevicePixelRatioMock(), false);
+        dpr.ratio = 1;
+        const target = TestElement();
+        const input = __addDisposableResource(env_19, DefaultInput(DefaultCam(), target).register('add'), false);
+        await ctx.test('init', () => {
+            assert.partialDeepStrictEqual(input.point?.center, undefined);
+            assert(input.point?.pinch, undefined);
+            assert(input.point?.invalid, undefined);
+        });
+        await ctx.test('click', () => {
+            target.dispatchEvent(PointerTestEvent('pointerdown', { buttons: 1, offsetX: 10, offsetY: 10 }));
+            input.update(16);
+            assert.partialDeepStrictEqual(input.point?.center, { x: 10, y: 10 });
+            assert(input.point?.pinch?.xy, undefined);
+            assert(input.point?.invalid, true);
+        });
+        await ctx.test('secondary click', () => {
+            target.dispatchEvent(PointerTestEvent('pointerdown', {
+                buttons: 1,
+                offsetX: 20,
+                offsetY: 20,
+                pointerId: 2
+            }));
+            input.update(16);
+            assert.partialDeepStrictEqual(input.point?.center, { x: 15, y: 15 });
+            assert(input.point?.pinch?.xy, { x: 0, y: 0 });
+            assert(input.point?.invalid, true);
+        });
+        await ctx.test('expand', () => {
+            target.dispatchEvent(PointerTestEvent('pointermove', {
+                buttons: 1,
+                offsetX: 30,
+                offsetY: 30,
+                pointerId: 2
+            }));
+            input.update(16);
+            assert.partialDeepStrictEqual(input.point?.center, { x: 20, y: 20 });
+            assert(input.point?.pinch?.xy, { x: 10, y: 10 });
+            assert(input.point?.invalid, true);
+        });
+        await ctx.test('release', () => {
+            target.dispatchEvent(PointerTestEvent('pointerup', { pointerId: 2 }));
+            input.update(16);
+            assert.partialDeepStrictEqual(input.point?.center, { x: 10, y: 10 });
+            assert(input.point?.pinch?.xy, undefined);
+            assert(input.point?.invalid, true);
+        });
+    }
+    catch (e_19) {
+        env_19.error = e_19;
+        env_19.hasError = true;
+    }
+    finally {
+        __disposeResources(env_19);
+    }
+});
+test('wheel', () => {
+    const env_20 = { stack: [], error: void 0, hasError: false };
+    try {
+        const secureContext = __addDisposableResource(env_20, new SecureContextMock(), false);
+        secureContext.secure = false;
+        const dpr = __addDisposableResource(env_20, new DevicePixelRatioMock(), false);
+        dpr.ratio = 1;
+        const target = TestElement();
+        const input = __addDisposableResource(env_20, DefaultInput(DefaultCam(), target).register('add'), false);
+        target.dispatchEvent(WheelTestEvent({ deltaX: 1, deltaY: 2, deltaZ: 3 }));
+        input.update(16);
+        assert(input.wheel?.delta.client, { x: 1, y: 2, z: 3 });
+        assert(input.wheel?.delta.xy, { x: 1, y: 2 });
+    }
+    catch (e_20) {
+        env_20.error = e_20;
+        env_20.hasError = true;
+    }
+    finally {
+        __disposeResources(env_20);
+    }
+});
+function assertButton(input, btn, state, edge) {
+    assert(input.isAnyOn(btn), state === 'On');
+    assert(input.isAnyOnStart(btn), state === 'On' && edge === 'Start');
+    assert(input.isOn(btn), state === 'On');
+    assert(input.isOnStart(btn), state === 'On' && edge === 'Start');
+    assert(input.isOff(btn), state === 'Off');
+    assert(input.isOffStart(btn), state === 'Off' && edge === 'Start');
+}
+function assertCombo(input, combo, state, edge) {
+    assert(input.isComboEndsWith(...combo), state !== 'Unequal');
+    assert(input.isComboEndsWithStart(...combo), state !== 'Unequal' && edge === 'Start');
+    assert(input.isCombo(...combo), state === 'Equal');
+    assert(input.isComboStart(...combo), state === 'Equal' && edge === 'Start');
+    const abcCombo = combo.map(set => set.sort());
+    if (state === 'Equal')
+        assert(input.combo, abcCombo);
+    else
+        assert.notDeepEqual(input.combo, abcCombo);
+}
+function DefaultCam() {
+    const cam = new Cam();
+    // assume a fixed cam for all tests.
+    cam.update({
+        width: 0,
+        height: 0,
+        parentElement: { clientHeight: 1000, clientWidth: 1000 },
+        style: { width: '', height: '' }
+    });
+    return cam;
+}
+function DefaultInput(cam, target) {
+    const input = new Input(cam, target);
+    input.mapDefault();
+    return input;
+}
+//# sourceMappingURL=input.test.js.map