@map-gesture-controls/ol 0.1.2

package/dist/GestureMapController.d.ts

@@ -0,0 +1,41 @@
+import type { GestureMapControllerConfig } from './types.js';
+/**
+ * GestureMapController
+ *
+ * Top-level public API. Wires together all subsystems:
+ *   GestureController → GestureStateMachine → OpenLayersGestureInteraction
+ *                                           ↘ WebcamOverlay
+ *
+ * Usage:
+ *   const ctrl = new GestureMapController({ map });
+ *   await ctrl.start();
+ *   // …
+ *   ctrl.stop();
+ */
+export declare class GestureMapController {
+    private config;
+    private gestureController;
+    private stateMachine;
+    private overlay;
+    private interaction;
+    private lastFrame;
+    private rafHandle;
+    private started;
+    private paused;
+    constructor(userConfig: GestureMapControllerConfig);
+    /**
+     * Initialise webcam + MediaPipe, mount overlay, begin detection loop.
+     * Must be called from a user-gesture event (e.g. button click) to allow
+     * webcam permission prompt.
+     */
+    start(): Promise<void>;
+    /** Stop detection and remove overlay. */
+    stop(): void;
+    /** Pause detection (overlay stays visible but inactive). */
+    pause(): void;
+    /** Resume after pause. */
+    resume(): void;
+    private renderLoop;
+    private handleVisibilityChange;
+    private logDebug;
+}

package/dist/GestureMapController.js

@@ -0,0 +1,168 @@
+import { DEFAULT_WEBCAM_CONFIG, DEFAULT_TUNING_CONFIG, GestureController, GestureStateMachine, WebcamOverlay, } from '@map-gesture-controls/core';
+import { OpenLayersGestureInteraction } from './OpenLayersGestureInteraction.js';
+/**
+ * GestureMapController
+ *
+ * Top-level public API. Wires together all subsystems:
+ *   GestureController → GestureStateMachine → OpenLayersGestureInteraction
+ *                                           ↘ WebcamOverlay
+ *
+ * Usage:
+ *   const ctrl = new GestureMapController({ map });
+ *   await ctrl.start();
+ *   // …
+ *   ctrl.stop();
+ */
+export class GestureMapController {
+    constructor(userConfig) {
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "gestureController", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "stateMachine", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "overlay", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "interaction", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "lastFrame", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "rafHandle", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "started", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "paused", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "handleVisibilityChange", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => {
+                if (document.hidden) {
+                    this.pause();
+                }
+                else {
+                    this.resume();
+                }
+            }
+        });
+        const webcamConfig = { ...DEFAULT_WEBCAM_CONFIG, ...userConfig.webcam };
+        const tuningConfig = { ...DEFAULT_TUNING_CONFIG, ...userConfig.tuning };
+        this.config = {
+            map: userConfig.map,
+            webcam: webcamConfig,
+            tuning: tuningConfig,
+            debug: userConfig.debug ?? false,
+        };
+        this.gestureController = new GestureController(tuningConfig, (frame) => {
+            this.lastFrame = frame;
+        });
+        this.stateMachine = new GestureStateMachine(tuningConfig);
+        this.overlay = new WebcamOverlay(webcamConfig);
+        this.interaction = new OpenLayersGestureInteraction(userConfig.map);
+    }
+    /**
+     * Initialise webcam + MediaPipe, mount overlay, begin detection loop.
+     * Must be called from a user-gesture event (e.g. button click) to allow
+     * webcam permission prompt.
+     */
+    async start() {
+        if (this.started)
+            return;
+        this.started = true;
+        const videoEl = await this.gestureController.init();
+        this.overlay.attachVideo(videoEl);
+        const mapTarget = this.config.map.getTargetElement();
+        this.overlay.mount(mapTarget ?? document.body);
+        this.gestureController.start();
+        this.renderLoop();
+        // Pause when tab is hidden to save resources
+        document.addEventListener('visibilitychange', this.handleVisibilityChange);
+    }
+    /** Stop detection and remove overlay. */
+    stop() {
+        this.gestureController.destroy();
+        this.overlay.unmount();
+        this.stateMachine.reset();
+        if (this.rafHandle !== null) {
+            cancelAnimationFrame(this.rafHandle);
+            this.rafHandle = null;
+        }
+        document.removeEventListener('visibilitychange', this.handleVisibilityChange);
+        this.started = false;
+        this.paused = false;
+    }
+    /** Pause detection (overlay stays visible but inactive). */
+    pause() {
+        this.paused = true;
+        this.gestureController.stop();
+        this.stateMachine.reset();
+    }
+    /** Resume after pause. */
+    resume() {
+        if (!this.paused)
+            return;
+        this.paused = false;
+        this.gestureController.start();
+    }
+    renderLoop() {
+        this.rafHandle = requestAnimationFrame(() => this.renderLoop());
+        if (this.paused) {
+            this.overlay.render(null, 'idle');
+            return;
+        }
+        const frame = this.lastFrame;
+        if (frame === null) {
+            this.overlay.render(null, 'idle');
+            return;
+        }
+        const output = this.stateMachine.update(frame);
+        this.interaction.apply(output);
+        this.overlay.render(frame, output.mode);
+        if (this.config.debug) {
+            this.logDebug(output.mode, frame);
+        }
+    }
+    logDebug(mode, frame) {
+        const hands = frame.hands
+            .map((h) => `${h.handedness}:${h.gesture}(${h.score.toFixed(2)})`)
+            .join(' ');
+        console.debug(`[ol-gestures] mode=${mode} ${hands}`);
+    }
+}

package/dist/OpenLayersGestureInteraction.d.ts

@@ -0,0 +1,30 @@
+import type Map from 'ol/Map.js';
+import type { StateMachineOutput } from '@map-gesture-controls/core';
+/**
+ * OpenLayersGestureInteraction
+ *
+ * Translates GestureStateMachine output into actual OL map movements.
+ *
+ * Pan:  normalised hand delta → pixel offset → new map center
+ * Zoom: two-hand index-finger distance delta → zoom level change (hands apart = zoom in)
+ */
+export declare class OpenLayersGestureInteraction {
+    private map;
+    private panScale;
+    private zoomScale;
+    constructor(map: Map);
+    /**
+     * Apply a state machine output frame to the map.
+     * Safe to call every animation frame.
+     */
+    apply(output: StateMachineOutput): void;
+    /**
+     * Pan map by a normalised delta (0–1 range from webcam space).
+     * dx/dy are hand movement as a fraction of frame width/height.
+     */
+    private pan;
+    /**
+     * Zoom map. delta > 0 = zoom in, delta < 0 = zoom out.
+     */
+    private zoom;
+}

package/dist/OpenLayersGestureInteraction.js

@@ -0,0 +1,87 @@
+import { getCenter } from 'ol/extent.js';
+/**
+ * OpenLayersGestureInteraction
+ *
+ * Translates GestureStateMachine output into actual OL map movements.
+ *
+ * Pan:  normalised hand delta → pixel offset → new map center
+ * Zoom: two-hand index-finger distance delta → zoom level change (hands apart = zoom in)
+ */
+export class OpenLayersGestureInteraction {
+    constructor(map) {
+        Object.defineProperty(this, "map", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "panScale", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 2.0
+        });
+        // Two-hand distance delta is ~0.005–0.02 per frame at natural speed.
+        // zoomScale=4.0 ≈ 1.2 zoom levels/sec at 30fps. Adjust to taste.
+        Object.defineProperty(this, "zoomScale", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 4.0
+        });
+        this.map = map;
+    }
+    /**
+     * Apply a state machine output frame to the map.
+     * Safe to call every animation frame.
+     */
+    apply(output) {
+        if (output.panDelta) {
+            this.pan(output.panDelta.x, output.panDelta.y);
+        }
+        if (output.zoomDelta !== null) {
+            this.zoom(output.zoomDelta);
+        }
+    }
+    /**
+     * Pan map by a normalised delta (0–1 range from webcam space).
+     * dx/dy are hand movement as a fraction of frame width/height.
+     */
+    pan(dx, dy) {
+        const view = this.map.getView();
+        const resolution = view.getResolution();
+        if (resolution === undefined)
+            return;
+        const size = this.map.getSize();
+        if (!size)
+            return;
+        const [mapW, mapH] = size;
+        // Convert normalised webcam delta to map pixels, then to map coords.
+        // Webcam is mirrored so negate dx.
+        const pixelDx = -dx * mapW * this.panScale;
+        const pixelDy = dy * mapH * this.panScale;
+        const center = view.getCenter();
+        if (!center)
+            return;
+        view.setCenter([
+            center[0] - pixelDx * resolution,
+            center[1] + pixelDy * resolution,
+        ]);
+    }
+    /**
+     * Zoom map. delta > 0 = zoom in, delta < 0 = zoom out.
+     */
+    zoom(delta) {
+        const view = this.map.getView();
+        const currentZoom = view.getZoom();
+        if (currentZoom === undefined)
+            return;
+        const extent = view.calculateExtent(this.map.getSize());
+        const zoomCenter = getCenter(extent);
+        view.animate({
+            zoom: currentZoom + delta * this.zoomScale,
+            center: zoomCenter,
+            duration: 0,
+        });
+    }
+}

package/dist/OpenLayersGestureInteraction.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/OpenLayersGestureInteraction.test.js

@@ -0,0 +1,137 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { OpenLayersGestureInteraction } from './OpenLayersGestureInteraction.js';
+// ─── Minimal OL map mock ──────────────────────────────────────────────────────
+function makeMapMock(opts = {}) {
+    const center = opts.center ?? [0, 0];
+    const zoom = opts.zoom ?? 5;
+    const resolution = opts.resolution ?? 100;
+    const size = opts.size ?? [800, 600];
+    const setCenter = vi.fn();
+    const animate = vi.fn();
+    const view = {
+        getResolution: () => resolution,
+        getZoom: () => zoom,
+        getCenter: () => [...center],
+        setCenter,
+        animate,
+        calculateExtent: (_size) => [
+            center[0] - 400 * resolution,
+            center[1] - 300 * resolution,
+            center[0] + 400 * resolution,
+            center[1] + 300 * resolution,
+        ],
+    };
+    const map = {
+        getView: () => view,
+        getSize: () => size,
+    };
+    return { map, view, setCenter, animate };
+}
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+function idle() {
+    return { mode: 'idle', panDelta: null, zoomDelta: null };
+}
+function panning(dx, dy) {
+    return { mode: 'panning', panDelta: { x: dx, y: dy }, zoomDelta: null };
+}
+function zooming(delta) {
+    return { mode: 'zooming', panDelta: null, zoomDelta: delta };
+}
+// ─── Tests ────────────────────────────────────────────────────────────────────
+describe('OpenLayersGestureInteraction', () => {
+    let interaction;
+    let mocks;
+    beforeEach(() => {
+        mocks = makeMapMock({ center: [0, 0], zoom: 5, resolution: 100, size: [800, 600] });
+        // @ts-expect-error - we pass a minimal mock, not a full ol/Map instance
+        interaction = new OpenLayersGestureInteraction(mocks.map);
+    });
+    // ── idle output does nothing ───────────────────────────────────────────────
+    it('does not call setCenter or animate for idle output', () => {
+        interaction.apply(idle());
+        expect(mocks.setCenter).not.toHaveBeenCalled();
+        expect(mocks.animate).not.toHaveBeenCalled();
+    });
+    // ── pan ───────────────────────────────────────────────────────────────────
+    it('calls view.setCenter when panDelta is present', () => {
+        interaction.apply(panning(0.1, 0.0));
+        expect(mocks.setCenter).toHaveBeenCalledOnce();
+    });
+    it('negates dx (webcam mirror) and applies panScale', () => {
+        const dx = 0.1;
+        const dy = 0.0;
+        const resolution = 100;
+        const mapW = 800;
+        const panScale = 2.0;
+        interaction.apply(panning(dx, dy));
+        const [newCenter] = mocks.setCenter.mock.calls[0];
+        // pixelDx = -dx * mapW * panScale = -0.1 * 800 * 2 = -160
+        // newCenter[0] = 0 - (-160) * 100 = 16000
+        expect(newCenter[0]).toBeCloseTo(-(-dx * mapW * panScale) * resolution);
+    });
+    it('applies positive dy upward (map y increases with view y)', () => {
+        const dy = 0.05;
+        const resolution = 100;
+        const mapH = 600;
+        const panScale = 2.0;
+        interaction.apply(panning(0, dy));
+        const [newCenter] = mocks.setCenter.mock.calls[0];
+        // pixelDy = dy * mapH * panScale = 0.05 * 600 * 2 = 60
+        // newCenter[1] = 0 + 60 * 100 = 6000
+        expect(newCenter[1]).toBeCloseTo(dy * mapH * panScale * resolution);
+    });
+    it('does not call setCenter when panDelta is null', () => {
+        interaction.apply(idle());
+        expect(mocks.setCenter).not.toHaveBeenCalled();
+    });
+    // ── zoom ──────────────────────────────────────────────────────────────────
+    it('calls view.animate when zoomDelta is present', () => {
+        interaction.apply(zooming(0.01));
+        expect(mocks.animate).toHaveBeenCalledOnce();
+    });
+    it('applies zoomScale to zoomDelta', () => {
+        const delta = 0.01;
+        const zoomScale = 4.0;
+        const currentZoom = 5;
+        interaction.apply(zooming(delta));
+        const args = mocks.animate.mock.calls[0][0];
+        expect(args.zoom).toBeCloseTo(currentZoom + delta * zoomScale);
+        expect(args.duration).toBe(0);
+    });
+    it('zooms in (positive delta) increases zoom level', () => {
+        interaction.apply(zooming(0.02));
+        const args = mocks.animate.mock.calls[0][0];
+        expect(args.zoom).toBeGreaterThan(5);
+    });
+    it('zooms out (negative delta) decreases zoom level', () => {
+        interaction.apply(zooming(-0.02));
+        const args = mocks.animate.mock.calls[0][0];
+        expect(args.zoom).toBeLessThan(5);
+    });
+    it('does not call animate when zoomDelta is null', () => {
+        interaction.apply(idle());
+        expect(mocks.animate).not.toHaveBeenCalled();
+    });
+    // ── gracefully handles missing view data ──────────────────────────────────
+    it('does not throw when resolution is undefined', () => {
+        const { map } = makeMapMock();
+        map.getView().getResolution = () => undefined;
+        // @ts-expect-error
+        const i = new OpenLayersGestureInteraction(map);
+        expect(() => i.apply(panning(0.1, 0.1))).not.toThrow();
+    });
+    it('does not throw when map size is undefined', () => {
+        const { map } = makeMapMock();
+        map.getSize = () => undefined;
+        // @ts-expect-error
+        const i = new OpenLayersGestureInteraction(map);
+        expect(() => i.apply(panning(0.1, 0.1))).not.toThrow();
+    });
+    it('does not throw when zoom is undefined', () => {
+        const { map } = makeMapMock();
+        map.getView().getZoom = () => undefined;
+        // @ts-expect-error
+        const i = new OpenLayersGestureInteraction(map);
+        expect(() => i.apply(zooming(0.01))).not.toThrow();
+    });
+});

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { GestureMapController } from './GestureMapController.js';
+export { OpenLayersGestureInteraction } from './OpenLayersGestureInteraction.js';
+export type { GestureMapControllerConfig } from './types.js';
+export { GestureController, GestureStateMachine, WebcamOverlay, classifyGesture, getHandSize, getTwoHandDistance, DEFAULT_WEBCAM_CONFIG, DEFAULT_TUNING_CONFIG, LANDMARKS, COLORS, } from '@map-gesture-controls/core';
+export type { GestureMode, GestureType, HandednessLabel, GestureFrame, DetectedHand, WebcamConfig, TuningConfig, StateMachineOutput, SmoothedPoint, Point2D, HandLandmark, } from '@map-gesture-controls/core';

package/dist/index.js

@@ -0,0 +1,134 @@
+var d = Object.defineProperty;
+var m = (a, e, t) => e in a ? d(a, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : a[e] = t;
+var s = (a, e, t) => m(a, typeof e != "symbol" ? e + "" : e, t);
+import { DEFAULT_WEBCAM_CONFIG as p, DEFAULT_TUNING_CONFIG as g, GestureController as f, GestureStateMachine as y, WebcamOverlay as C } from "@map-gesture-controls/core";
+import { COLORS as L, DEFAULT_TUNING_CONFIG as S, DEFAULT_WEBCAM_CONFIG as E, GestureController as M, GestureStateMachine as A, LANDMARKS as N, WebcamOverlay as O, classifyGesture as T, getHandSize as H, getTwoHandDistance as _ } from "@map-gesture-controls/core";
+function v(a) {
+  return [(a[0] + a[2]) / 2, (a[1] + a[3]) / 2];
+}
+class b {
+  constructor(e) {
+    s(this, "map");
+    s(this, "panScale", 2);
+    // Two-hand distance delta is ~0.005–0.02 per frame at natural speed.
+    // zoomScale=4.0 ≈ 1.2 zoom levels/sec at 30fps. Adjust to taste.
+    s(this, "zoomScale", 4);
+    this.map = e;
+  }
+  /**
+   * Apply a state machine output frame to the map.
+   * Safe to call every animation frame.
+   */
+  apply(e) {
+    e.panDelta && this.pan(e.panDelta.x, e.panDelta.y), e.zoomDelta !== null && this.zoom(e.zoomDelta);
+  }
+  /**
+   * Pan map by a normalised delta (0–1 range from webcam space).
+   * dx/dy are hand movement as a fraction of frame width/height.
+   */
+  pan(e, t) {
+    const n = this.map.getView(), i = n.getResolution();
+    if (i === void 0) return;
+    const r = this.map.getSize();
+    if (!r) return;
+    const [l, h] = r, c = -e * l * this.panScale, u = t * h * this.panScale, o = n.getCenter();
+    o && n.setCenter([
+      o[0] - c * i,
+      o[1] + u * i
+    ]);
+  }
+  /**
+   * Zoom map. delta > 0 = zoom in, delta < 0 = zoom out.
+   */
+  zoom(e) {
+    const t = this.map.getView(), n = t.getZoom();
+    if (n === void 0) return;
+    const i = t.calculateExtent(this.map.getSize()), r = v(i);
+    t.animate({
+      zoom: n + e * this.zoomScale,
+      center: r,
+      duration: 0
+    });
+  }
+}
+class w {
+  constructor(e) {
+    s(this, "config");
+    s(this, "gestureController");
+    s(this, "stateMachine");
+    s(this, "overlay");
+    s(this, "interaction");
+    s(this, "lastFrame", null);
+    s(this, "rafHandle", null);
+    s(this, "started", !1);
+    s(this, "paused", !1);
+    s(this, "handleVisibilityChange", () => {
+      document.hidden ? this.pause() : this.resume();
+    });
+    const t = { ...p, ...e.webcam }, n = { ...g, ...e.tuning };
+    this.config = {
+      map: e.map,
+      webcam: t,
+      tuning: n,
+      debug: e.debug ?? !1
+    }, this.gestureController = new f(n, (i) => {
+      this.lastFrame = i;
+    }), this.stateMachine = new y(n), this.overlay = new C(t), this.interaction = new b(e.map);
+  }
+  /**
+   * Initialise webcam + MediaPipe, mount overlay, begin detection loop.
+   * Must be called from a user-gesture event (e.g. button click) to allow
+   * webcam permission prompt.
+   */
+  async start() {
+    if (this.started) return;
+    this.started = !0;
+    const e = await this.gestureController.init();
+    this.overlay.attachVideo(e);
+    const t = this.config.map.getTargetElement();
+    this.overlay.mount(t ?? document.body), this.gestureController.start(), this.renderLoop(), document.addEventListener("visibilitychange", this.handleVisibilityChange);
+  }
+  /** Stop detection and remove overlay. */
+  stop() {
+    this.gestureController.destroy(), this.overlay.unmount(), this.stateMachine.reset(), this.rafHandle !== null && (cancelAnimationFrame(this.rafHandle), this.rafHandle = null), document.removeEventListener("visibilitychange", this.handleVisibilityChange), this.started = !1, this.paused = !1;
+  }
+  /** Pause detection (overlay stays visible but inactive). */
+  pause() {
+    this.paused = !0, this.gestureController.stop(), this.stateMachine.reset();
+  }
+  /** Resume after pause. */
+  resume() {
+    this.paused && (this.paused = !1, this.gestureController.start());
+  }
+  renderLoop() {
+    if (this.rafHandle = requestAnimationFrame(() => this.renderLoop()), this.paused) {
+      this.overlay.render(null, "idle");
+      return;
+    }
+    const e = this.lastFrame;
+    if (e === null) {
+      this.overlay.render(null, "idle");
+      return;
+    }
+    const t = this.stateMachine.update(e);
+    this.interaction.apply(t), this.overlay.render(e, t.mode), this.config.debug && this.logDebug(t.mode, e);
+  }
+  logDebug(e, t) {
+    const n = t.hands.map((i) => `${i.handedness}:${i.gesture}(${i.score.toFixed(2)})`).join(" ");
+    console.debug(`[ol-gestures] mode=${e} ${n}`);
+  }
+}
+export {
+  L as COLORS,
+  S as DEFAULT_TUNING_CONFIG,
+  E as DEFAULT_WEBCAM_CONFIG,
+  M as GestureController,
+  w as GestureMapController,
+  A as GestureStateMachine,
+  N as LANDMARKS,
+  b as OpenLayersGestureInteraction,
+  O as WebcamOverlay,
+  T as classifyGesture,
+  H as getHandSize,
+  _ as getTwoHandDistance
+};

package/dist/types.d.ts

@@ -0,0 +1,7 @@
+import type { WebcamConfig, TuningConfig } from '@map-gesture-controls/core';
+export interface GestureMapControllerConfig {
+    map: import('ol').Map;
+    webcam?: Partial<WebcamConfig>;
+    tuning?: Partial<TuningConfig>;
+    debug?: boolean;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@map-gesture-controls/ol",
+  "version": "0.1.2",
+  "description": "Control OpenLayers maps with hand gestures via MediaPipe",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./style.css": "./dist/style.css"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build:lib": "tsc -p tsconfig.lib.json && vite build --config vite.lib.config.ts",
+    "type-check": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@map-gesture-controls/core": "*"
+  },
+  "peerDependencies": {
+    "ol": "^10.2.1"
+  },
+  "devDependencies": {
+    "ol": "^10.2.1",
+    "typescript": "^5.4.5",
+    "vite": "^5.2.11"
+  },
+  "keywords": [
+    "openlayers",
+    "mediapipe",
+    "hand-gestures",
+    "map",
+    "gesture-control"
+  ],
+  "overrides": {
+    "esbuild": "^0.25.0"
+  },
+  "license": "MIT"
+}