like2d 2.10.2 → 2.11.1

package/dist/graphics/{drawing.js → graphics.js}

@@ -27,59 +27,7 @@
  * - Angles in radians, 0 is right, positive is clockwise
  */
 import { Vec2 } from "../math/vector2";
-export class ImageHandle {
-    constructor(path) {
-        Object.defineProperty(this, "path", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "element", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
-        });
-        Object.defineProperty(this, "loadPromise", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "isLoaded", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        this.path = path;
-        this.loadPromise = new Promise((resolve, reject) => {
-            const img = new Image();
-            img.onload = () => {
-                this.element = img;
-                this.isLoaded = true;
-                resolve();
-            };
-            img.onerror = () => {
-                reject(new Error(`Failed to load image: ${path}`));
-            };
-            img.src = path;
-        });
-    }
-    isReady() {
-        return this.isLoaded;
-    }
-    ready() {
-        return this.loadPromise;
-    }
-    get size() {
-        return [this.element?.width ?? 0, this.element?.height ?? 0];
-    }
-    getElement() {
-        return this.element;
-    }
-}
+import { ImageHandle } from "./image";
 function parseColor(color) {
     if (typeof color === "string")
         return color;
@@ -117,57 +65,96 @@ function getFontHeight(ctx) {
     return match ? parseInt(match[1]) : 16;
 }
 /**
- * All of these methods exist on `like.gfx`, but with `ctx`
- * bound to the first arg.
+ * LIKE's way of drawing to the screen.
  *
- * Acts as the core of the graphics system, but can be used separately.
+ * More specifically: a system for wrapping canvas draw calls conveniently.
  *
+ *  - Reduces state in calls -- no `setColor`, etc. Everything is passed in.
+ *  - Abstracts away common drawing operations.
+ *
+ * ### Examples
+ * Draw a spinning symbol in the center of the screen using transforms.
  * ```ts
- * import { draw } from "like/graphics"
- * draw.clear(my2dContext, "red");
- * ```
+ * function drawSpinningYinYang(like: Like) {
+ *   const color1 = "black";
+ *   const color2 = "white";
+ *   const size = 50;
+ *   const pos = Vec2.div(like.canvas.getSize(), 2); // calc center of screen
+ *   const speed = 0.5; // rotations per second
+ *
+ *   like.gfx.push();
+ *   like.gfx.translate(pos);
+ *   like.gfx.rotate(like.timer.getTime() * Math.PI * 2.0 * speed);
+ *   like.gfx.scale(size);
+ *   like.gfx.circle("fill", color1, [0, 0], 2);
+ *   // use the arc parameter to fill in a semicircle. Note that it's clockwise from {x:1, y:0}.
+ *   like.gfx.circle("fill", color2, [0, 0], 2, { arc: [Math.PI/2, Math.PI*3/2] });
+ *   like.gfx.circle("fill", color2, [0, -1], 1);
+ *   like.gfx.circle("fill", color1, [0, 1], 1);
+ *   like.gfx.circle("fill", color2, [0, 1], 1/3);
+ *   like.gfx.circle("fill", color1, [0, -1], 1/3);
+ *   like.gfx.pop();
+ * }
  *
+ * like.draw = (like: Like) => {
+ *   drawSpinningYinYang(like);
+ * }
+ * ```
  */
-export const draw = {
+export class Graphics {
+    constructor(ctx) {
+        Object.defineProperty(this, "ctx", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ctx
+        });
+    }
+    /**
+     * Set the 2d drawing context for graphics.
+     *
+     * Be aware that that `like` can set this value at any time.
+     */
+    setContext(ctx) {
+        this.ctx = ctx;
+    }
     /**
      * Clears the canvas with a solid color.
-     * @param ctx Canvas context.
      * @param color Fill color.
      */
-    clear(ctx, color = [0, 0, 0, 1]) {
-        ctx.fillStyle = parseColor(color);
-        ctx.fillRect(0, 0, ctx.canvas.width, ctx.canvas.height);
-    },
+    clear(color = [0, 0, 0, 1]) {
+        this.ctx.fillStyle = parseColor(color);
+        this.ctx.fillRect(0, 0, this.ctx.canvas.width, this.ctx.canvas.height);
+    }
     /**
      * Draws a rectangle.
-     * @param ctx Canvas context.
      * @param mode Fill or line.
      * @param color Fill or stroke color.
      * @param rect Rectangle [x, y, w, h].
      * @param props Optional stroke properties.
      */
-    rectangle(ctx, mode, color, rect, props) {
+    rectangle(mode, color, rect, props) {
         const c = applyColor(color);
         if (mode === "fill") {
-            ctx.fillStyle = c;
-            ctx.fillRect(...rect);
+            this.ctx.fillStyle = c;
+            this.ctx.fillRect(...rect);
         }
         else {
-            setStrokeProps(ctx, props);
-            ctx.strokeStyle = c;
-            ctx.strokeRect(...rect);
+            setStrokeProps(this.ctx, props);
+            this.ctx.strokeStyle = c;
+            this.ctx.strokeRect(...rect);
         }
-    },
+    }
     /**
      * Draws a circle or ellipse.
-     * @param ctx Canvas context.
+     
      * @param mode Fill or line.
      * @param color Fill or stroke color.
      * @param position Center position.
      * @param radii Radius (number) or [rx, ry] for ellipse.
      * @param props Optional arc, center, and stroke properties. Center is true by default.
      */
-    circle(ctx, mode, color, position, radii, props) {
+    circle(mode, color, position, radii, props) {
         const center = (props && 'center' in props) ? props.center : true;
         const c = applyColor(color);
         const size = typeof radii === "number" ? [radii, radii] : radii;
@@ -175,43 +162,43 @@ export const draw = {
         if (!center) {
             position = Vec2.add(position, size);
         }
-        ctx.save();
-        ctx.translate(...position);
-        ctx.scale(...size);
-        ctx.beginPath();
-        ctx.arc(0, 0, 1, startAngle, endAngle);
+        this.ctx.save();
+        this.ctx.translate(...position);
+        this.ctx.scale(...size);
+        this.ctx.beginPath();
+        this.ctx.arc(0, 0, 1, startAngle, endAngle);
         if (mode == 'fill')
-            ctx.lineTo(0, 0);
-        ctx.closePath();
-        ctx.restore();
+            this.ctx.lineTo(0, 0);
+        this.ctx.closePath();
+        this.ctx.restore();
         if (mode === "fill") {
-            ctx.fillStyle = c;
-            ctx.fill();
+            this.ctx.fillStyle = c;
+            this.ctx.fill();
         }
         else {
-            setStrokeProps(ctx, props);
-            ctx.strokeStyle = c;
-            ctx.stroke();
+            setStrokeProps(this.ctx, props);
+            this.ctx.strokeStyle = c;
+            this.ctx.stroke();
         }
-    },
+    }
     /**
      * Draws connected line segments.
-     * @param ctx Canvas context.
+     
      * @param color Stroke color.
      * @param points Array of [x, y] positions.
      * @param props Optional stroke properties.
      */
-    line(ctx, color, points, props) {
+    line(color, points, props) {
         if (points.length < 2)
             return;
-        setStrokeProps(ctx, props);
-        ctx.beginPath();
+        setStrokeProps(this.ctx, props);
+        this.ctx.beginPath();
         const [[x0, y0], ...rest] = points;
-        ctx.moveTo(x0, y0);
-        rest.forEach(([x, y]) => ctx.lineTo(x, y));
-        ctx.strokeStyle = applyColor(color);
-        ctx.stroke();
-    },
+        this.ctx.moveTo(x0, y0);
+        rest.forEach(([x, y]) => this.ctx.lineTo(x, y));
+        this.ctx.strokeStyle = applyColor(color);
+        this.ctx.stroke();
+    }
     /**
      * Draws text at a position.
      *
@@ -222,44 +209,44 @@ export const draw = {
      * to the left and right of its position. If you align right, your position
      * becomes the upper-right corner of the text.
      *
-     * @param ctx Canvas context.
+     
      * @param color Fill color.
      * @param text Text string.
      * @param position Top-left position.
      * @param props {@link PrintProps} Optional font, text limit, or alignment.
      */
-    print(ctx, color, text, position, props) {
+    print(color, text, position, props) {
         const [x, y] = position;
         const { font = "16px sans-serif" } = props ?? {};
-        ctx.fillStyle = parseColor(color);
-        ctx.font = font;
-        ctx.textAlign = props?.align ?? "left";
+        this.ctx.fillStyle = parseColor(color);
+        this.ctx.font = font;
+        this.ctx.textAlign = props?.align ?? "left";
         if (props && 'width' in props) {
             const { width } = props;
-            const lines = wrapText(ctx, text, width);
-            const lineHeight = getFontHeight(ctx);
-            ctx.textBaseline = "top";
+            const lines = wrapText(this.ctx, text, width);
+            const lineHeight = getFontHeight(this.ctx);
+            this.ctx.textBaseline = "top";
             lines.forEach((line, i) => {
-                ctx.fillText(line, x, y + i * lineHeight, width);
+                this.ctx.fillText(line, x, y + i * lineHeight, width);
             });
-            ctx.textBaseline = "alphabetic";
+            this.ctx.textBaseline = "alphabetic";
         }
         else {
-            ctx.fillText(text, x, y);
+            this.ctx.fillText(text, x, y);
         }
-    },
+    }
     /**
      * Draws an image.
      *
      * @remarks named "draw" because it draws anything _drawable_
      * in the long run.
      *
-     * @param ctx Canvas context.
+     
      * @param handle Image handle from newImage.
      * @param position Draw position.
      * @param props Optional rotation, scale, origin, or quad.
      */
-    draw(ctx, handle, position, props) {
+    draw(handle, position, props) {
         if (!handle.isReady())
             return;
         const element = handle.getElement();
@@ -269,120 +256,121 @@ export const draw = {
         const { r = 0, scale = 1, origin = 0, quad } = props ?? {};
         const [sx, sy] = typeof scale === "number" ? [scale, scale] : scale;
         const [ox, oy] = typeof origin === "number" ? [origin, origin] : origin;
-        ctx.save();
-        ctx.translate(x, y);
-        ctx.rotate(r);
-        ctx.scale(sx, sy);
+        this.ctx.save();
+        this.ctx.translate(x, y);
+        this.ctx.rotate(r);
+        this.ctx.scale(sx, sy);
         if (quad) {
             const [qx, qy, qw, qh] = quad;
-            ctx.drawImage(element, qx, qy, qw, qh, -ox, -oy, qw, qh);
+            this.ctx.drawImage(element, qx, qy, qw, qh, -ox, -oy, qw, qh);
         }
         else {
-            ctx.drawImage(element, -ox, -oy);
+            this.ctx.drawImage(element, -ox, -oy);
         }
-        ctx.restore();
-    },
+        this.ctx.restore();
+    }
     /**
      * Loads an image from a path.
      * Unlike built-in loading, this pretends to be synchronous.
-     * @param ctx Canvas context.
+     
      * @param path Image file path.
      * @returns ImageHandle for use with draw.
      */
-    newImage(_ctx, path) {
+    newImage(path) {
         return new ImageHandle(path);
-    },
+    }
     /**
      * Sets the clipping region.
-     * @param ctx Canvas context.
+     
      * @param rect Clipping rectangle, or full canvas if omitted.
      */
-    clip(ctx, rect) {
-        ctx.beginPath();
+    clip(rect) {
+        this.ctx.beginPath();
         if (rect) {
             const [x, y, w, h] = rect;
-            ctx.rect(x, y, w, h);
+            this.ctx.rect(x, y, w, h);
         }
         else {
-            ctx.rect(0, 0, ctx.canvas.width, ctx.canvas.height);
+            this.ctx.rect(0, 0, this.ctx.canvas.width, this.ctx.canvas.height);
         }
-        ctx.clip();
-    },
+        this.ctx.clip();
+    }
     /**
      * Draws a polygon.
-     * @param ctx Canvas context.
+     
      * @param mode Fill or line.
      * @param color Fill or stroke color.
      * @param points Array of [x, y] vertices.
      * @param props Optional stroke properties.
      */
-    polygon(ctx, mode, color, points, props) {
+    polygon(mode, color, points, props) {
         if (points.length < 3)
             return;
         const c = applyColor(color);
-        ctx.beginPath();
+        this.ctx.beginPath();
         const [[x0, y0], ...rest] = points;
-        ctx.moveTo(x0, y0);
-        rest.forEach(([x, y]) => ctx.lineTo(x, y));
-        ctx.closePath();
+        this.ctx.moveTo(x0, y0);
+        rest.forEach(([x, y]) => this.ctx.lineTo(x, y));
+        this.ctx.closePath();
         if (mode === "fill") {
-            ctx.fillStyle = c;
-            ctx.fill();
+            this.ctx.fillStyle = c;
+            this.ctx.fill();
         }
         else {
-            setStrokeProps(ctx, props);
-            ctx.strokeStyle = c;
-            ctx.stroke();
+            setStrokeProps(this.ctx, props);
+            this.ctx.strokeStyle = c;
+            this.ctx.stroke();
         }
-    },
+    }
     /**
      * Draws individual pixels.
-     * @param ctx Canvas context.
+     
      * @param color Fill color.
      * @param pts Array of [x, y] positions.
      */
-    points(ctx, color, pts) {
-        ctx.fillStyle = applyColor(color);
-        pts.forEach(([x, y]) => ctx.fillRect(x, y, 1, 1));
-    },
+    points(color, pts) {
+        this.ctx.fillStyle = applyColor(color);
+        pts.forEach(([x, y]) => this.ctx.fillRect(x, y, 1, 1));
+    }
     /**
      * Saves canvas state.
-     * @param ctx Canvas context.
+     
      */
-    push(ctx) {
-        ctx.save();
-    },
+    push() {
+        this.ctx.save();
+    }
     /**
      * Restores canvas state.
-     * @param ctx Canvas context.
+     
      */
-    pop(ctx) {
-        ctx.restore();
-    },
+    pop() {
+        this.ctx.restore();
+    }
     /**
      * Applies a translation.
-     * @param ctx Canvas context.
+     
      * @param offset [x, y] offset.
      */
-    translate(ctx, offset) {
+    translate(offset) {
         const [x, y] = offset;
-        ctx.translate(x, y);
-    },
+        this.ctx.translate(x, y);
+    }
     /**
      * Applies a rotation.
-     * @param ctx Canvas context.
+     
      * @param angle Rotation in radians.
      */
-    rotate(ctx, angle) {
-        ctx.rotate(angle);
-    },
+    rotate(angle) {
+        this.ctx.rotate(angle);
+    }
     /**
      * Applies a scale.
-     * @param ctx Canvas context.
+     
      * @param factor Scale factor (number or [x, y]).
      */
-    scale(ctx, factor) {
+    scale(factor) {
         const [sx, sy] = typeof factor === "number" ? [factor, factor] : factor;
-        ctx.scale(sx, sy);
-    },
-};
+        this.ctx.scale(sx, sy);
+    }
+}
+;

package/dist/graphics/image.d.ts

@@ -0,0 +1,22 @@
+import { Vector2 } from "../math";
+/**
+ * An image that can be drawn using {@link Graphics.draw}
+ *
+ * Unlike raw HTMLImageElement, there is no need to wait for it to load.
+ * If the image isn't loaded, it simply won't draw it at all.
+ *
+ * If you're planning on loading many large images, simply preload
+ * these image handles beforehand so that they're ready.
+ */
+export declare class ImageHandle {
+    readonly path: string;
+    private element;
+    private loadPromise;
+    private isLoaded;
+    constructor(path: string);
+    isReady(): boolean;
+    ready(): Promise<void>;
+    get size(): Vector2;
+    getElement(): HTMLImageElement | null;
+}
+//# sourceMappingURL=image.d.ts.map

package/dist/graphics/image.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image.d.ts","sourceRoot":"","sources":["../../src/graphics/image.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAElC;;;;;;;;GAQG;AACH,qBAAa,WAAW;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,OAAO,CAAiC;IAChD,OAAO,CAAC,WAAW,CAAgB;IACnC,OAAO,CAAC,QAAQ,CAAS;gBAEb,IAAI,EAAE,MAAM;IAiBxB,OAAO,IAAI,OAAO;IAIlB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAItB,IAAI,IAAI,IAAI,OAAO,CAElB;IAED,UAAU,IAAI,gBAAgB,GAAG,IAAI;CAGtC"}

package/dist/graphics/image.js

@@ -0,0 +1,62 @@
+/**
+ * An image that can be drawn using {@link Graphics.draw}
+ *
+ * Unlike raw HTMLImageElement, there is no need to wait for it to load.
+ * If the image isn't loaded, it simply won't draw it at all.
+ *
+ * If you're planning on loading many large images, simply preload
+ * these image handles beforehand so that they're ready.
+ */
+export class ImageHandle {
+    constructor(path) {
+        Object.defineProperty(this, "path", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "element", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "loadPromise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "isLoaded", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        this.path = path;
+        this.loadPromise = new Promise((resolve, reject) => {
+            const img = new Image();
+            img.onload = () => {
+                this.element = img;
+                this.isLoaded = true;
+                resolve();
+            };
+            img.onerror = () => {
+                reject(new Error(`Failed to load image: ${path}`));
+            };
+            img.src = path;
+        });
+    }
+    isReady() {
+        return this.isLoaded;
+    }
+    ready() {
+        return this.loadPromise;
+    }
+    get size() {
+        return [this.element?.width ?? 0, this.element?.height ?? 0];
+    }
+    getElement() {
+        return this.element;
+    }
+}

package/dist/graphics/index.d.ts

@@ -1,19 +1,10 @@
 /**
+ * Where we draw with {@link Graphics} on to the {@link Canvas}.
  * @module graphics
- * @description a reduced-state, Love2D-like wrapper around browser canvas
  */
-import { draw } from "./drawing";
-export type { Color, DrawMode, ShapeProps, DrawProps, PrintProps, ImageHandle, } from "./drawing";
-export { draw } from "./drawing";
-export type { CanvasModeOptions, CanvasSize, Canvas, } from "./canvas";
-type Bind<F> = F extends (ctx: CanvasRenderingContext2D, ...args: infer A) => infer R ? (...args: A) => R : never;
-/**
- * A graphics object with a canvas already attatched to it.
- * Calling its methods will draw to the render canvas.
- * See {@link graphics} for more info.
- */
-export type BoundGraphics = {
-    [K in keyof typeof draw]: Bind<(typeof draw)[K]>;
-};
-export declare function bindGraphics(ctx: CanvasRenderingContext2D): BoundGraphics;
+export type { Graphics } from "./graphics";
+export type { Canvas } from "./canvas";
+export type { ImageHandle } from './image';
+export type { Color, DrawMode, ShapeProps, DrawProps, PrintProps, } from "./graphics";
+export type { CanvasSize, CanvasModeOptions, } from "./canvas";
 //# sourceMappingURL=index.d.ts.map

package/dist/graphics/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/graphics/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,YAAY,EACV,KAAK,EACL,QAAQ,EACR,UAAU,EACV,SAAS,EACT,UAAU,EACV,WAAW,GACZ,MAAM,WAAW,CAAC;AAEnB,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,YAAY,EACV,iBAAiB,EACjB,UAAU,EACV,MAAM,GACP,MAAM,UAAU,CAAC;AAElB,KAAK,IAAI,CAAC,CAAC,IAAI,CAAC,SAAS,CACvB,GAAG,EAAE,wBAAwB,EAC7B,GAAG,IAAI,EAAE,MAAM,CAAC,KACb,MAAM,CAAC,GACR,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,CAAC,GACjB,KAAK,CAAC;AAEV;;;;GAIG;AACH,MAAM,MAAM,aAAa,GAAG;KACzB,CAAC,IAAI,MAAM,OAAO,IAAI,GAAG,IAAI,CAAC,CAAC,OAAO,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;CACjD,CAAC;AAEF,wBAAgB,YAAY,CAAC,GAAG,EAAE,wBAAwB,GAAG,aAAa,CAMzE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/graphics/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,YAAY,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,YAAY,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAEvC,YAAY,EACV,WAAW,EACZ,MAAM,SAAS,CAAC;AAEjB,YAAY,EACV,KAAK,EACL,QAAQ,EACR,UAAU,EACV,SAAS,EACT,UAAU,GACX,MAAM,YAAY,CAAC;AAEpB,YAAY,EACV,UAAU,EACV,iBAAiB,GAClB,MAAM,UAAU,CAAC"}

package/dist/graphics/index.js

@@ -1,13 +1,5 @@
 /**
+ * Where we draw with {@link Graphics} on to the {@link Canvas}.
  * @module graphics
- * @description a reduced-state, Love2D-like wrapper around browser canvas
  */
-import { draw } from "./drawing";
-export { draw } from "./drawing";
-export function bindGraphics(ctx) {
-    const bound = {};
-    for (const [name, fn] of Object.entries(draw)) {
-        bound[name] = (...args) => fn(ctx, ...args);
-    }
-    return bound;
-}
+export {};

package/dist/index.d.ts

@@ -1,10 +1,12 @@
 /**
- * @module like2d
- * @description A cozy web-native 2D game framework.
+ * A cozy web-native 2D game framework.
+ *
  */
 import type { Like } from './like';
-export type { Like, TopLevelEventHandler } from './like';
-export type { LikeEvent, EventType, EventMap } from './events';
+export type { Like, TopLevelEventHandler, Callbacks, Callback } from './like';
+export type { LikeEvent, EventType, EventMap, LikeCanvasElement, Dispatcher, LikeCanvasEventMap, LikeKeyboardEvent } from './events';
+export type { Scene } from './scene';
+export type { EngineProps } from './engine';
 /**
  * Create a new Like2D game instance attached to a DOM container.
  *

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC,YAAY,EAAE,IAAI,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAAC;AACzD,YAAY,EAAE,SAAS,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAE/D;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAAE,WAAW,GAAG,IAAI,CAGvD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAYH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC,YAAY,EAAE,IAAI,EAAE,oBAAoB,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAC9E,YAAY,EAAE,SAAS,EAAE,SAAS,EAAE,QAAQ,EAAE,iBAAiB,EAAE,UAAU,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AACrI,YAAY,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AACrC,YAAY,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAAE,WAAW,GAAG,IAAI,CAGvD"}

package/dist/index.js

@@ -1,6 +1,13 @@
 /**
- * @module like2d
- * @description A cozy web-native 2D game framework.
+ * A cozy web-native 2D game framework.
+ *
+ */
+/**
+ * Here are the top-level events, modules, and the scene system.
+ *
+ * See {@link createLike} to get started.
+ *
+ * @module like
  */
 import { Engine } from './engine';
 /**