minimojs 1.0.0-alpha.41 → 1.0.0-alpha.43

package/dist/minimo-format.js

@@ -12,9 +12,13 @@
 const ASSET_FILE_FORMAT = "minimo-assets";
 /** The newest asset file `version` this engine reads. */
 const ASSET_FILE_VERSION = 1;
+/** The entry types this engine loads. */
+export const ASSET_TYPES = Object.freeze(["image", "sound", "spritesheet", "atlas"]);
 const ASSET_FILE_FIELDS = new Set(["format", "version", "assets"]);
 /** The fields of each supported entry type; `image` and `sound` share theirs. */
 const SRC_ASSET_FIELDS = new Set(["key", "type", "src"]);
+const SPRITESHEET_ASSET_FIELDS = new Set(["key", "type", "src", "frameWidth", "frameHeight"]);
+const ATLAS_ASSET_FIELDS = new Set(["key", "type", "src", "data"]);
 /**
  * Validates the content of an asset file and returns a copy of it.
  *
@@ -25,7 +29,9 @@ const SRC_ASSET_FIELDS = new Set(["key", "type", "src"]);
  * - an entry without a string `key` and `type`;
  * - an empty key, or one with leading or trailing spaces;
  * - a key repeated in the file, whatever the types of its entries;
- * - an `image` or `sound` entry without a non-empty string `src`.
+ * - an `image`, `sound`, `spritesheet`, or `atlas` entry without a non-empty string `src`;
+ * - a `spritesheet` whose `frameWidth` or `frameHeight` is not a positive integer;
+ * - an `atlas` without a non-empty string `data`.
  *
  * An entry of a type this engine does not support is kept unchanged, without
  * checking its other fields, so nothing is lost when a tool saves the file.
@@ -82,13 +88,25 @@ export function parseAssetFile(json) {
         if (typeof type !== "string" || type.length === 0) {
             throw assetError(`${where} ("${key}") must have a string "type", found ${describe(type)}.`);
         }
+        const named = `${where} ("${key}")`;
         if (type === "image" || type === "sound") {
-            rejectUnknownFields(entry, SRC_ASSET_FIELDS, `${where} ("${key}")`);
-            const src = entry.src;
-            if (typeof src !== "string" || src.trim().length === 0) {
-                throw assetError(`${where} ("${key}") must have a non-empty string "src", found ${describe(src)}.`);
+            rejectUnknownFields(entry, SRC_ASSET_FIELDS, named);
+            assets.push({ key, type, src: requireText(entry, "src", named) });
+        }
+        else if (type === "spritesheet") {
+            rejectUnknownFields(entry, SPRITESHEET_ASSET_FIELDS, named);
+            const src = requireText(entry, "src", named);
+            for (const field of ["frameWidth", "frameHeight"]) {
+                const value = entry[field];
+                if (typeof value !== "number" || !Number.isInteger(value) || value < 1) {
+                    throw assetError(`${named} must have a positive integer "${field}", found ${describe(value)}.`);
+                }
             }
-            assets.push({ key, type, src });
+            assets.push({ key, type, src, frameWidth: entry.frameWidth, frameHeight: entry.frameHeight });
+        }
+        else if (type === "atlas") {
+            rejectUnknownFields(entry, ATLAS_ASSET_FIELDS, named);
+            assets.push({ key, type, src: requireText(entry, "src", named), data: requireText(entry, "data", named) });
         }
         else {
             assets.push({ ...entry, key, type });
@@ -97,6 +115,164 @@ export function parseAssetFile(json) {
     return { format: ASSET_FILE_FORMAT, version: ASSET_FILE_VERSION, assets };
 }
 // ---------------------------------------------------------------------------
+// Spritesheets and texture atlases
+// ---------------------------------------------------------------------------
+/**
+ * The image key of a spritesheet's or an atlas's frame: the sheet's key, a
+ * slash, and the frame's name, such as `"frog/0"` or `"pond/lotus"`.
+ */
+export function frameKey(sheetKey, frameName) {
+    return `${sheetKey}/${frameName}`;
+}
+/**
+ * The frames of a spritesheet whose image is `imageWidth` by `imageHeight`
+ * pixels: every whole cell of the grid, numbered from `0` left to right and
+ * top to bottom. Throws when the image holds no whole frame.
+ */
+export function spritesheetFrames(sheet, imageWidth, imageHeight) {
+    const columns = Math.floor(imageWidth / sheet.frameWidth);
+    const rows = Math.floor(imageHeight / sheet.frameHeight);
+    if (columns < 1 || rows < 1) {
+        throw new Error(`MinimoJS: The spritesheet "${sheet.key}" is ${imageWidth} by ${imageHeight} pixels, smaller than one ${sheet.frameWidth} by ${sheet.frameHeight} frame.`);
+    }
+    const frames = [];
+    for (let row = 0; row < rows; row++) {
+        for (let column = 0; column < columns; column++) {
+            frames.push({
+                name: String(frames.length),
+                x: column * sheet.frameWidth,
+                y: row * sheet.frameHeight,
+                width: sheet.frameWidth,
+                height: sheet.frameHeight,
+                sourceWidth: sheet.frameWidth,
+                sourceHeight: sheet.frameHeight,
+                offsetX: 0,
+                offsetY: 0,
+            });
+        }
+    }
+    return frames;
+}
+/**
+ * Reads a texture atlas in the JSON Hash format, as TexturePacker
+ * (*JSON (Hash)*) and free-tex-packer (`JsonHash`) export it, and returns its
+ * frames.
+ *
+ * From each entry of `frames` it reads `frame`, the rectangle in the image;
+ * `sourceSize`, the picture's size before trimming; and `spriteSourceSize`,
+ * where the trimmed rectangle sat in it. The last two may be left out for an
+ * untrimmed frame. Other fields, such as `pivot`, `anchor`, `trimmed`, and
+ * the rest of `meta`, are ignored.
+ *
+ * It throws an error naming what is wrong, and which packer setting changes
+ * it, for:
+ * - a value that is not an object with a `frames` object, including the JSON
+ *   Array format, whose `frames` is a list, and multi-image atlases, which
+ *   list `textures`;
+ * - no frames, or a frame name that is empty or has leading or trailing spaces;
+ * - a rotated frame, `"rotated": true`;
+ * - a `meta.scale` other than 1;
+ * - a rectangle that is not made of whole, non-negative pixels, or a trimmed
+ *   rectangle that does not fit in its source size;
+ * - a frame outside the image size `meta.size` states.
+ *
+ * @param json - The parsed atlas JSON.
+ */
+export function parseTextureAtlas(json) {
+    if (!isPlainObject(json)) {
+        throw atlasError("an atlas must be a JSON object.");
+    }
+    if (Array.isArray(json.textures)) {
+        throw atlasError(`it holds several images ("textures"). Export one image per atlas, in the JSON Hash format, with TexturePacker's Multipack off.`);
+    }
+    if (Array.isArray(json.frames)) {
+        throw atlasError(`"frames" is a list, the JSON Array format. Export the JSON Hash format: TexturePacker's "JSON (Hash)", free-tex-packer's "JSON (hash)".`);
+    }
+    if (!isPlainObject(json.frames)) {
+        throw atlasError(`"frames" must be an object of frames by name, found ${describe(json.frames)}.`);
+    }
+    const meta = isPlainObject(json.meta) ? json.meta : {};
+    if (meta.scale !== undefined && Number(meta.scale) !== 1) {
+        throw atlasError(`"meta.scale" is ${describe(meta.scale)}. Export the atlas at scale 1.`);
+    }
+    let imageWidth = null;
+    let imageHeight = null;
+    if (isPlainObject(meta.size)) {
+        imageWidth = requirePixels(meta.size.w, `"meta.size.w"`, 1);
+        imageHeight = requirePixels(meta.size.h, `"meta.size.h"`, 1);
+    }
+    const frames = [];
+    for (const [name, entry] of Object.entries(json.frames)) {
+        const where = `the frame "${name}"`;
+        if (name.length === 0 || name.trim() !== name) {
+            throw atlasError(`the frame name "${name}" is empty or has leading or trailing spaces.`);
+        }
+        if (!isPlainObject(entry)) {
+            throw atlasError(`${where} must be an object, found ${describe(entry)}.`);
+        }
+        if (entry.rotated === true) {
+            throw atlasError(`${where} is rotated. Export the atlas without rotation: TexturePacker's "Allow rotation", free-tex-packer's "allowRotation".`);
+        }
+        if (!isPlainObject(entry.frame)) {
+            throw atlasError(`${where} must have a "frame" rectangle, found ${describe(entry.frame)}.`);
+        }
+        const x = requirePixels(entry.frame.x, `${where}'s "frame.x"`, 0);
+        const y = requirePixels(entry.frame.y, `${where}'s "frame.y"`, 0);
+        const width = requirePixels(entry.frame.w, `${where}'s "frame.w"`, 1);
+        const height = requirePixels(entry.frame.h, `${where}'s "frame.h"`, 1);
+        let sourceWidth = width;
+        let sourceHeight = height;
+        if (entry.sourceSize !== undefined) {
+            if (!isPlainObject(entry.sourceSize)) {
+                throw atlasError(`${where}'s "sourceSize" must be an object, found ${describe(entry.sourceSize)}.`);
+            }
+            sourceWidth = requirePixels(entry.sourceSize.w, `${where}'s "sourceSize.w"`, 1);
+            sourceHeight = requirePixels(entry.sourceSize.h, `${where}'s "sourceSize.h"`, 1);
+        }
+        let offsetX = 0;
+        let offsetY = 0;
+        if (entry.spriteSourceSize !== undefined) {
+            if (!isPlainObject(entry.spriteSourceSize)) {
+                throw atlasError(`${where}'s "spriteSourceSize" must be an object, found ${describe(entry.spriteSourceSize)}.`);
+            }
+            offsetX = requirePixels(entry.spriteSourceSize.x, `${where}'s "spriteSourceSize.x"`, 0);
+            offsetY = requirePixels(entry.spriteSourceSize.y, `${where}'s "spriteSourceSize.y"`, 0);
+        }
+        if (offsetX + width > sourceWidth || offsetY + height > sourceHeight) {
+            throw atlasError(`${where}, ${width} by ${height} pixels at ${offsetX}, ${offsetY}, does not fit in its ${sourceWidth} by ${sourceHeight} "sourceSize".`);
+        }
+        if (imageWidth !== null && imageHeight !== null && (x + width > imageWidth || y + height > imageHeight)) {
+            throw atlasError(`${where} reaches outside the ${imageWidth} by ${imageHeight} image "meta.size" states.`);
+        }
+        frames.push({ name, x, y, width, height, sourceWidth, sourceHeight, offsetX, offsetY });
+    }
+    if (frames.length === 0) {
+        throw atlasError(`it has no frames.`);
+    }
+    return { frames, imageWidth, imageHeight };
+}
+/**
+ * Throws unless every frame lies inside an image of `imageWidth` by
+ * `imageHeight` pixels. `sheet` names the sheet in the error.
+ */
+export function checkFramesFitImage(sheet, frames, imageWidth, imageHeight) {
+    for (const frame of frames) {
+        if (frame.x + frame.width > imageWidth || frame.y + frame.height > imageHeight) {
+            throw new Error(`MinimoJS: The frame "${frame.name}" of "${sheet}" reaches outside its ${imageWidth} by ${imageHeight} image. Check that the atlas JSON was packed for this image.`);
+        }
+    }
+}
+function requirePixels(value, where, minimum) {
+    if (typeof value !== "number" || !Number.isInteger(value) || value < minimum) {
+        const expected = minimum === 0 ? "a whole number of pixels, 0 or more" : "a whole number of pixels, 1 or more";
+        throw atlasError(`${where} must be ${expected}, found ${describe(value)}.`);
+    }
+    return value;
+}
+function atlasError(message) {
+    return new Error(`MinimoJS: Invalid atlas: ${message}`);
+}
+// ---------------------------------------------------------------------------
 // Design files
 // ---------------------------------------------------------------------------
 /** The `format` value of every design file. */
@@ -142,14 +318,20 @@ const SPRITE_SPECS = {
     bodyOffsetY: spec("number", 0),
     ...DATA,
 };
+const OUTLINE_SPECS = {
+    outlineWidth: spec("number", 0),
+    outlineColor: spec("string", "#ffffff"),
+};
 const IMAGE_SPECS = {
     imageKey: requiredString(),
     ...SPRITE_SPECS,
+    ...OUTLINE_SPECS,
 };
 const EMOJI_SPECS = {
     sprite: requiredString(),
     size: spec("number", 32),
     ...SPRITE_SPECS,
+    ...OUTLINE_SPECS,
 };
 const TEXT_SPECS = {
     text: requiredString(),
@@ -173,6 +355,7 @@ const TEXT_SPECS = {
     strokeWidth: spec("number", 0),
     ...SPRITE_SPECS,
     color: spec("string", "#ffffff"),
+    ...OUTLINE_SPECS,
 };
 const BACKGROUND_SPECS = {
     imageKey: requiredString(),
@@ -283,6 +466,62 @@ export const designModules = Object.freeze({
         sizeOption: null,
     }),
 });
+/**
+ * The optional modules that decorate design objects of the core's types,
+ * by id. Unlike a {@link DesignModule}, a decoration adds no object: it is a
+ * look of an `image`, `emoji`, or `text` object, held in properties of that
+ * object, which the module draws.
+ *
+ * A tool that draws a design creates the module, with `new Class(game)`,
+ * before creating an object whose `enabledBy` property is above `0`.
+ *
+ * @example
+ * ```ts
+ * for (const schema of Object.values(designDecorations)) {
+ *   const used = design.objects.some((object) => (object[schema.enabledBy] ?? 0) > 0);
+ *   if (used) console.log(`${schema.className} from ${schema.file}`);
+ * }
+ * ```
+ */
+export const designDecorations = Object.freeze({
+    outline: Object.freeze({
+        module: "outline",
+        file: "minimo-outline.js",
+        className: "Outline",
+        types: Object.freeze(["image", "emoji", "text"]),
+        properties: Object.freeze(Object.keys(OUTLINE_SPECS)),
+        enabledBy: "outlineWidth",
+    }),
+});
+/**
+ * The first property of `object` that belongs to a decoration, or `null`.
+ *
+ * @internal
+ */
+export function findDecorationProperty(object) {
+    const fields = object;
+    for (const schema of Object.values(designDecorations)) {
+        if (!schema.types.includes(object.type))
+            continue;
+        for (const name of schema.properties) {
+            if (name in fields)
+                return name;
+        }
+    }
+    return null;
+}
+/**
+ * The decorations whose `enabledBy` property is above `0` in `object`.
+ *
+ * @internal
+ */
+export function enabledDecorations(object) {
+    const fields = object;
+    return Object.values(designDecorations).filter((schema) => {
+        const value = fields[schema.enabledBy];
+        return schema.types.includes(object.type) && typeof value === "number" && value > 0;
+    });
+}
 /** The properties every module object takes, whatever its module. */
 const MODULE_OBJECT_FIELDS = new Set(["id", "type", "module", "kind", "options", "name", "tags", "data"]);
 /** Checks a module object, already checked as a `module`, against its module's schema. */
@@ -437,7 +676,7 @@ function parseDesignFile(json) {
     }
     // Every version is current, so none is migrated: version 1 is a design
     // without pages, version 2 one divided into pages, and version 3 either,
-    // holding objects of an optional module.
+    // holding objects of an optional module or properties of a decoration.
     for (const field of Object.keys(json)) {
         if (!DESIGN_FILE_FIELDS[version].has(field)) {
             const hint = field === "pages" ? ` A design with pages has "version" 2.` : field === "objects" ? ` In version 2, objects belong to "pages".` : "";
@@ -459,6 +698,12 @@ function parseDesignFile(json) {
             if (object.type === "module" && version < 3) {
                 throw fail(`${at} is a "module" object, which only a design with "version" 3 holds, so that an older MinimoJS refuses the design by its version.`);
             }
+            if (version < 3) {
+                const decorated = findDecorationProperty(object);
+                if (decorated !== null) {
+                    throw fail(`${at} sets "${decorated}", which only a design with "version" 3 holds, so that an older MinimoJS refuses the design by its version.`);
+                }
+            }
             const id = object.id.toLowerCase();
             const first = whereById.get(id);
             if (first !== undefined) {
@@ -573,7 +818,8 @@ export class Design {
      * a `data` that is not a JSON object, a page without a UUID `id` or with
      * a missing, padded, or repeated `name`, and a `module` object in a design
      * older than version 3 or with a module, kind, property, or option that
-     * {@link designModules} does not list.
+     * {@link designModules} does not list, and a property of a decoration, such
+     * as `outlineWidth`, in a design older than version 3.
      *
      * @param json - The content of a `*.design.json` file. See {@link DesignFile}.
      */
@@ -641,6 +887,13 @@ export class Design {
         return this.objects.filter((object) => object.tags?.includes(tag) === true);
     }
 }
+function requireText(entry, field, where) {
+    const value = entry[field];
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw assetError(`${where} must have a non-empty string "${field}", found ${describe(value)}.`);
+    }
+    return value;
+}
 function isPlainObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }

package/dist/minimo-leaderboard.d.ts

@@ -116,9 +116,9 @@ export interface LeaderboardShowOptions {
  * On Minimo Games, the creator sets up a game's leaderboards, up to 5, on the
  * game's Edit leaderboards page, or an AI agent with the `saveGameLeaderboard`
  * tool; the game names one by its key. Their settings come from there, and a
- * key that no leaderboard of the game has is unavailable. Leaderboards are part
- * of Minimo Games Pro: while the creator is not on it, the game shows its
- * tables but saves no new records.
+ * key that no leaderboard of the game has is unavailable. Leaderboards save
+ * new records only while the creator's plan includes them: otherwise the game
+ * shows its tables but saves no new records.
  *
  * Scores of a leaderboard that takes Minimo Games accounts go to one table
  * that every player sees. Minimo Games posts them for the signed-in player, and

package/dist/minimo-leaderboard.js

@@ -265,9 +265,9 @@ export function renderLeaderboardHtml(table, view) {
  * On Minimo Games, the creator sets up a game's leaderboards, up to 5, on the
  * game's Edit leaderboards page, or an AI agent with the `saveGameLeaderboard`
  * tool; the game names one by its key. Their settings come from there, and a
- * key that no leaderboard of the game has is unavailable. Leaderboards are part
- * of Minimo Games Pro: while the creator is not on it, the game shows its
- * tables but saves no new records.
+ * key that no leaderboard of the game has is unavailable. Leaderboards save
+ * new records only while the creator's plan includes them: otherwise the game
+ * shows its tables but saves no new records.
  *
  * Scores of a leaderboard that takes Minimo Games accounts go to one table
  * that every player sees. Minimo Games posts them for the signed-in player, and

package/dist/minimo-multiplayer.d.ts

@@ -122,7 +122,7 @@ export interface RoomResultsOptions {
 }
 /**
  * What a room promise is refused with. `reason` is one of:
- * `unavailable` (not on Minimo Games, or the game's creator is not on Pro),
+ * `unavailable` (not on Minimo Games, or the creator's plan lacks multiplayer),
  * `cancelled` (the player closed the lobby), `room_not_found`, `full`,
  * `in_progress`, `removed`, `not_your_turn`, `stale` (another change came
  * first; read the room again and retry), `not_host`, `wrong_phase`,
@@ -288,8 +288,8 @@ export declare class Room {
  * frame: it suits card games, board games, word games, and races against the
  * clock, not action games.
  *
- * It works only inside Minimo Games, and only while the game's creator is on
- * Minimo Games Pro. Players need no account: a guest types a name once.
+ * It works only inside Minimo Games, and only while the game's creator's plan
+ * includes it. Players need no account: a guest types a name once.
  *
  * {@link Multiplayer.lobby} shows the lobby over the game, in HTML: creating a
  * room, joining one by its code, sharing its link, and waiting for the others
@@ -341,8 +341,8 @@ export declare class Multiplayer {
     /** The room the player is in, or `null`. */
     get room(): Room | null;
     /**
-     * Whether multiplayer can be played here: inside Minimo Games, with the
-     * game's creator on Pro.
+     * Whether multiplayer can be played here: inside Minimo Games, on a game
+     * whose creator's plan includes it.
      */
     available(): Promise<boolean>;
     /** Creates a room, without the lobby. The player is its host. */
@@ -353,7 +353,7 @@ export declare class Multiplayer {
      * The room this player is expected in, before any screen is shown: the room
      * whose link they opened, an invitation, or the room they were in on this
      * device before the page reloaded. `null` on a normal visit, outside
-     * Minimo Games, and when the game's creator is not on Pro.
+     * Minimo Games, and when the game's creator's plan lacks multiplayer.
      *
      * It opens nothing, joins nothing, and can be asked again: the room stays
      * pending until the player is in it. {@link Multiplayer.lobby} then takes
@@ -375,8 +375,8 @@ export declare class Multiplayer {
      * game from a room's link goes straight into that room, and one who reloads
      * the page returns to theirs.
      *
-     * Refused with `unavailable` outside Minimo Games or when the game's creator
-     * is not on Pro, after the lobby says so, and with `cancelled` when the
+     * Refused with `unavailable` outside Minimo Games or when the game's creator's
+     * plan lacks multiplayer, after the lobby says so, and with `cancelled` when the
      * player closes it.
      */
     lobby(): Promise<Room>;

package/dist/minimo-multiplayer.js

@@ -1,6 +1,6 @@
 /**
  * What a room promise is refused with. `reason` is one of:
- * `unavailable` (not on Minimo Games, or the game's creator is not on Pro),
+ * `unavailable` (not on Minimo Games, or the creator's plan lacks multiplayer),
  * `cancelled` (the player closed the lobby), `room_not_found`, `full`,
  * `in_progress`, `removed`, `not_your_turn`, `stale` (another change came
  * first; read the room again and retry), `not_host`, `wrong_phase`,
@@ -752,8 +752,8 @@ export class Room {
  * frame: it suits card games, board games, word games, and races against the
  * clock, not action games.
  *
- * It works only inside Minimo Games, and only while the game's creator is on
- * Minimo Games Pro. Players need no account: a guest types a name once.
+ * It works only inside Minimo Games, and only while the game's creator's plan
+ * includes it. Players need no account: a guest types a name once.
  *
  * {@link Multiplayer.lobby} shows the lobby over the game, in HTML: creating a
  * room, joining one by its code, sharing its link, and waiting for the others
@@ -817,8 +817,8 @@ export class Multiplayer {
         return this._room;
     }
     /**
-     * Whether multiplayer can be played here: inside Minimo Games, with the
-     * game's creator on Pro.
+     * Whether multiplayer can be played here: inside Minimo Games, on a game
+     * whose creator's plan includes it.
      */
     async available() {
         const info = await connectHost();
@@ -859,7 +859,7 @@ export class Multiplayer {
         const info = await request("hello", {}, HOST_TIMEOUT_MS * 2);
         this._info = info;
         if (!info.available) {
-            throw new MultiplayerError(info.preview ? "Multiplayer is part of Minimo Games Pro: this preview opens rooms once the game's creator is on Pro" : "Multiplayer is not available for this game", "unavailable");
+            throw new MultiplayerError(info.preview ? "Multiplayer is not on this account's plan: this preview opens rooms once it is" : "Multiplayer is not available for this game", "unavailable");
         }
         if (!this._listening) {
             this._listening = true;
@@ -924,7 +924,7 @@ export class Multiplayer {
      * The room this player is expected in, before any screen is shown: the room
      * whose link they opened, an invitation, or the room they were in on this
      * device before the page reloaded. `null` on a normal visit, outside
-     * Minimo Games, and when the game's creator is not on Pro.
+     * Minimo Games, and when the game's creator's plan lacks multiplayer.
      *
      * It opens nothing, joins nothing, and can be asked again: the room stays
      * pending until the player is in it. {@link Multiplayer.lobby} then takes
@@ -976,8 +976,8 @@ export class Multiplayer {
      * game from a room's link goes straight into that room, and one who reloads
      * the page returns to theirs.
      *
-     * Refused with `unavailable` outside Minimo Games or when the game's creator
-     * is not on Pro, after the lobby says so, and with `cancelled` when the
+     * Refused with `unavailable` outside Minimo Games or when the game's creator's
+     * plan lacks multiplayer, after the lobby says so, and with `cancelled` when the
      * player closes it.
      */
     async lobby() {

package/dist/minimo-outline.d.ts

@@ -0,0 +1,106 @@
+import { Game, Sprite } from "./minimo.js";
+/** How {@link Outline.set} outlines a sprite. */
+export interface OutlineOptions {
+    /**
+     * Width of the outline in the sprite's own pixels, before
+     * {@link Sprite.scale}, so it grows and shrinks with the sprite. `0`
+     * removes the outline. A width above {@link Outline.MAX_WIDTH} draws that
+     * width.
+     */
+    width: number;
+    /**
+     * CSS color of the outline, such as `"#fff5df"`, which may be translucent,
+     * such as `"rgba(0, 0, 0, 0.5)"`. Default `"#ffffff"`.
+     */
+    color?: string;
+}
+/** The outline a sprite has, as {@link Outline.get} reports it. */
+export interface OutlineStyle {
+    /** Width in the sprite's own pixels, before scale. */
+    readonly width: number;
+    /** CSS color. */
+    readonly color: string;
+}
+/**
+ * Draws a solid outline around the visible shape of image, emoji, and text
+ * sprites, so a character or an answer stands out from what is behind it.
+ *
+ * The outline follows the shape's transparent edges, not its box, and is
+ * part of the sprite's own picture: it moves, turns, flips, scales, fades,
+ * and changes layer with the sprite, and it shows in trails, wipes, and
+ * explosions of it. Only what is drawn grows. The sprite's size, collision
+ * body, the area that takes taps, and its pivot stay as they were.
+ *
+ * Each outline is built once and kept, so moving or turning a sprite costs
+ * nothing more. A new texture, new text, or a new width or color builds it
+ * again. Sprites that look the same share one outline.
+ *
+ * {@link DrawSprite}s, and the sprites made from it such as a flame or a die,
+ * are not outlined: they are redrawn every frame, which would rebuild the
+ * outline every frame.
+ *
+ * Create the module in the scene's `onCreate()`. It needs no `update()`.
+ *
+ * @example
+ * ```ts
+ * import { Outline } from "./minimo-outline.js";
+ *
+ * onCreate() {
+ *   const outlines = new Outline(game);
+ *   const frog = game.add(new ImageSprite(game, "frog", 360, 640));
+ *   outlines.set(frog, { width: 4, color: "#fff5df" });
+ * }
+ * ```
+ *
+ * ## In a design
+ *
+ * An `image`, `emoji`, or `text` object in a design takes an outline through
+ * two properties, which Studio shows among the object's properties:
+ *
+ * - `outlineWidth`: the width in the object's own pixels. `0`, the default,
+ *   draws none.
+ * - `outlineColor`: its CSS color. Default `"#ffffff"`.
+ *
+ * ```json
+ * { "id": "…", "type": "image", "name": "frog", "imageKey": "frog",
+ *   "x": 360, "y": 640, "outlineWidth": 4, "outlineColor": "#fff5df" }
+ * ```
+ *
+ * A design holding either property has `"version": 3`. The outline is a look
+ * of the object, not an object of its own: there is no `module` object for it.
+ * Create the module before the design's objects, or creating an object whose
+ * `outlineWidth` is above `0` throws an error naming it:
+ *
+ * ```ts
+ * onCreate() {
+ *   this.outlines = new Outline(game);
+ *   const screen = game.createObjectList(menu.objects);
+ *   const frog = screen.findByName("frog");
+ *   // Change it while the game plays, such as on the chosen answer:
+ *   this.outlines.set(frog, { width: 6, color: "#ffd84a" });
+ * }
+ * ```
+ */
+export declare class Outline {
+    /** The widest outline drawn, in the sprite's own pixels. */
+    static readonly MAX_WIDTH = 64;
+    /** The game whose sprites it outlines. */
+    readonly game: Game;
+    constructor(game: Game);
+    /**
+     * Outlines `sprite`, or changes its outline. A width of `0` removes it.
+     * @param sprite - An {@link ImageSprite}, {@link EmojiSprite}, or {@link TextSprite}, or a subclass of one.
+     * @param options - The width, and the color, white by default.
+     */
+    set(sprite: Sprite, options: OutlineOptions): void;
+    /**
+     * The outline `sprite` has, or `null` when it has none.
+     * @param sprite - Any sprite.
+     */
+    get(sprite: Sprite): OutlineStyle | null;
+    /**
+     * Removes the outline of `sprite`. Nothing happens when it has none.
+     * @param sprite - Any sprite.
+     */
+    remove(sprite: Sprite): void;
+}