@sepveneto/dao 0.0.5 → 0.1.1

package/dist/scene/text/utils.d.ts

@@ -0,0 +1,74 @@
+import { CanvasAndContext } from '../../renderer/CanvasPool';
+import { TextStyle } from './TextStyle';
+import { Rectangle } from '../../maths/shapes/Rectangle';
+export declare const NEWLINE_MATCH_REGEX: RegExp;
+/**
+ * A number, or a string containing a number.
+ * @category text
+ * @typedef {object} FontMetrics
+ * @property {number} ascent - Font ascent
+ * @property {number} descent - Font descent
+ * @property {number} fontSize - Font size
+ * @advanced
+ */
+export interface FontMetrics {
+    ascent: number;
+    descent: number;
+    fontSize: number;
+}
+export declare class TextMetrics {
+    text: string;
+    style: TextStyle;
+    width: number;
+    height: number;
+    lines: string[];
+    lineWidths: number[];
+    lineHeight: number;
+    maxLineWidth: number;
+    fontProperties: FontMetrics;
+    /**
+      * String used for calculate font metrics.
+      * These characters are all tall to help calculate the height required for text.
+      */
+    static METRICS_STRING: string;
+    /** Baseline symbol for calculate font metrics. */
+    static BASELINE_SYMBOL: string;
+    private static _canvas;
+    private static _context;
+    private static readonly _measurementCache;
+    /** Cache of {@link TextMetrics.FontMetrics} objects. */
+    private static _fonts;
+    constructor(text: string, style: TextStyle, width: number, height: number, lines: string[], lineWidths: number[], lineHeight: number, maxLineWidth: number, fontProperties: FontMetrics);
+    static get canvas(): HTMLCanvasElement | OffscreenCanvas;
+    static get context(): CanvasRenderingContext2D;
+    static measureText(text: string, style: TextStyle): TextMetrics;
+    static _measureText(text: string, letterSpacing: number): number;
+    /**
+      * A Unicode "character", or "grapheme cluster", can be composed of multiple Unicode code points,
+      * such as letters with diacritical marks (e.g. `'\u0065\u0301'`, letter e with acute)
+      * or emojis with modifiers (e.g. `'\uD83E\uDDD1\u200D\uD83D\uDCBB'`, technologist).
+      * The new `Intl.Segmenter` API in ES2022 can split the string into grapheme clusters correctly. If it is not available,
+      * PixiJS will fallback to use the iterator of String, which can only spilt the string into code points.
+      * If you want to get full functionality in environments that don't support `Intl.Segmenter` (such as Firefox),
+      * you can use other libraries such as [grapheme-splitter]{@link https://www.npmjs.com/package/grapheme-splitter}
+      * or [graphemer]{@link https://www.npmjs.com/package/graphemer} to create a polyfill. Since these libraries can be
+      * relatively large in size to handle various Unicode grapheme clusters properly, PixiJS won't use them directly.
+      */
+    static graphemeSegmenter: (s: string) => string[];
+    /**
+      * Calculates the ascent, descent and fontSize of a given font-style
+      * @param font - String representing the style of the font
+      * @returns Font properties object
+      */
+    static measureFont(font: string): FontMetrics;
+}
+export declare function createCanvas(width?: number, height?: number): HTMLCanvasElement;
+export declare function generateTextTexture(options: {
+    text: string;
+    style: TextStyle;
+    resolution?: number;
+    padding?: number;
+}): {
+    canvasAndContext: CanvasAndContext;
+    frame: Rectangle;
+};

package/dist/system/CanvasContextSystem.d.ts

@@ -0,0 +1,15 @@
+import { Matrix } from '../maths';
+import { CanvasRenderer } from '../renderer';
+export declare class CanvasContextSystem {
+    static desc: {
+        readonly name: "canvasContext";
+    };
+    private _renderer;
+    rootContext: CanvasRenderingContext2D;
+    activeConext: CanvasRenderingContext2D;
+    activeResolution: number;
+    globalTransform: Matrix;
+    constructor(renderer: CanvasRenderer);
+    init(): void;
+    setContextTransform(transform: Matrix, roundPixels?: boolean, localResolution?: number): void;
+}

package/dist/system/EventSystem.d.ts

@@ -1,8 +1,52 @@
-type EventKey = string | Symbol;
+import { Container } from '../scene/container/Container';
+import { CanvasRenderer } from '../renderer';
+import { Vector2 } from '../maths';
+import { FederatedEventMap } from '../events/FederatedEventMap';
+import { FederatedEvent } from '../events/FederatedEvent';
+export type EventMode = 'none' | 'static' | 'passive';
+type EmitterListener = {
+    fn(...args: any[]): any;
+    context: any;
+    once: boolean;
+};
+export type EmitterListeners = Record<string, EmitterListener | EmitterListener[]>;
 export declare class EventSystem {
-    private events;
-    on(type: EventKey, callback: Function): void;
-    off(type: EventKey, callback: Function): void;
-    emit(type: EventKey, ...args: any[]): void;
+    renderer: CanvasRenderer;
+    domElement: HTMLElement;
+    rootTarget: Container;
+    resolution: number;
+    private readonly _allInteractiveElements;
+    private _hitElements;
+    private _isPointerMoveEvent;
+    private mappingState;
+    static desc: {
+        readonly name: "events";
+    };
+    constructor(renderer: CanvasRenderer);
+    /**
+     *
+     * @param id pointerId
+     */
+    private trackingData;
+    init(): void;
+    setTargetElement(element: HTMLElement): void;
+    dispatchEvent(e: FederatedEvent, type: keyof FederatedEventMap): void;
+    private _notifyTarget;
+    propagationPath(target: Container): Container<import('../scene/container/Container').ContainerChild>[];
+    _removeEvents(): void;
+    _addEvents(): void;
+    _onPointerMove(event: PointerEvent): void;
+    _onPointerDown(event: PointerEvent): void;
+    _onPointerOverOut(event: PointerEvent): void;
+    _onPointerUp(event: PointerEvent): void;
+    _isInteractive(eventMode: EventMode): eventMode is "static";
+    createPointEvent(from: PointerEvent, type?: string, target?: Container): FederatedEvent;
+    clonePointEvent(from: FederatedEvent, type?: string): FederatedEvent;
+    mapPositionToPoint(x: number, y: number): Vector2;
+    hitTest(x: number, y: number): Container<import('../scene/container/Container').ContainerChild>;
+    private _interactivePrune;
+    hitTestMoveRecursive(currentTarget: Container, eventMode: EventMode, location: Vector2): Container[];
+    hitTestRecursive(currentTarget: Container, eventMode: EventMode, location: Vector2): Container[];
+    hitTestFn(container: Container, pos: Vector2): boolean;
 }
 export {};

package/dist/system/ExtractSystem.d.ts

@@ -0,0 +1,18 @@
+import { Rectangle } from '../maths';
+import { CanvasRenderer } from '../renderer';
+import { RenderTexture } from '../renderer/texture/RenderTexture';
+import { Container } from '../scene';
+export type GenerateTextureOptions = {
+    target: Container;
+    frame?: Rectangle;
+    resolution?: number;
+};
+export declare class ExtractSystem {
+    static desc: {
+        readonly name: "extract";
+    };
+    private _renderer;
+    constructor(renderer: CanvasRenderer);
+    texture(options: Container): RenderTexture;
+    private _generateTexture;
+}

package/dist/system/RenderGroupSystem.d.ts

@@ -0,0 +1,16 @@
+import { Matrix } from '../maths';
+import { CanvasRenderer } from '../renderer';
+import { Container, RenderGroup } from '../scene';
+export declare class RenderGroupSystem {
+    renderer: CanvasRenderer;
+    static desc: {
+        readonly name: "renderGroup";
+    };
+    constructor(renderer: CanvasRenderer);
+    private _updateRenderGroup;
+    render({ container, transform }: {
+        container: Container;
+        transform: Matrix;
+    }): void;
+    _buildInstructions(renderGroup: RenderGroup, renderer: CanvasRenderer): void;
+}

package/dist/system/ViewSystem.d.ts

@@ -0,0 +1,22 @@
+import { Rectangle } from '../maths';
+import { Texture } from '../renderer/texture/Texture';
+import { CanvasSource } from '../renderer/texture/TextureSource';
+export type ViewSystemOptions = {
+    width?: number;
+    height?: number;
+    resolution?: number;
+    autoDensity?: boolean;
+};
+export declare class ViewSystem {
+    static desc: {
+        readonly name: "view";
+    };
+    static defaultOptions: ViewSystemOptions;
+    canvas: HTMLCanvasElement;
+    screen: Rectangle;
+    texture: Texture<CanvasSource>;
+    get resolution(): number;
+    set resolution(value: number);
+    init(options: ViewSystemOptions): void;
+    resize(width: number, height: number, resolution: number): void;
+}

package/dist/system/index.d.ts

@@ -0,0 +1,2 @@
+export * from './EventSystem';
+export * from './RenderGroupSystem';

package/dist/ticker/Ticker.d.ts

@@ -0,0 +1,290 @@
+export type TickerCallback<T> = (this: T, ticker: Ticker) => any;
+export declare class Ticker {
+    /**
+      * Target frame rate in frames per millisecond.
+      * Used for converting deltaTime to a scalar time delta.
+      * @example
+      * ```ts
+      * // Default is 0.06 (60 FPS)
+      * console.log(Ticker.targetFPMS); // 0.06
+      *
+      * // Calculate target frame duration
+      * const frameDuration = 1 / Ticker.targetFPMS; // ≈ 16.67ms
+      *
+      * // Use in custom timing calculations
+      * const deltaTime = elapsedMS * Ticker.targetFPMS;
+      * ```
+      * @remarks
+      * - Default is 0.06 (equivalent to 60 FPS)
+      * - Used in deltaTime calculations
+      * - Affects all ticker instances
+      * @default 0.06
+      * @see {@link Ticker#deltaTime} For time scaling
+      * @see {@link Ticker#FPS} For actual frame rate
+      */
+    static targetFPMS: number;
+    /**
+      * Whether or not this ticker should invoke the method {@link Ticker#start|start}
+      * automatically when a listener is added.
+      * @example
+      * ```ts
+      * // Default behavior (manual start)
+      * const ticker = new Ticker();
+      * ticker.autoStart = false;
+      * ticker.add(() => {
+      *     // Won't run until ticker.start() is called
+      * });
+      *
+      * // Auto-start behavior
+      * const autoTicker = new Ticker();
+      * autoTicker.autoStart = true;
+      * autoTicker.add(() => {
+      *     // Runs immediately when added
+      * });
+      * ```
+      * @default false
+      * @see {@link Ticker#start} For manually starting the ticker
+      * @see {@link Ticker#stop} For manually stopping the ticker
+      */
+    autoStart: boolean;
+    /**
+      * Scalar representing the delta time factor.
+      * This is a dimensionless value representing the fraction of a frame at the target framerate.
+      * At 60 FPS, this value is typically around 1.0.
+      *
+      * This is NOT in milliseconds - it's a scalar multiplier for frame-independent animations.
+      * For actual milliseconds, use {@link Ticker#deltaMS}.
+      * @example
+      * ```ts
+      * // Frame-independent animation using deltaTime scalar
+      * ticker.add((ticker) => {
+      *     // Rotate sprite by 0.1 radians per frame, scaled by deltaTime
+      *     sprite.rotation += 0.1 * ticker.deltaTime;
+      * });
+      * ```
+      */
+    deltaTime: number;
+    /**
+      * Scalar time elapsed in milliseconds from last frame to this frame.
+      * Provides precise timing for animations and updates.
+      *
+      * This value is capped by setting {@link Ticker#minFPS|minFPS}
+      * and is scaled with {@link Ticker#speed|speed}.
+      *
+      * If the platform supports DOMHighResTimeStamp,
+      * this value will have a precision of 1 µs.
+      *
+      * Defaults to target frame time
+      *
+      * > [!NOTE] The cap may be exceeded by scaling.
+      * @example
+      * ```ts
+      * // Animation timing
+      * ticker.add((ticker) => {
+      *     // Use millisecond timing for precise animations
+      *     const progress = (ticker.deltaMS / animationDuration);
+      *     sprite.alpha = Math.min(1, progress);
+      * });
+      * ```
+      * @default 16.66
+      */
+    deltaMS: number;
+    /**
+      * Time elapsed in milliseconds from the last frame to this frame.
+      * This value is not capped or scaled and provides raw timing information.
+      *
+      * Unlike {@link Ticker#deltaMS}, this value is unmodified by speed scaling or FPS capping.
+      * @example
+      * ```ts
+      * ticker.add((ticker) => {
+      *     console.log(`Raw frame time: ${ticker.elapsedMS}ms`);
+      * });
+      * ```
+      */
+    elapsedMS: number;
+    /**
+      * The last time update was invoked, in milliseconds since epoch.
+      * Similar to performance.now() timestamp format.
+      *
+      * Used internally for calculating time deltas between frames.
+      * @example
+      * ```ts
+      * ticker.add((ticker) => {
+      *     const currentTime = performance.now();
+      *     const timeSinceLastFrame = currentTime - ticker.lastTime;
+      *     console.log(`Time since last frame: ${timeSinceLastFrame}ms`);
+      * });
+      * ```
+      */
+    lastTime: number;
+    /**
+      * Factor of current {@link Ticker#deltaTime|deltaTime}.
+      * Used to scale time for slow motion or fast-forward effects.
+      * @example
+      * ```ts
+      * // Basic speed adjustment
+      * ticker.speed = 0.5; // Half speed (slow motion)
+      * ticker.speed = 2.0; // Double speed (fast forward)
+      *
+      * // Temporary speed changes
+      * function slowMotion() {
+      *     const normalSpeed = ticker.speed;
+      *     ticker.speed = 0.2;
+      *     setTimeout(() => {
+      *         ticker.speed = normalSpeed;
+      *     }, 1000);
+      * }
+      * ```
+      */
+    speed: number;
+    /**
+      * Whether or not this ticker has been started.
+      *
+      * `true` if {@link Ticker#start|start} has been called.
+      * `false` if {@link Ticker#stop|Stop} has been called.
+      *
+      * While `false`, this value may change to `true` in the
+      * event of {@link Ticker#autoStart|autoStart} being `true`
+      * and a listener is added.
+      * @example
+      * ```ts
+      * // Check ticker state
+      * const ticker = new Ticker();
+      * console.log(ticker.started); // false
+      *
+      * // Start and verify
+      * ticker.start();
+      * console.log(ticker.started); // true
+      * ```
+      */
+    started: boolean;
+    /**
+      * Internal tick method bound to ticker instance.
+      * This is because in early 2015, Function.bind
+      * is still 60% slower in high performance scenarios.
+      * Also separating frame requests from update method
+      * so listeners may be called at any time and with
+      * any animation API, just invoke ticker.update(time).
+      * @param time - Time since last tick.
+      */
+    private readonly _tick;
+    /** Internal current frame request ID */
+    private _requestId;
+    /**
+      * Internal value managed by minFPS property setter and getter.
+      * This is the maximum allowed milliseconds between updates.
+      */
+    private _maxElapsedMS;
+    /**
+      * Internal value managed by maxFPS property setter and getter.
+      * This is the minimum allowed milliseconds between updates.
+      */
+    private _minElapsedMS;
+    /** The last time keyframe was executed. Maintains a relatively fixed interval with the previous value. */
+    private _lastFrame;
+    private _head;
+    constructor();
+    /**
+      * Triggers an update.
+      *
+      * An update entails setting the
+      * current {@link Ticker#elapsedMS|elapsedMS},
+      * the current {@link Ticker#deltaTime|deltaTime},
+      * invoking all listeners with current deltaTime,
+      * and then finally setting {@link Ticker#lastTime|lastTime}
+      * with the value of currentTime that was provided.
+      *
+      * This method will be called automatically by animation
+      * frame callbacks if the ticker instance has been started
+      * and listeners are added.
+      * @example
+      * ```ts
+      * // Basic manual update
+      * const ticker = new Ticker();
+      * ticker.update(performance.now());
+      * ```
+      * @param currentTime - The current time of execution (defaults to performance.now())
+      * @see {@link Ticker#deltaTime} For frame delta value
+      * @see {@link Ticker#elapsedMS} For raw elapsed time
+      */
+    update(currentTime?: number): void;
+    /**
+      * The frames per second at which this ticker is running.
+      * The default is approximately 60 in most modern browsers.
+      * > [!NOTE] This does not factor in the value of
+      * > {@link Ticker#speed|speed}, which is specific
+      * > to scaling {@link Ticker#deltaTime|deltaTime}.
+      * @example
+      * ```ts
+      * // Basic FPS monitoring
+      * ticker.add(() => {
+      *     console.log(`Current FPS: ${Math.round(ticker.FPS)}`);
+      * });
+      * ```
+      * @readonly
+      */
+    get FPS(): number;
+    /**
+      * Manages the minimum amount of milliseconds required to
+      * elapse between invoking {@link Ticker#update|update}.
+      *
+      * This will effect the measured value of {@link Ticker#FPS|FPS}.
+      *
+      * If it is set to `0`, then there is no limit; PixiJS will render as many frames as it can.
+      * Otherwise it will be at least `minFPS`.
+      *
+      * If `maxFPS` is set below the current `minFPS`, `minFPS` is automatically lowered to match.
+      * This keeps the two limits consistent.
+      * @example
+      * ```ts
+      * // Cap the frame rate
+      * const ticker = new Ticker();
+      * ticker.maxFPS = 60; // Never go above 60 FPS
+      *
+      * // Use with minFPS for frame rate clamping
+      * ticker.minFPS = 30;
+      * ticker.maxFPS = 60;
+      *
+      * // maxFPS below minFPS pushes minFPS down
+      * ticker.maxFPS = 20; // minFPS is now also 20
+      * ```
+      * @default 0
+      */
+    get maxFPS(): number;
+    set maxFPS(value: number);
+    /**
+      * Manages the maximum amount of milliseconds allowed to
+      * elapse between invoking {@link Ticker#update|update}.
+      *
+      * This value is used to cap {@link Ticker#deltaTime|deltaTime},
+      * but does not effect the measured value of {@link Ticker#FPS|FPS}.
+      *
+      * When setting this property it is clamped to a value between
+      * `0` and `Ticker.targetFPMS * 1000` (typically 60).
+      *
+      * If `maxFPS` is currently set (non-zero) and `minFPS` is set above it,
+      * `maxFPS` is automatically raised to match. This keeps the two limits consistent.
+      * @example
+      * ```ts
+      * // Set minimum acceptable frame rate
+      * const ticker = new Ticker();
+      * ticker.minFPS = 30; // Never go below 30 FPS
+      *
+      * // Use with maxFPS for frame rate clamping
+      * ticker.minFPS = 30;
+      * ticker.maxFPS = 60;
+      *
+      * // minFPS above maxFPS pushes maxFPS up
+      * ticker.minFPS = 50; // maxFPS is raised to 50
+      * ```
+      * @default 10
+      */
+    get minFPS(): number;
+    set minFPS(value: number);
+    add<T = any>(fn: TickerCallback<T>, context?: T, priority?: number): this;
+    start(): void;
+    remove<T>(fn: TickerCallback<T>, context?: T): this;
+    private _startIfPossible;
+    private _requestIfNeeded;
+    private _cancelIfNeeded;
+}

package/dist/ticker/TickerListener.d.ts

@@ -0,0 +1,21 @@
+import { Ticker, TickerCallback } from './Ticker';
+export declare class TickerListener<T = any> {
+    next: TickerListener;
+    previous: TickerListener;
+    priority: number;
+    private _fn;
+    private _context;
+    private _once;
+    private _destroyed;
+    constructor(fn: TickerCallback<T>, context: T, priority?: number, once?: boolean);
+    match(fn: TickerCallback<T>, context?: any): boolean;
+    emit(ticker: Ticker): TickerListener<any>;
+    /**
+      * Destroy and don't use after this.
+      * @param hard - `true` to remove the `next` reference, this
+      *        is considered a hard destroy. Soft destroy maintains the next reference.
+      * @returns The listener to redirect while emitting or removing.
+      */
+    destroy(hard?: boolean): TickerListener<any>;
+    connect(previous: TickerListener): void;
+}

package/dist/ticker/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Ticker';
+export * from './TickerListener';

package/dist/utils/index.d.ts

@@ -0,0 +1,12 @@
+import { Bounds } from '../maths/Bounds';
+import { ObservablePoint } from '../maths/Point';
+import { Texture } from '../renderer/texture/Texture';
+export * from './uid';
+export declare function loadImage(url: string): Promise<{
+    image: HTMLImageElement;
+    w: number;
+    h: number;
+}>;
+export declare function createDebug(ns: string): (...args: any[]) => void;
+export declare function updateBounds(bounds: Bounds, anchor: ObservablePoint, texture: Texture): void;
+export declare function applyMixins(base: any, ...mixins: Parameters<typeof Object.getOwnPropertyDescriptors>[0][]): void;

package/dist/utils/type.d.ts

@@ -0,0 +1,16 @@
+interface System {
+    desc: {
+        name: string;
+    };
+    defaultOptions?: any;
+    new (...args: any): any;
+}
+type NameType<T extends System[]> = T[number]['desc']['name'];
+export type ExtractSystemTypes<T extends System[]> = {
+    [K in NameType<T>]: InstanceType<Extract<T[number], {
+        desc: {
+            name: K;
+        };
+    }>>;
+};
+export {};

package/dist/utils/uid.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The names of the unique identifiers. These are used to create unique identifiers for different types of objects.
+ * @category utils
+ * @internal
+ */
+export type UIDNames = 'default' | 'resource' | 'texture' | 'textureSource' | 'textureResource' | 'batcher' | 'graphicsContext' | 'graphicsView' | 'graphicsPath' | 'fillGradient' | 'fillPattern' | 'meshView' | 'renderable' | 'buffer' | 'bufferResource' | 'geometry' | 'instructionSet' | 'renderTarget' | 'uniform' | 'spriteView' | 'textView' | 'tilingSpriteView' | 'shader' | 'renderer' | 'textStyle' | (string & {});
+/**
+ * Gets the next unique identifier
+ * @param name - The name of the identifier.
+ * @returns {number} The next unique identifier to use.
+ * @category utils
+ * @internal
+ */
+export declare function uid(name?: UIDNames): number;
+/**
+ * Resets the next unique identifier to 0. This is used for some tests, dont touch or things WILL explode :)
+ * @internal
+ */
+export declare function resetUids(): void;

package/package.json

@@ -1,12 +1,14 @@
 {
   "name": "@sepveneto/dao",
-  "version": "0.0.5",
+  "version": "0.1.1",
   "type": "module",
   "scripts": {
+    "docs:dev": "vitepress dev docs",
     "dev": "vite",
     "build": "vite build",
     "release": "bumpp",
-    "preview": "vite preview"
+    "preview": "vite preview",
+    "test": "vitest"
   },
   "files": [
     "dist"
@@ -22,19 +24,33 @@
     }
   },
   "devDependencies": {
+    "@test/utils": "workspace: *",
     "@types/node": "^24.10.1",
+    "@types/stats.js": "^0.17.4",
     "@vitejs/plugin-vue": "^6.0.1",
     "@vue/tsconfig": "^0.8.1",
     "bumpp": "^10.3.2",
+    "canvas": "3.2.3",
+    "jsdom": "^29.1.1",
+    "stats.js": "^0.17.0",
     "typescript": "~5.9.3",
     "vite": "npm:rolldown-vite@7.2.5",
     "vite-plugin-dts": "^4.5.4",
+    "vitepress": "2.0.0-alpha.17",
+    "vitest": "^4.1.6",
     "vue": "^3.5.24",
     "vue-tsc": "^3.1.4"
   },
   "pnpm": {
     "overrides": {
       "vite": "npm:rolldown-vite@7.2.5"
-    }
+    },
+    "onlyBuiltDependencies": [
+      "canvas"
+    ]
+  },
+  "dependencies": {
+    "@tweenjs/tween.js": "^25.0.0",
+    "eventemitter3": "^5.0.4"
   }
 }

package/dist/Camera.d.ts

@@ -1,46 +0,0 @@
-import { GameObject } from './GameObject';
-import { Projection } from './Projection';
-import { InputSystem } from './system/InputSystem';
-export declare class Camera {
-    viewport: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    };
-    x: number;
-    y: number;
-    zoom: number;
-    projection: Projection;
-    private _followTarget?;
-    private _followLerp;
-    private _offsetX;
-    private _offsetY;
-    private originX;
-    private originY;
-    get width(): number;
-    get height(): number;
-    constructor(proj: Projection);
-    setOrigin(x: number, y: number): void;
-    setViewport(x: number, y: number, width: number, height: number): void;
-    apply(ctx: CanvasRenderingContext2D): void;
-    restore(ctx: CanvasRenderingContext2D): void;
-    project(worldX: number, worldY: number, worldZ?: number): {
-        px: number;
-        py: number;
-    };
-    follow(target: GameObject, options?: {
-        lerp?: number;
-        offsetX?: number;
-        offsetY?: number;
-    }): void;
-    stopFollow(): void;
-    update(): void;
-}
-export declare class CameraController {
-    private camera;
-    private input;
-    speed: number;
-    constructor(camera: Camera, input: InputSystem);
-    update(delta: number): void;
-}