@lvl99dotcom/paintcanvas 0.0.0-stage → 0.3.0

package/dist/lib/classes/GestureTracker/index.js

@@ -0,0 +1,122 @@
+// src/lib/classes/GestureTracker/index.ts
+/** A tap's fingers must all lift within this long of the first touching down */
+var TAP_MAX_MS = 300;
+/** How far a finger can move and still be tapping (screen pixels); two-finger pan and pinch wait until a finger moves further */
+var TAP_SLOP_PX = 10;
+/** How far three fingers must move together, or spread apart or close together, to swipe (screen pixels) */
+var SWIPE_MIN_PX = 40;
+/**
+* The swipe three fingers made from where they were to where they are: in or out if their spread changed more than
+* they moved together, otherwise left, right, up or down (whichever way they moved most). Undefined if they moved less
+* than `SWIPE_MIN_PX`.
+*
+* @example
+* swipeOf([{ x: 0, y: 0 }, { x: 10, y: 0 }, { x: 20, y: 0 }], [{ x: 50, y: 0 }, { x: 60, y: 0 }, { x: 70, y: 0 }]); // "swipeRight3"
+*/
+var swipeOf = (from, to) => {
+	const centre = (points) => ({
+		x: points.reduce((sum, p) => sum + p.x, 0) / points.length,
+		y: points.reduce((sum, p) => sum + p.y, 0) / points.length
+	});
+	const spread = (points) => {
+		const c = centre(points);
+		return points.reduce((sum, p) => sum + Math.hypot(p.x - c.x, p.y - c.y), 0) / points.length;
+	};
+	const a = centre(from);
+	const b = centre(to);
+	const dx = b.x - a.x;
+	const dy = b.y - a.y;
+	const moved = Math.hypot(dx, dy);
+	const spreadChange = spread(to) - spread(from);
+	if (Math.abs(spreadChange) > moved) {
+		if (Math.abs(spreadChange) < 40) return void 0;
+		return spreadChange > 0 ? "swipeOut3" : "swipeIn3";
+	}
+	if (moved < 40) return void 0;
+	if (Math.abs(dx) > Math.abs(dy)) return dx > 0 ? "swipeRight3" : "swipeLeft3";
+	return dy > 0 ? "swipeDown3" : "swipeUp3";
+};
+/**
+* Recognises touch gestures from the fingers on the canvas, from the first finger down to the last one up: a tap with
+* two or three fingers (all lifted within `TAP_MAX_MS`, none moving more than `TAP_SLOP_PX`), or a swipe with three
+* fingers (see `swipeOf`, measured from when the third finger touched down to when the first of them lifted). Four or
+* more fingers, or a cancelled touch (e.g. taken by a system gesture), make no gesture.
+*
+* @example
+* const tracker = new GestureTracker();
+* tracker.down(1, { x: 0, y: 0 }, 0);
+* tracker.down(2, { x: 50, y: 0 }, 10);
+* tracker.up(1, 100);
+* tracker.up(2, 120); // "tap2"
+*/
+var GestureTracker = class {
+	/** Where each finger on the screen touched down, and where it is now */
+	fingers = /* @__PURE__ */ new Map();
+	/** When the first finger touched down */
+	startTime = 0;
+	/** Most fingers down at once */
+	most = 0;
+	/** Whether any finger moved too far to tap */
+	moved = false;
+	/** Whether a touch was cancelled */
+	cancelled = false;
+	/** The three fingers' positions when the third touched down, and when the first of them lifted */
+	swipe;
+	/** How many fingers are on the screen */
+	get count() {
+		return this.fingers.size;
+	}
+	/**
+	* Whether any finger moved further than a tap allows since touching down.
+	*/
+	get dragging() {
+		return this.moved;
+	}
+	/** A finger touched down */
+	down(id, point, time) {
+		if (this.fingers.size === 0) this.reset(time);
+		this.fingers.set(id, {
+			start: point,
+			now: point
+		});
+		this.most = Math.max(this.most, this.fingers.size);
+		if (this.fingers.size === 3) this.swipe = { from: [...this.fingers.values()].map((f) => f.now) };
+	}
+	/** A finger moved */
+	move(id, point) {
+		const finger = this.fingers.get(id);
+		if (!finger) return;
+		finger.now = point;
+		if (Math.hypot(point.x - finger.start.x, point.y - finger.start.y) > 10) this.moved = true;
+	}
+	/**
+	* A finger lifted. Returns the gesture made once the last finger lifts, if any.
+	*/
+	up(id, time) {
+		if (!this.fingers.has(id)) return void 0;
+		if (this.swipe && !this.swipe.to) this.swipe.to = [...this.fingers.values()].map((f) => f.now);
+		this.fingers.delete(id);
+		if (this.fingers.size > 0 || this.cancelled || this.most > 3) return void 0;
+		if (this.most === 3 && this.swipe?.to) {
+			const swipe = swipeOf(this.swipe.from, this.swipe.to);
+			if (swipe) return swipe;
+		}
+		if (this.moved || time - this.startTime > 300) return void 0;
+		if (this.most === 2) return "tap2";
+		if (this.most === 3) return "tap3";
+	}
+	/** A touch was cancelled: no gesture until all fingers have lifted */
+	cancel(id) {
+		if (!this.fingers.delete(id)) return;
+		this.cancelled = true;
+	}
+	/** Start tracking a new gesture */
+	reset(time) {
+		this.startTime = time;
+		this.most = 0;
+		this.moved = false;
+		this.cancelled = false;
+		this.swipe = void 0;
+	}
+};
+export { SWIPE_MIN_PX, TAP_MAX_MS, TAP_SLOP_PX, GestureTracker as default, swipeOf };

package/dist/lib/classes/History/index.d.ts

@@ -0,0 +1,83 @@
+/** Maximum number of actions that can be undone */
+export declare const MAX_HISTORY_ENTRIES = 20;
+/** Event dispatched after a step is undone (detail: `HistoryStepDetail`) */
+export declare const UNDO_EVENT = "undo";
+/** Event dispatched after a step is redone (detail: `HistoryStepDetail`) */
+export declare const REDO_EVENT = "redo";
+/** Details of an undo or redo event: the step undone or redone */
+export interface HistoryStepDetail {
+    step: string;
+}
+/** An action that can be undone and redone */
+export interface HistoryEntry {
+    /** Put things back as they were before the action */
+    undo(): void;
+    /** Apply the action again after it was undone */
+    redo(): void;
+}
+/**
+ * A timeline of the user's actions. Undo moves back along it and redo moves forward again. Recording an action after
+ * undoing removes the undone actions. Only the latest `limit` actions are kept.
+ *
+ * Actions recorded while an entry is being undone or redone (or inside `untracked`) are ignored, so entries can use
+ * the same methods that record actions. Each recorded step gets an ID. Dispatches `change` when what can be undone or
+ * redone changes, and `undo` or `redo` (with the step's ID) after a step is undone or redone.
+ *
+ * @example
+ * const history = new History();
+ * history.push({ undo: () => (layer.opacity = 1), redo: () => (layer.opacity = 0.5) });
+ * history.undo(); // layer.opacity is 1
+ * history.redo(); // layer.opacity is 0.5
+ */
+export default class History extends EventTarget {
+    /** Maximum number of entries kept */
+    readonly limit: number;
+    private entries;
+    /** Number of entries applied (the rest can be redone) */
+    private applied;
+    /** Each recorded step's ID */
+    private readonly steps;
+    private paused;
+    constructor(limit?: number);
+    /** Number of recorded steps (done and undone), at most `limit` */
+    get size(): number;
+    /** Whether there is an action to undo */
+    get canUndo(): boolean;
+    /** Whether there is an undone action to redo */
+    get canRedo(): boolean;
+    /** Whether actions are being recorded (not while undoing, redoing or inside `untracked`) */
+    get recording(): boolean;
+    /**
+     * Record an action that has just been applied. Removes any undone actions, and the oldest action when over the limit.
+     */
+    push(entry: HistoryEntry): void;
+    /**
+     * Undo the latest applied action. Returns whether there was one.
+     */
+    undo(): boolean;
+    /**
+     * Redo the next undone action. Returns whether there was one.
+     */
+    redo(): boolean;
+    /**
+     * Forget all actions (e.g. when the canvas is replaced).
+     */
+    clear(): void;
+    /**
+     * Tell listeners that what can be undone or redone may have changed.
+     */
+    /**
+     * The ID of the latest recorded step (undefined when there are none), e.g. to tell others which step a stroke made.
+     */
+    get latestStep(): string | undefined;
+    /** Dispatch an undo or redo event for a step */
+    private announce;
+    private notify;
+    /**
+     * Run a function without recording the actions it applies. Returns the function's result.
+     *
+     * @example
+     * history.untracked(() => stack.create()); // not undoable
+     */
+    untracked<T>(run: () => T): T;
+}

package/dist/lib/classes/History/index.js

@@ -0,0 +1,126 @@
+// src/lib/classes/History/index.ts
+/** Maximum number of actions that can be undone */
+var MAX_HISTORY_ENTRIES = 20;
+/** Event dispatched after a step is undone (detail: `HistoryStepDetail`) */
+var UNDO_EVENT = "undo";
+/** Event dispatched after a step is redone (detail: `HistoryStepDetail`) */
+var REDO_EVENT = "redo";
+/**
+* A timeline of the user's actions. Undo moves back along it and redo moves forward again. Recording an action after
+* undoing removes the undone actions. Only the latest `limit` actions are kept.
+*
+* Actions recorded while an entry is being undone or redone (or inside `untracked`) are ignored, so entries can use
+* the same methods that record actions. Each recorded step gets an ID. Dispatches `change` when what can be undone or
+* redone changes, and `undo` or `redo` (with the step's ID) after a step is undone or redone.
+*
+* @example
+* const history = new History();
+* history.push({ undo: () => (layer.opacity = 1), redo: () => (layer.opacity = 0.5) });
+* history.undo(); // layer.opacity is 1
+* history.redo(); // layer.opacity is 0.5
+*/
+var History = class extends EventTarget {
+	/** Maximum number of entries kept */
+	limit;
+	entries = [];
+	/** Number of entries applied (the rest can be redone) */
+	applied = 0;
+	/** Each recorded step's ID */
+	steps = /* @__PURE__ */ new WeakMap();
+	paused = false;
+	constructor(limit = 20) {
+		super();
+		this.limit = limit;
+	}
+	/** Number of recorded steps (done and undone), at most `limit` */
+	get size() {
+		return this.entries.length;
+	}
+	/** Whether there is an action to undo */
+	get canUndo() {
+		return this.applied > 0;
+	}
+	/** Whether there is an undone action to redo */
+	get canRedo() {
+		return this.applied < this.entries.length;
+	}
+	/** Whether actions are being recorded (not while undoing, redoing or inside `untracked`) */
+	get recording() {
+		return !this.paused;
+	}
+	/**
+	* Record an action that has just been applied. Removes any undone actions, and the oldest action when over the limit.
+	*/
+	push(entry) {
+		if (this.paused) return;
+		this.steps.set(entry, crypto.randomUUID());
+		this.entries = [...this.entries.slice(0, this.applied), entry].slice(-this.limit);
+		this.applied = this.entries.length;
+		this.notify();
+	}
+	/**
+	* Undo the latest applied action. Returns whether there was one.
+	*/
+	undo() {
+		if (!this.canUndo) return false;
+		this.applied -= 1;
+		const entry = this.entries[this.applied];
+		this.untracked(() => entry.undo());
+		this.notify();
+		this.announce(UNDO_EVENT, entry);
+		return true;
+	}
+	/**
+	* Redo the next undone action. Returns whether there was one.
+	*/
+	redo() {
+		if (!this.canRedo) return false;
+		const entry = this.entries[this.applied];
+		this.applied += 1;
+		this.untracked(() => entry.redo());
+		this.notify();
+		this.announce(REDO_EVENT, entry);
+		return true;
+	}
+	/**
+	* Forget all actions (e.g. when the canvas is replaced).
+	*/
+	clear() {
+		this.entries = [];
+		this.applied = 0;
+		this.notify();
+	}
+	/**
+	* Tell listeners that what can be undone or redone may have changed.
+	*/
+	/**
+	* The ID of the latest recorded step (undefined when there are none), e.g. to tell others which step a stroke made.
+	*/
+	get latestStep() {
+		const entry = this.entries.at(-1);
+		return entry && this.steps.get(entry);
+	}
+	/** Dispatch an undo or redo event for a step */
+	announce(type, entry) {
+		this.dispatchEvent(new CustomEvent(type, { detail: { step: this.steps.get(entry) } }));
+	}
+	notify() {
+		this.dispatchEvent(new Event("change"));
+	}
+	/**
+	* Run a function without recording the actions it applies. Returns the function's result.
+	*
+	* @example
+	* history.untracked(() => stack.create()); // not undoable
+	*/
+	untracked(run) {
+		const paused = this.paused;
+		this.paused = true;
+		try {
+			return run();
+		} finally {
+			this.paused = paused;
+		}
+	}
+};
+export { MAX_HISTORY_ENTRIES, REDO_EVENT, UNDO_EVENT, History as default };

package/dist/lib/classes/HistoryGuard/index.d.ts

@@ -0,0 +1,58 @@
+/** History state of the entry the guard adds */
+export declare const GUARD_STATE: {
+    readonly paintcanvasGuard: true;
+};
+/** The parts of `window` the guard uses (replaceable for tests) */
+export type GuardWindow = Pick<Window, "history" | "location" | "addEventListener" | "removeEventListener">;
+/**
+ * Whether a history state is the guard's entry.
+ *
+ * @example
+ * isGuardState(GUARD_STATE); // true
+ * isGuardState(null); // false
+ */
+export declare const isGuardState: (state: unknown) => boolean;
+/**
+ * Keeps going back (e.g. swiping from the screen's edge) from leaving the page while it guards: it adds a history entry
+ * for the page, and when the browser goes back from it, puts it back and calls `onBack` (to ask before leaving).
+ * Releasing goes back to the page's own entry, keeping the address the page shows.
+ *
+ * Call `guard` whenever the page's address may have changed while guarding (it remembers the address to show), and
+ * `release` once leaving is safe.
+ *
+ * @example
+ * const guard = new HistoryGuard(() => askBeforeLeaving());
+ * guard.attach(window);
+ * guard.guard(); // a canvas is open
+ * guard.release(); // the canvas closed
+ */
+export default class HistoryGuard {
+    private readonly onBack;
+    private target?;
+    /** Whether the page wants guarding */
+    private wanted;
+    /** Whether the guard's entry was added (and not yet released) */
+    private guarded;
+    /** The address the guard's entry shows */
+    private url;
+    /** While releasing: the address to keep once back on the page's own entry */
+    private releasing?;
+    constructor(onBack: () => void);
+    /**
+     * Start listening for the browser going back.
+     */
+    attach(target: GuardWindow): void;
+    /**
+     * Stop listening (the guard's entry, if any, stays).
+     */
+    detach(): void;
+    /**
+     * Guard the page: add the guard's entry if it isn't there, and remember the address it shows.
+     */
+    guard(): void;
+    /**
+     * Stop guarding: go back to the page's own entry, keeping the address the page shows now.
+     */
+    release(): void;
+    private readonly onPopState;
+}

package/dist/lib/classes/HistoryGuard/index.js

@@ -0,0 +1,97 @@
+// src/lib/classes/HistoryGuard/index.ts
+/** History state of the entry the guard adds */
+var GUARD_STATE = { paintcanvasGuard: true };
+/**
+* Whether a history state is the guard's entry.
+*
+* @example
+* isGuardState(GUARD_STATE); // true
+* isGuardState(null); // false
+*/
+var isGuardState = (state) => typeof state === "object" && state !== null && state.paintcanvasGuard === true;
+/**
+* Keeps going back (e.g. swiping from the screen's edge) from leaving the page while it guards: it adds a history entry
+* for the page, and when the browser goes back from it, puts it back and calls `onBack` (to ask before leaving).
+* Releasing goes back to the page's own entry, keeping the address the page shows.
+*
+* Call `guard` whenever the page's address may have changed while guarding (it remembers the address to show), and
+* `release` once leaving is safe.
+*
+* @example
+* const guard = new HistoryGuard(() => askBeforeLeaving());
+* guard.attach(window);
+* guard.guard(); // a canvas is open
+* guard.release(); // the canvas closed
+*/
+var HistoryGuard = class {
+	onBack;
+	target;
+	/** Whether the page wants guarding */
+	wanted = false;
+	/** Whether the guard's entry was added (and not yet released) */
+	guarded = false;
+	/** The address the guard's entry shows */
+	url = "";
+	/** While releasing: the address to keep once back on the page's own entry */
+	releasing;
+	constructor(onBack) {
+		this.onBack = onBack;
+	}
+	/**
+	* Start listening for the browser going back.
+	*/
+	attach(target) {
+		this.detach();
+		this.target = target;
+		target.addEventListener("popstate", this.onPopState);
+	}
+	/**
+	* Stop listening (the guard's entry, if any, stays).
+	*/
+	detach() {
+		this.target?.removeEventListener("popstate", this.onPopState);
+		this.target = void 0;
+		this.guarded = false;
+		this.wanted = false;
+		this.releasing = void 0;
+	}
+	/**
+	* Guard the page: add the guard's entry if it isn't there, and remember the address it shows.
+	*/
+	guard() {
+		const target = this.target;
+		if (!target) return;
+		this.wanted = true;
+		if (this.releasing !== void 0) return;
+		if (!this.guarded) {
+			this.guarded = true;
+			target.history.pushState(GUARD_STATE, "", target.location.href);
+		}
+		if (isGuardState(target.history.state)) this.url = target.location.href;
+	}
+	/**
+	* Stop guarding: go back to the page's own entry, keeping the address the page shows now.
+	*/
+	release() {
+		const target = this.target;
+		this.wanted = false;
+		if (!target || !this.guarded) return;
+		this.guarded = false;
+		if (!isGuardState(target.history.state)) return;
+		this.releasing = target.location.href;
+		target.history.back();
+	}
+	onPopState = (event) => {
+		const target = this.target;
+		if (this.releasing !== void 0) {
+			target.history.replaceState(null, "", this.releasing);
+			this.releasing = void 0;
+			if (this.wanted) this.guard();
+			return;
+		}
+		if (!this.guarded || isGuardState(event.state)) return;
+		target.history.pushState(GUARD_STATE, "", this.url);
+		this.onBack();
+	};
+};
+export { GUARD_STATE, HistoryGuard as default, isGuardState };

package/dist/lib/classes/InputSettings/index.d.ts

@@ -0,0 +1,74 @@
+import { type GestureSettings } from "../../utils/gestures";
+/** How the user's input devices control the canvas */
+export interface InputSettingsData {
+    /** Two-finger scroll (or mouse wheel) pans the canvas */
+    scrollPan: boolean;
+    /** Pinch zooms the canvas */
+    pinchZoom: boolean;
+    /** Cmd/Ctrl + scroll zooms the canvas (desktop only) */
+    modifierScrollZoom: boolean;
+    /** Which touch gesture undoes, redoes, copies and pastes (touch devices only) */
+    gestures: GestureSettings;
+    /** Focus pen mode: fingers and palms never draw, and touches are ignored while a pen is down or just lifted */
+    focusPen: boolean;
+}
+/** Names of all input settings, e.g. to pick them out of a larger settings object */
+export declare const INPUT_SETTING_KEYS: readonly ["scrollPan", "pinchZoom", "modifierScrollZoom", "focusPen", "gestures"];
+/**
+ * Default input settings: all navigation on, the default touch gestures, focus pen mode off.
+ *
+ * @example
+ * defaultInputSettings().focusPen; // false
+ */
+export declare const defaultInputSettings: () => InputSettingsData;
+/**
+ * Keep only valid input settings from an untrusted value (e.g. stored or imported), using `defaults` for anything
+ * missing or invalid. Other properties are left out.
+ *
+ * @example
+ * sanitiseInputSettings({ focusPen: true, scrollPan: "yes" }, defaultInputSettings()); // focusPen on, scrollPan from defaults
+ */
+export declare const sanitiseInputSettings: (input: unknown, defaults: InputSettingsData) => InputSettingsData;
+/**
+ * Whether the device has no fine pointer (mouse or trackpad), i.e. it is a phone or tablet. Without `matchMedia`, the
+ * device is treated as a desktop.
+ *
+ * @example
+ * isTouchDevice(); // false on a laptop
+ */
+export declare const isTouchDevice: (matchMedia?: ((query: string) => {
+    matches: boolean;
+}) | undefined) => boolean;
+/**
+ * Name of the key held to zoom with the scroll wheel: "Cmd" on Apple devices, "Ctrl" elsewhere.
+ *
+ * @example
+ * zoomModifierName("MacIntel"); // "Cmd"
+ * zoomModifierName("Win32"); // "Ctrl"
+ */
+export declare const zoomModifierName: (platform?: string) => "Cmd" | "Ctrl";
+/**
+ * How the user's input devices control the canvas: scrolling, pinching, touch gestures and focus pen mode. Kept in
+ * memory; the implementer saves and restores them (see `update` and the `change` event).
+ *
+ * Dispatches a `change` event when a setting changes.
+ *
+ * @example
+ * const input = new InputSettings();
+ * input.update({ focusPen: true });
+ * input.data.focusPen; // true
+ */
+export default class InputSettings extends EventTarget {
+    private values;
+    constructor(initial?: unknown);
+    /** Current settings (read-only copy) */
+    get data(): Readonly<InputSettingsData>;
+    /**
+     * Change some settings and dispatch `change` if anything changed. Invalid values and other properties are ignored, so
+     * a larger settings object can be passed.
+     *
+     * @example
+     * input.update({ pinchZoom: false });
+     */
+    update(changes: Partial<InputSettingsData>): void;
+}

package/dist/lib/classes/InputSettings/index.js

@@ -0,0 +1,101 @@
+import { DEFAULT_GESTURES, sanitiseGestures } from "../../utils/gestures/index.js";
+// src/lib/classes/InputSettings/index.ts
+/** The on/off input settings */
+var INPUT_TOGGLES = [
+	"scrollPan",
+	"pinchZoom",
+	"modifierScrollZoom",
+	"focusPen"
+];
+/** Names of all input settings, e.g. to pick them out of a larger settings object */
+var INPUT_SETTING_KEYS = [...INPUT_TOGGLES, "gestures"];
+/**
+* Default input settings: all navigation on, the default touch gestures, focus pen mode off.
+*
+* @example
+* defaultInputSettings().focusPen; // false
+*/
+var defaultInputSettings = () => ({
+	scrollPan: true,
+	pinchZoom: true,
+	modifierScrollZoom: true,
+	gestures: { ...DEFAULT_GESTURES },
+	focusPen: false
+});
+/**
+* Keep only valid input settings from an untrusted value (e.g. stored or imported), using `defaults` for anything
+* missing or invalid. Other properties are left out.
+*
+* @example
+* sanitiseInputSettings({ focusPen: true, scrollPan: "yes" }, defaultInputSettings()); // focusPen on, scrollPan from defaults
+*/
+var sanitiseInputSettings = (input, defaults) => {
+	const result = {
+		...defaults,
+		gestures: { ...defaults.gestures }
+	};
+	if (typeof input !== "object" || input === null) return result;
+	const value = input;
+	for (const key of INPUT_TOGGLES) if (typeof value[key] === "boolean") result[key] = value[key];
+	if ("gestures" in value) result.gestures = sanitiseGestures(value.gestures);
+	return result;
+};
+/**
+* Whether two sets of input settings are the same.
+*/
+var sameInputSettings = (a, b) => INPUT_TOGGLES.every((key) => a[key] === b[key]) && JSON.stringify(a.gestures) === JSON.stringify(b.gestures);
+/**
+* Whether the device has no fine pointer (mouse or trackpad), i.e. it is a phone or tablet. Without `matchMedia`, the
+* device is treated as a desktop.
+*
+* @example
+* isTouchDevice(); // false on a laptop
+*/
+var isTouchDevice = (matchMedia = typeof window.matchMedia === "function" ? (query) => window.matchMedia(query) : void 0) => matchMedia ? !matchMedia("(any-pointer: fine)").matches : false;
+/**
+* Name of the key held to zoom with the scroll wheel: "Cmd" on Apple devices, "Ctrl" elsewhere.
+*
+* @example
+* zoomModifierName("MacIntel"); // "Cmd"
+* zoomModifierName("Win32"); // "Ctrl"
+*/
+var zoomModifierName = (platform = navigator.platform) => /Mac|iPhone|iPad|iPod/.test(platform) ? "Cmd" : "Ctrl";
+/**
+* How the user's input devices control the canvas: scrolling, pinching, touch gestures and focus pen mode. Kept in
+* memory; the implementer saves and restores them (see `update` and the `change` event).
+*
+* Dispatches a `change` event when a setting changes.
+*
+* @example
+* const input = new InputSettings();
+* input.update({ focusPen: true });
+* input.data.focusPen; // true
+*/
+var InputSettings = class extends EventTarget {
+	values;
+	constructor(initial) {
+		super();
+		this.values = sanitiseInputSettings(initial, defaultInputSettings());
+	}
+	/** Current settings (read-only copy) */
+	get data() {
+		return this.values;
+	}
+	/**
+	* Change some settings and dispatch `change` if anything changed. Invalid values and other properties are ignored, so
+	* a larger settings object can be passed.
+	*
+	* @example
+	* input.update({ pinchZoom: false });
+	*/
+	update(changes) {
+		const next = sanitiseInputSettings({
+			...this.values,
+			...changes
+		}, this.values);
+		if (sameInputSettings(next, this.values)) return;
+		this.values = next;
+		this.dispatchEvent(new Event("change"));
+	}
+};
+export { INPUT_SETTING_KEYS, InputSettings as default, defaultInputSettings, isTouchDevice, sanitiseInputSettings, zoomModifierName };