textmode.js 0.3.0 → 0.3.1

package/dist/types/textmode/managers/MouseManager.d.ts

@@ -17,11 +17,13 @@ export interface MouseEventData {
     position: MousePosition;
     /** Previous mouse position in grid coordinates */
     previousPosition: MousePosition;
-    /** Mouse button that triggered the event (for click events) */
+    /** Mouse button that triggered the event *(for click events)* */
     button?: number;
     /** Scroll delta for wheel events */
     delta?: {
+        /** Scroll delta in X direction */
         x: number;
+        /** Scroll delta in Y direction */
         y: number;
     };
     /** Original DOM event */
@@ -34,6 +36,7 @@ export type MouseEventHandler = (data: MouseEventData) => void;
 /**
  * Manages all mouse interaction for a Textmodifier instance.
  * Handles event listeners, coordinate conversion, and event dispatching.
+ * @ignore
  */
 export declare class MouseManager {
     private _canvas;
@@ -41,6 +44,7 @@ export declare class MouseManager {
     private _mousePosition;
     private _previousMousePosition;
     private _lastClientCoordinates;
+    private _suppressUntil;
     private _mouseMoveListener;
     private _mouseLeaveListener;
     private _mouseDownListener;
@@ -54,6 +58,20 @@ export declare class MouseManager {
     private _mouseMovedCallback?;
     private _mouseScrolledCallback?;
     constructor(canvas: TextmodeCanvas);
+    /**
+     * Temporarily suppress mouse event callbacks for a duration in milliseconds.
+     * Used to prevent synthetic mouse events from touch interactions from firing twice.
+     */
+    $suppressEventsFor(durationMs: number): void;
+    private _isSuppressed;
+    /**
+     * Set the CSS cursor for the textmode canvas.
+     * Pass a valid CSS cursor value (e.g. 'pointer', 'crosshair', 'move', 'nwse-resize', 'none').
+     * Call with no argument or an empty string to reset to the default cursor.
+     *
+     * Reference: https://developer.mozilla.org/en-US/docs/Web/CSS/cursor
+     */
+    $setCursor(cursor?: string): void;
     /**
      * Update the grid reference (useful when grid changes after font loading)
      */

package/dist/types/textmode/managers/TouchManager.d.ts

@@ -0,0 +1,225 @@
+import type { TextmodeCanvas } from '../Canvas';
+import type { TextmodeGrid } from '../Grid';
+import type { MouseManager } from './MouseManager';
+/**
+ * Touch position expressed both in grid and client coordinates
+ */
+export interface TouchPosition {
+    /** Identifier provided by the browser for a touch point */
+    id: number;
+    /** Grid X coordinate (column), -1 if touch is outside grid */
+    x: number;
+    /** Grid Y coordinate (row), -1 if touch is outside grid */
+    y: number;
+    /** Client X coordinate in CSS pixels */
+    clientX: number;
+    /** Client Y coordinate in CSS pixels */
+    clientY: number;
+    /** Touch pressure (0-1) when supported */
+    pressure?: number;
+    /** Contact ellipse radius on the X axis in CSS pixels */
+    radiusX?: number;
+    /** Contact ellipse radius on the Y axis in CSS pixels */
+    radiusY?: number;
+    /** Contact ellipse angle in radians when provided */
+    rotationAngle?: number;
+}
+/**
+ * Touch event data.
+ */
+export interface TouchEventData {
+    /** The touch point that triggered this event */
+    touch: TouchPosition;
+    /** The previous position for this touch if available */
+    previousTouch?: TouchPosition;
+    /** All active touches mapped to grid coordinates */
+    touches: TouchPosition[];
+    /** Active touches snapshot before this event */
+    previousTouches: TouchPosition[];
+    /** Touches that changed during this event */
+    changedTouches: TouchPosition[];
+    /** Milliseconds elapsed since the previous update for this touch */
+    deltaTime: number;
+    /** Original browser event */
+    originalEvent: TouchEvent;
+}
+/**
+ * Tap (single or double) event data
+ */
+export interface TouchTapEventData {
+    /** Position of the tap */
+    touch: TouchPosition;
+    /** Number of taps recognised (1 or 2) */
+    taps: 1 | 2;
+    /** Original browser event */
+    originalEvent: TouchEvent;
+}
+/**
+ * Long press event data
+ */
+export interface TouchLongPressEventData {
+    /** Touch position at the time the long press fired */
+    touch: TouchPosition;
+    /** Duration in milliseconds the press was held */
+    duration: number;
+    /** Original browser event */
+    originalEvent: TouchEvent;
+}
+/**
+ * Swipe event data reported when the finger travels a minimum distance within a time window
+ */
+export interface TouchSwipeEventData {
+    /** Touch point at the end of the swipe */
+    touch: TouchPosition;
+    /** Normalised swipe direction vector */
+    direction: {
+        x: number;
+        y: number;
+    };
+    /** Total distance travelled in CSS pixels */
+    distance: number;
+    /** Velocity in CSS pixels per millisecond */
+    velocity: {
+        /** Velocity in X direction */
+        x: number;
+        /** Velocity in Y direction */
+        y: number;
+    };
+    /** Original browser event */
+    originalEvent: TouchEvent;
+}
+/**
+ * Pinch gesture event data describing the scaling factor between the initial and current distance
+ */
+export interface TouchPinchEventData {
+    /** Touch points participating in the pinch, always two entries */
+    touches: [TouchPosition, TouchPosition];
+    /** Scale factor relative to the initial distance *(1 == unchanged)* */
+    scale: number;
+    /** Scale delta compared to the previous callback */
+    deltaScale: number;
+    /** Centre of the gesture in grid coordinates */
+    center: {
+        /** Grid X coordinate *(column)* */
+        x: number;
+        /** Grid Y coordinate *(row)* */
+        y: number;
+    };
+    /** Original browser event */
+    originalEvent: TouchEvent;
+}
+/**
+ * Rotate gesture event data describing the angle change between the initial and current segment
+ */
+export interface TouchRotateEventData {
+    /** Touch points participating in the rotation, always two entries */
+    touches: [TouchPosition, TouchPosition];
+    /** Total rotation in degrees relative to the initial angle */
+    rotation: number;
+    /** Change in rotation since the previous callback */
+    deltaRotation: number;
+    /** Centre of the gesture in grid coordinates */
+    center: {
+        /** Grid X coordinate *(column)* */
+        x: number;
+        /** Grid Y coordinate *(row)* */
+        y: number;
+    };
+    /** Original browser event */
+    originalEvent: TouchEvent;
+}
+/** Touch event handler function type */
+export type TouchEventHandler = (data: TouchEventData) => void;
+/** Touch tap event handler function type */
+export type TouchTapHandler = (data: TouchTapEventData) => void;
+/** Touch long press event handler function type */
+export type TouchLongPressHandler = (data: TouchLongPressEventData) => void;
+/** Touch swipe event handler function type */
+export type TouchSwipeHandler = (data: TouchSwipeEventData) => void;
+/** Touch pinch event handler function type */
+export type TouchPinchHandler = (data: TouchPinchEventData) => void;
+/** Touch rotate event handler function type */
+export type TouchRotateHandler = (data: TouchRotateEventData) => void;
+/**
+ * Manages all touch interactions for a Textmodifier instance.
+ * Handles event listeners, coordinate conversion, gesture detection, and event dispatching.
+ * @ignore
+ */
+export declare class TouchManager {
+    private readonly _canvas;
+    private readonly _mouseManager?;
+    private _grid;
+    private _activeTouches;
+    private _previousTouches;
+    private _touchInfo;
+    private _gestureBaseline;
+    private readonly _originalTouchAction;
+    private readonly _originalUserSelect;
+    private _touchStartListener;
+    private _touchMoveListener;
+    private _touchEndListener;
+    private _touchCancelListener;
+    private _areListenersSetup;
+    private _touchStartedCallback?;
+    private _touchMovedCallback?;
+    private _touchEndedCallback?;
+    private _touchCancelledCallback?;
+    private _tapCallback?;
+    private _doubleTapCallback?;
+    private _longPressCallback?;
+    private _swipeCallback?;
+    private _pinchCallback?;
+    private _rotateCallback?;
+    private readonly _tapMaxDuration;
+    private readonly _doubleTapMaxInterval;
+    private readonly _tapMovementTolerance;
+    private readonly _longPressDuration;
+    private readonly _longPressMovementTolerance;
+    private readonly _swipeMinDistance;
+    private readonly _swipeMaxDuration;
+    private readonly _pinchThreshold;
+    private readonly _rotationThreshold;
+    private readonly _mouseSuppressionDuration;
+    private _lastTapTime;
+    private _lastTapPosition;
+    constructor(canvas: TextmodeCanvas, mouseManager?: MouseManager);
+    /** Initialise the manager with the active grid */
+    $initialize(grid: TextmodeGrid): void;
+    /** Install touch listeners onto the canvas */
+    $setupListeners(): void;
+    /** Remove all touch listeners */
+    $cleanupListeners(): void;
+    /**
+     * Recalculate touch positions after grid size or offset changes.
+     * Uses stored client coordinates to project touches into the new grid.
+     */
+    $updatePositions(): void;
+    /** Retrieve a snapshot of all active touches */
+    $getTouches(): TouchPosition[];
+    $setStartedCallback(callback: TouchEventHandler): void;
+    $setMovedCallback(callback: TouchEventHandler): void;
+    $setEndedCallback(callback: TouchEventHandler): void;
+    $setCancelledCallback(callback: TouchEventHandler): void;
+    $setTapCallback(callback: TouchTapHandler): void;
+    $setDoubleTapCallback(callback: TouchTapHandler): void;
+    $setLongPressCallback(callback: TouchLongPressHandler): void;
+    $setSwipeCallback(callback: TouchSwipeHandler): void;
+    $setPinchCallback(callback: TouchPinchHandler): void;
+    $setRotateCallback(callback: TouchRotateHandler): void;
+    private _handleTouchStart;
+    private _handleTouchMove;
+    private _handleTouchEnd;
+    private _handleTouchCancel;
+    private _mapTouchList;
+    private _projectTouch;
+    private _projectClientToGrid;
+    private _buildTouchEventData;
+    private _initializeGestureBaseline;
+    private _updatePinchAndRotate;
+    private _gestureCenter;
+    private _evaluateTapAndSwipe;
+    private _detectDoubleTap;
+    private _cloneTouchPosition;
+    private _distance;
+    private _angle;
+}

package/dist/types/textmode/managers/index.d.ts

@@ -1,4 +1,12 @@
-export { KeyboardManager } from '../managers/KeyboardManager';
-export type { KeyboardEventData, KeyboardEventHandler, KeyState } from '../managers/KeyboardManager';
-export { MouseManager } from '../managers/MouseManager';
-export type { MousePosition, MouseEventData, MouseEventHandler } from '../managers/MouseManager';
+/**
+ * Types and interfaces for keyboard event handling
+ */
+export * as keyboard from '../managers/KeyboardManager';
+/**
+ * Types and interfaces for mouse event handling
+ */
+export * as mouse from '../managers/MouseManager';
+/**
+ * Types and interfaces for touch event handling
+ */
+export * as touch from '../managers/TouchManager';

package/dist/types/textmode/mixins/KeyboardMixin.d.ts

@@ -1,4 +1,5 @@
 import type { Mixin } from './TextmodifierMixin';
+import type { KeyboardEventHandler } from '../managers/KeyboardManager';
 /**
  * Capabilities provided by the KeyboardMixin
  */
@@ -61,7 +62,7 @@ export interface KeyboardCapabilities {
      * });
      * ```
      */
-    keyPressed(callback: () => void): void;
+    keyPressed(callback: KeyboardEventHandler): void;
     /**
      * Set a callback function that will be called when a key is released.
      *
@@ -79,7 +80,7 @@ export interface KeyboardCapabilities {
      * });
      * ```
      */
-    keyReleased(callback: () => void): void;
+    keyReleased(callback: KeyboardEventHandler): void;
 }
 /**
  * Mixin that adds keyboard interaction capabilities to Textmodifier.

package/dist/types/textmode/mixins/MouseMixin.d.ts

@@ -1,5 +1,5 @@
 import type { Mixin } from './TextmodifierMixin';
-import type { MousePosition } from '../managers';
+import type { MouseEventHandler, MousePosition } from '../managers/MouseManager';
 /**
  * Capabilities provided by the MouseMixin
  */
@@ -19,7 +19,7 @@ export interface MouseCapabilities {
      * });
      * ```
      */
-    mouseClicked(callback: () => void): void;
+    mouseClicked(callback: MouseEventHandler): void;
     /**
      * Set a callback function that will be called when the mouse is pressed down.
      *
@@ -34,7 +34,7 @@ export interface MouseCapabilities {
      * });
      * ```
      */
-    mousePressed(callback: () => void): void;
+    mousePressed(callback: MouseEventHandler): void;
     /**
      * Set a callback function that will be called when the mouse is released.
      *
@@ -49,7 +49,7 @@ export interface MouseCapabilities {
      * });
      * ```
      */
-    mouseReleased(callback: () => void): void;
+    mouseReleased(callback: MouseEventHandler): void;
     /**
      * Set a callback function that will be called when the mouse moves.
      *
@@ -67,7 +67,7 @@ export interface MouseCapabilities {
      * });
      * ```
      */
-    mouseMoved(callback: () => void): void;
+    mouseMoved(callback: MouseEventHandler): void;
     /**
      * Set a callback function that will be called when the mouse wheel is scrolled.
      *
@@ -83,7 +83,7 @@ export interface MouseCapabilities {
      * });
      * ```
      */
-    mouseScrolled(callback: () => void): void;
+    mouseScrolled(callback: MouseEventHandler): void;
     /**
      * Get the current mouse position in grid coordinates.
      *
@@ -109,6 +109,23 @@ export interface MouseCapabilities {
      * ```
      */
     get mouse(): MousePosition;
+    /**
+     * Set the mouse cursor for the textmode canvas.
+     *
+     * Provide any valid CSS cursor value (e.g. 'default', 'pointer', 'crosshair', 'move', 'text', 'grab', 'grabbing',
+     * 'none', 'zoom-in', 'zoom-out', 'ns-resize', 'ew-resize', 'nwse-resize', 'nesw-resize', etc.),
+     * or a CSS `url(...)` cursor. Call with no argument or an empty string to reset to default.
+     *
+     * See MDN for all options: https://developer.mozilla.org/en-US/docs/Web/CSS/cursor
+     *
+     * @example
+     * ```javascript
+     * t.cursor('crosshair');
+     * // ... later, reset:
+     * t.cursor();
+     * ```
+     */
+    cursor(cursor?: string): void;
 }
 /**
  * Mixin that adds mouse tracking capabilities to Textmodifier.

package/dist/types/textmode/mixins/RenderingMixin.d.ts

@@ -563,6 +563,7 @@ export interface RenderingCapabilities {
      * @param r Red component (0-255)
      * @param g Green component (0-255)
      * @param b Blue component (0-255)
+     * @param a Alpha component (0-255, optional, defaults to 255)
      *
      * @example
      * ```javascript
@@ -578,12 +579,13 @@ export interface RenderingCapabilities {
      * });
      * ```
      */
-    charColor(r: number, g: number, b: number): void;
+    charColor(r: number, g: number, b: number, a?: number): void;
     /**
      * Set the cell background color for subsequent rendering operations.
      * @param r Red component (0-255)
      * @param g Green component (0-255)
      * @param b Blue component (0-255)
+     * @param a Alpha component (0-255, optional, defaults to 255)
      *
      * @example
      * ```javascript
@@ -599,7 +601,7 @@ export interface RenderingCapabilities {
      * });
      * ```
      */
-    cellColor(r: number, g: number, b: number): void;
+    cellColor(r: number, g: number, b: number, a: number): void;
     /**
      * Toggle horizontal flipping for subsequent character rendering.
      * @param toggle Whether to flip horizontally

package/dist/types/textmode/mixins/TextmodifierMixin.d.ts

@@ -7,8 +7,9 @@ import type { TextmodeCanvas } from '../Canvas';
 import type { TextmodeGrid } from '../Grid';
 import type { AnimationController } from '../AnimationController';
 import type { GLFramebuffer, Shader } from '../../rendering';
-import type { MouseManager } from '../managers';
-import type { KeyboardManager } from '../managers';
+import type { MouseManager } from '../managers/MouseManager';
+import type { KeyboardManager } from '../managers/KeyboardManager';
+import type { TouchManager } from '../managers/TouchManager';
 /**
  * Constructor type for mixin pattern
  */
@@ -34,6 +35,8 @@ export interface TextmodifierContext {
     readonly _animationController: AnimationController;
     /** Mouse interaction manager @ignore */
     readonly _mouseManager: MouseManager;
+    /** Touch interaction manager @ignore */
+    readonly _touchManager: TouchManager;
     /** Keyboard interaction manager @ignore */
     readonly _keyboardManager: KeyboardManager;
     /** Draw shader that contains content drawn by the user @ignore */

package/dist/types/textmode/mixins/TouchMixin.d.ts

@@ -0,0 +1,191 @@
+import type { Mixin } from './TextmodifierMixin';
+import type { TouchEventHandler, TouchLongPressHandler, TouchPinchHandler, TouchPosition, TouchRotateHandler, TouchSwipeHandler, TouchTapHandler } from '../managers/TouchManager';
+/**
+ * Capabilities exposed by the TouchMixin for handling touch interaction and gestures.
+ */
+export interface TouchCapabilities {
+    /**
+     * Set a callback function that will be called when a touch point begins.
+     *
+     * The callback receives {@link TouchEventData} containing the touch that triggered the event,
+     * all active touches, and the original DOM event. Use this to react when the user places one or
+     * more fingers on the canvas.
+     *
+     * @param callback The function to call when a touch starts.
+     *
+     * @example
+     * ```javascript
+     * t.touchStarted((data) => {
+     *   console.log(`Touch ${data.touch.id} began at ${data.touch.x}, ${data.touch.y}`);
+     * });
+     * ```
+     */
+    touchStarted(callback: TouchEventHandler): void;
+    /**
+     * Set a callback function that will be called when a touch point moves across the canvas.
+     *
+     * The provided callback is invoked continuously while the browser reports move events. Use the
+     * `previousTouch` and `deltaTime` fields to derive velocity or gesture behaviour.
+     *
+     * @param callback The function to call when a touch moves.
+     *
+     * @example
+     * ```javascript
+     * t.touchMoved((data) => {
+     *   const { touch, previousTouch } = data;
+     *   if (previousTouch) {
+     *     console.log(`Touch moved by ${touch.x - previousTouch.x}, ${touch.y - previousTouch.y}`);
+     *   }
+     * });
+     * ```
+     */
+    touchMoved(callback: TouchEventHandler): void;
+    /**
+     * Set a callback function that will be called when a touch ends normally.
+     *
+     * This fires after the finger leaves the canvas surface and the browser raises a `touchend`
+     * event. Use it to finalise state such as drawing strokes or completing gestures.
+     *
+     * @param callback The function to call when a touch ends.
+     *
+     * @example
+     * ```javascript
+     * t.touchEnded((data) => {
+     *   console.log(`Touch ${data.touch.id} finished at ${data.touch.x}, ${data.touch.y}`);
+     * });
+     * ```
+     */
+    touchEnded(callback: TouchEventHandler): void;
+    /**
+     * Set a callback function that will be called when a touch is cancelled by the browser.
+     *
+     * Cancellation can occur when the browser takes ownership for scrolling or if the gesture
+     * leaves the window. Treat this as an aborted touch and clean up any in-progress state.
+     *
+     * @param callback The function to call when a touch is cancelled.
+     *
+     * @example
+     * ```javascript
+     * t.touchCancelled((data) => {
+     *   console.warn(`Touch ${data.touch.id} cancelled by the browser`);
+     * });
+     * ```
+     */
+    touchCancelled(callback: TouchEventHandler): void;
+    /**
+     * Register a callback for tap gestures.
+     *
+     * A tap is fired when the user quickly touches and releases the canvas without travelling far.
+     * Use {@link TouchTapEventData.taps} to determine whether the gesture is a single or multi tap.
+     *
+     * @param callback The function to call when a tap gesture is detected.
+     *
+     * @example
+     * ```javascript
+     * t.tap((data) => {
+     *   console.log(`Tapped at ${data.touch.x}, ${data.touch.y}`);
+     * });
+     * ```
+     */
+    tap(callback: TouchTapHandler): void;
+    /**
+     * Register a callback for double tap gestures.
+     *
+     * Double taps reuse the same {@link TouchTapEventData} as taps with `taps` set to `2`. This
+     * helper lets you supply a dedicated handler when you want to treat double taps differently.
+     *
+     * @param callback The function to call when a double tap is detected.
+     *
+     * @example
+     * ```javascript
+     * t.doubleTap((data) => {
+     *   console.log('Double tap detected', data.touch);
+     * });
+     * ```
+     */
+    doubleTap(callback: TouchTapHandler): void;
+    /**
+     * Register a callback for long press gestures.
+     *
+     * A long press is emitted when the user keeps a finger on the canvas without moving beyond the
+     * configured tolerance. The event includes the press duration in milliseconds.
+     *
+     * @param callback The function to call when a long press gesture is detected.
+     *
+     * @example
+     * ```javascript
+     * t.longPress((data) => {
+     *   console.log(`Long press for ${Math.round(data.duration)}ms`);
+     * });
+     * ```
+     */
+    longPress(callback: TouchLongPressHandler): void;
+    /**
+     * Register a callback for swipe gestures.
+     *
+     * Swipes provide the dominant direction (`up`, `down`, `left`, `right`), travelled distance, and
+     * velocity in CSS pixels per millisecond. Useful for panning, flicks, or quick shortcuts.
+     *
+     * @param callback The function to call when a swipe gesture is detected.
+     *
+     * @example
+     * ```javascript
+     * t.swipe((data) => {
+     *   console.log(`Swipe ${data.direction} with distance ${data.distance}`);
+     * });
+     * ```
+     */
+    swipe(callback: TouchSwipeHandler): void;
+    /**
+     * Register a callback for pinch gestures, receiving scale deltas.
+     *
+     * Pinch gestures involve two touch points. The callback receives the current scale relative to
+     * the initial distance and the change since the previous update, enabling zoom interactions.
+     *
+     * @param callback The function to call when a pinch gesture is detected.
+     *
+     * @example
+     * ```javascript
+     * t.pinch((data) => {
+     *   console.log(`Pinch scale: ${data.scale.toFixed(2)}`);
+     * });
+     * ```
+     */
+    pinch(callback: TouchPinchHandler): void;
+    /**
+     * Register a callback for rotate gestures, receiving rotation deltas in degrees.
+     *
+     * Rotation callbacks provide the cumulative rotation and delta rotation since the last update,
+     * along with the gesture centre in grid coordinates. Ideal for dial-like interactions.
+     *
+     * @param callback The function to call when a rotation gesture is detected.
+     *
+     * @example
+     * ```javascript
+     * t.rotateGesture((data) => {
+     *   console.log(`Rotated ${data.deltaRotation.toFixed(1)}°`);
+     * });
+     * ```
+     */
+    rotateGesture(callback: TouchRotateHandler): void;
+    /**
+     * Get the currently active touches in grid coordinates.
+     *
+     * Returns a copy of each touch, including grid position, client coordinates, and pressure when
+     * available. Use this inside a draw loop to react to active multi-touch scenarios.
+     *
+     * @example
+     * ```javascript
+     * t.draw(() => {
+     *   for (const touch of t.touches) {
+     *     t.point(touch.x, touch.y);
+     *   }
+     * });
+     * ```
+     */
+    get touches(): TouchPosition[];
+}
+/**
+ * Mixin that wires the public touch API to the underlying TouchManager implementation.
+ */
+export declare const TouchMixin: Mixin<TouchCapabilities>;

package/dist/types/textmode/mixins/index.d.ts

@@ -4,6 +4,8 @@ export { ExportMixin, type ExportCapabilities } from './ExportMixin';
 export { FontMixin, type FontCapabilities } from './FontMixin';
 export { AnimationMixin, type AnimationCapabilities } from './AnimationMixin';
 export { MouseMixin, type MouseCapabilities } from './MouseMixin';
+export { TouchMixin, type TouchCapabilities } from './TouchMixin';
 export { KeyboardMixin, type KeyboardCapabilities } from './KeyboardMixin';
-export type { MousePosition, MouseEventData, MouseEventHandler } from '../managers';
-export type { KeyboardEventData, KeyboardEventHandler, KeyState } from '../managers';
+export type { MousePosition, MouseEventData, MouseEventHandler } from '../managers/MouseManager';
+export type { TouchEventData, TouchLongPressEventData, TouchPinchEventData, TouchPosition, TouchRotateEventData, TouchSwipeEventData, TouchTapEventData } from '../managers/TouchManager';
+export type { KeyboardEventData, KeyboardEventHandler, KeyState } from '../managers/KeyboardManager';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "textmode.js",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "textmode.js is a lightweight creative coding library for creating real-time ASCII art on the web.",
   "type": "module",
   "types": "./dist/types/index.d.ts",