@originkit/avatars 0.0.0-stage → 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The public entry, shared by the npm package, the CLI, the MCP server and the studio's
+ * export: a style and a name in, an SVG out. The same inputs always give the same SVG.
+ */
+import type { Overrides } from "./traits.ts";
+export type { Overrides } from "./traits.ts";
+/** Every style, in the studio's order. */
+export declare const styles: {
+    id: string;
+    label: string;
+}[];
+/** The avatar for `name` in `style`. Throws on a style that doesn't exist. */
+export declare function createAvatar(style: string, name: string, overrides?: Overrides): string;

package/dist/index.js

@@ -0,0 +1,16 @@
+/**
+ * The public entry, shared by the npm package, the CLI, the MCP server and the studio's
+ * export: a style and a name in, an SVG out. The same inputs always give the same SVG.
+ */
+import { KINDS } from "./kinds.js";
+/** Every style, in the studio's order. */
+export const styles = KINDS.map(({ id, label }) => ({ id, label }));
+/** CC BY 4.0 asks for a credit wherever the Faces art goes, so it travels with the file. */
+const FACES_CREDIT = '<!-- Faces art: "Adventurer Neutral" by Lisa Wischofsky, CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/), changed. -->\n';
+/** The avatar for `name` in `style`. Throws on a style that doesn't exist. */
+export function createAvatar(style, name, overrides) {
+    const kind = KINDS.find((k) => k.id === style);
+    if (!kind)
+        throw new Error(`Unknown style "${style}". Styles: ${styles.map((s) => s.id).join(", ")}`);
+    return (style === "faces" ? FACES_CREDIT : "") + kind.svg(name, overrides);
+}

package/dist/kinds.d.ts

@@ -0,0 +1,30 @@
+/** The avatar types a visitor can choose from. */
+import type { ControlBuilder } from "./controls.ts";
+import type { Overrides } from "./traits.ts";
+import type { AvatarParts } from "./types.ts";
+export interface AvatarKind {
+    id: string;
+    label: string;
+    group: string;
+    hint: string;
+    defaultName: string;
+    controls: ControlBuilder;
+    /** What it is, its face and its colour, shown up front in order. The rest sit under More options. */
+    essentials: string[];
+    /** The controls that set a look apart most. Each variant takes a different value of each. */
+    styleKeys: string[];
+    /** Settings for how it is shown rather than what it looks like, which thumbnails leave out. */
+    displayKeys?: string[];
+    /** A still picture, for thumbnails and as the fallback when 3D cannot run. */
+    svg(name: string, overrides?: Overrides): string;
+    /** Present on kinds drawn in 3D. */
+    parts?(name: string, overrides?: Overrides): AvatarParts;
+    /** Kept, and tested, but not shown on the canvas for now. */
+    hidden?: boolean;
+    /** Never moves, so the panel leaves out Motion. */
+    still?: boolean;
+}
+export declare const KINDS: AvatarKind[];
+/** The kinds shown on the canvas, which leaves out any hidden for now. */
+export declare const SHOWN: AvatarKind[];
+export declare const toDataUri: (svg: string) => string;

package/dist/kinds.js

@@ -0,0 +1,266 @@
+/** The avatar types a visitor can choose from. */
+import { controls as auraControls } from "./auras/controls.js";
+import { auraSvg } from "./auras/index.js";
+import { controls as blobControls } from "./blobs/controls.js";
+import { blobParts, generateBlob } from "./blobs/index.js";
+import { controls as bubbleControls } from "./bubbles/controls.js";
+import { bubbleSvg } from "./bubbles/index.js";
+import { controls as botControls } from "./bots/controls.js";
+import { botParts, generateBot } from "./bots/index.js";
+import { controls as buddyControls } from "./buddies/controls.js";
+import { buddySvg } from "./buddies/index.js";
+import { controls as doodleControls } from "./doodles/controls.js";
+import { animalControls } from "./kitties/controls.js";
+import { animalSvg } from "./kitties/index.js";
+import { doodleSvg } from "./doodles/index.js";
+import { controls as faceControls } from "./faces/controls.js";
+import { faceSvg } from "./faces/index.js";
+import { controls as critterControls } from "./critters/controls.js";
+import { critterSvg } from "./critters/index.js";
+import { controls as glanceControls } from "./glances/controls.js";
+import { controls as knitControls } from "./knits/controls.js";
+import { knitSvg } from "./knits/index.js";
+import { controls as grinControls } from "./grins/controls.js";
+import { grinSvg } from "./grins/index.js";
+import { glanceSvg } from "./glances/index.js";
+import { controls as glyphControls } from "./glyphs/controls.js";
+import { controls as gummyControls } from "./gummies/controls.js";
+import { gummyParts, gummySvg } from "./gummies/index.js";
+import { glyphSvg } from "./glyphs/index.js";
+import { controls as mallowControls } from "./mallows/controls.js";
+import { mallowParts, mallowSvg } from "./mallows/index.js";
+import { controls as peekControls } from "./peeks/controls.js";
+import { peekSvg } from "./peeks/index.js";
+import { colorControls } from "./pixels/controls.js";
+import { controls as shapeControls } from "./shapes/controls.js";
+import { shapeSvg } from "./shapes/index.js";
+import { pixelSvg } from "./pixels/index.js";
+export const KINDS = [
+    {
+        id: "bots",
+        label: "Bots",
+        group: "3D",
+        hint: "Move your mouse and it looks at you",
+        defaultName: "Nova",
+        controls: botControls,
+        // The container's size and colour join it only while it's on, which may make 8.
+        essentials: ["head", "eye", "paint"],
+        styleKeys: ["head"],
+        displayKeys: ["container.size"],
+        svg: generateBot,
+        parts: botParts,
+    },
+    {
+        id: "blobs",
+        label: "Blobs",
+        group: "3D",
+        hint: "Move your mouse and it looks at you",
+        defaultName: "Rex-7",
+        controls: blobControls,
+        // As with bots, the container's size and colour join it only while it's on.
+        essentials: ["shape", "hue", "tone"],
+        styleKeys: ["shape"],
+        displayKeys: ["container.size"],
+        svg: generateBlob,
+        parts: blobParts,
+    },
+    {
+        id: "gummies",
+        label: "Gummies",
+        group: "3D",
+        hint: "A jelly in 3D, lit from inside. It watches you, and boings when tapped",
+        defaultName: "Juju",
+        controls: gummyControls,
+        // Its colour controls and Possibilities were asked for up front, so it shows 9.
+        essentials: ["body", "face", "glow"],
+        styleKeys: ["body", "face", "topper", "glow"],
+        svg: gummySvg,
+        parts: gummyParts,
+    },
+    {
+        id: "mallows",
+        label: "Mallows",
+        group: "3D",
+        hint: "Soft clay in 3D, a bun, a ghost or a cloud, and every one feels something different. It watches you, and boings when tapped",
+        defaultName: "Momo",
+        controls: mallowControls,
+        // Eyes and Pose were asked for up front beside the rest, so it shows 8. As with bots, the
+        // container's size and colour join it only while it's on.
+        essentials: ["type", "face", "colour"],
+        // One bun for every name, as asked, so only its feeling sets variants apart.
+        styleKeys: ["face"],
+        displayKeys: ["container.size"],
+        svg: mallowSvg,
+        parts: mallowParts,
+    },
+    {
+        id: "faces",
+        label: "Faces",
+        group: "Illustrated",
+        hint: "Its eyes follow you. Tap it to see what it does",
+        defaultName: "Maya",
+        controls: faceControls,
+        essentials: ["eyes", "mouth", "skin"],
+        styleKeys: ["mouth"],
+        svg: faceSvg,
+    },
+    {
+        id: "bubbles",
+        label: "Bubbles",
+        group: "Illustrated",
+        hint: "Its eyes follow you. Write anything on it",
+        defaultName: "Felix",
+        controls: bubbleControls,
+        essentials: ["shape", "mouth", "palette"],
+        styleKeys: ["shape", "palette"],
+        svg: bubbleSvg,
+    },
+    {
+        id: "pixels",
+        label: "Pixels",
+        group: "Pixel",
+        hint: "Its eyes follow you. Hover over it and it perks up",
+        defaultName: "Finn",
+        controls: colorControls,
+        essentials: ["hair", "hair.color", "hat.color", "skin"],
+        styleKeys: ["hair"],
+        svg: (name, overrides) => pixelSvg(name, "color", overrides),
+    },
+    {
+        id: "glyphs",
+        label: "Glyphs",
+        group: "Illustrated",
+        hint: "Its eyes follow you. Hover over it and it grows",
+        defaultName: "Priya",
+        controls: glyphControls,
+        essentials: ["shape", "fill", "tile"],
+        styleKeys: ["shape"],
+        svg: glyphSvg,
+    },
+    {
+        id: "peeks",
+        label: "Peeks",
+        group: "Illustrated",
+        hint: "It's watching you. Tap it to see what it does",
+        defaultName: "Milo",
+        controls: peekControls,
+        // Possibilities was asked for up front beside the rest, so it shows 7.
+        essentials: ["body", "eye.kind", "tile"],
+        styleKeys: ["body", "pose", "tile"],
+        svg: peekSvg,
+    },
+    {
+        id: "doodles",
+        label: "Doodles",
+        group: "Illustrated",
+        hint: "Its eyes follow you. Hover over it and it perks up",
+        defaultName: "Kiko",
+        controls: doodleControls,
+        essentials: ["mood", "tile", "colourful"],
+        // Colourful is off until switched on, so Colourway isn't always there to step through.
+        styleKeys: ["mood", "tile"],
+        svg: doodleSvg,
+    },
+    {
+        id: "animals",
+        label: "Animals",
+        group: "Illustrated",
+        hint: "A cat, a dog, an owl, a bear or a tiger, drawn like the cats. Hover over it and its ears twitch",
+        defaultName: "Biscuit",
+        controls: animalControls,
+        essentials: ["animal", "mood", "tile"],
+        styleKeys: ["mood", "ears", "tile"],
+        svg: animalSvg,
+    },
+    {
+        id: "buddies",
+        // Hidden for now, as asked. Its code stays as it was.
+        hidden: true,
+        label: "Buddies",
+        group: "Illustrated",
+        hint: "A tabby or a calico, up to something. Hover over it and its eyes widen",
+        defaultName: "Mochi",
+        controls: buddyControls,
+        essentials: ["character", "mood", "tile"],
+        styleKeys: ["gesture", "mood", "tile"],
+        svg: buddySvg,
+    },
+    {
+        id: "shapes",
+        label: "Shapes",
+        group: "Illustrated",
+        hint: "A face put together from bold shapes. Its eyes follow you. Tap it and they hop",
+        defaultName: "Lumi",
+        controls: shapeControls,
+        essentials: ["eye.left", "eye.right", "mouth", "tile"],
+        styleKeys: ["eye.left", "eye.right", "mouth", "colourway"],
+        svg: shapeSvg,
+    },
+    {
+        id: "critters",
+        label: "Critters",
+        group: "Illustrated",
+        hint: "A monster, a cyclops, a bear, a duck, a chick, an imp or a grump, up close. It watches you and blinks, and pops when tapped",
+        defaultName: "Gobo",
+        controls: critterControls,
+        essentials: ["kind", "feeling", "body"],
+        // Variants step through the creatures in the generator, as the animals' are different animals.
+        styleKeys: ["feeling", "body"],
+        svg: critterSvg,
+    },
+    {
+        id: "grins",
+        label: "Grins",
+        group: "Illustrated",
+        hint: "A button of a face, a tile or round, with a big toothy grin. Its googly eyes follow you and blink, and it chomps when tapped",
+        defaultName: "Zuzu",
+        controls: grinControls,
+        essentials: ["eyes", "mouth", "body"],
+        styleKeys: ["eyes", "mouth", "body"],
+        svg: grinSvg,
+    },
+    {
+        id: "knits",
+        // Hidden for now, as asked. Its code stays as it was.
+        hidden: true,
+        label: "Knits",
+        group: "Illustrated",
+        hint: "A bust in a knitted balaclava and a ribbed beanie. Its eyes follow you and blink",
+        defaultName: "Kade",
+        controls: knitControls,
+        essentials: ["mood", "hat", "mask"],
+        styleKeys: ["mood", "mask", "clothes"],
+        svg: knitSvg,
+    },
+    {
+        id: "glances",
+        label: "Glances",
+        group: "Illustrated",
+        hint: "Just two eyes. They follow you, glance about and blink, and pop when tapped",
+        defaultName: "Nyx",
+        controls: glanceControls,
+        essentials: ["eye.left", "eye.right", "tile"],
+        styleKeys: ["eye.left", "eye.right", "tile"],
+        svg: glanceSvg,
+    },
+    {
+        id: "auras",
+        // No animation at all, as asked: no drift, cursor, hover or tap, and no Motion controls.
+        still: true,
+        label: "Auras",
+        group: "Illustrated",
+        hint: "Soft colour melting together under a fine grain, or a sky, on a rounded tile. It holds perfectly still",
+        defaultName: "Luma",
+        controls: auraControls,
+        // The type and a sky's horizon were asked for up front beside the rest, as the animals'
+        // type is. Formation is only an aura's and Horizon only a sky's, so it shows 7.
+        essentials: ["type", "flow", "palette", "face"],
+        // Variants step through the types, formations and palettes themselves, as Mallows do,
+        // since each type has palettes of its own. See `stepped` in auras/index.ts.
+        styleKeys: [],
+        svg: auraSvg,
+    },
+];
+/** The kinds shown on the canvas, which leaves out any hidden for now. */
+export const SHOWN = KINDS.filter((kind) => !kind.hidden);
+export const toDataUri = (svg) => `data:image/svg+xml,${encodeURIComponent(svg)}`;

package/dist/kitties/calming.d.ts

@@ -0,0 +1,8 @@
+/**
+ * What Possibilities calms on a cat. Low keeps to the eight mildest expressions, one for
+ * each variant, smooth fur and the reference's corner poses. Every ear stays, so the
+ * variants still differ in silhouette. Indices are into the lists in `index.ts`.
+ */
+import type { Calming } from "../possibilities.ts";
+export declare const CALMING: Calming;
+export declare const NOTES: [string, string, string];

package/dist/kitties/calming.js

@@ -0,0 +1,19 @@
+/**
+ * What Possibilities calms on a cat. Low keeps to the eight mildest expressions, one for
+ * each variant, smooth fur and the reference's corner poses. Every ear stays, so the
+ * variants still differ in silhouette. Indices are into the lists in `index.ts`.
+ */
+export const CALMING = {
+    features: /^(head|eye|ear|whisker|lid|body)\.|^tilt$/,
+    lists: {
+        // Curious, Happy, Sleepy, Smug, Grumpy, Annoyed, Shocked, Hungry, then Sassy, Sly, Smitten, Menacing, Dizzy.
+        mood: [13, 8, [2, 4, 3, 1, 7, 0, 5, 8, 12, 6, 9, 10, 11]],
+        pose: [6, 2],
+        "fur.style": [3, 1],
+    },
+};
+export const NOTES = [
+    "mild moods like curious, happy and sleepy, with smooth fur, sitting in from the corner.",
+    "adds sassy and sly looks, fluffy and chubby cheeks, and more poses.",
+    "every expression, up to smitten, menacing and dizzy, in any pose.",
+];

package/dist/kitties/controls.d.ts

@@ -0,0 +1,2 @@
+import { type ControlBuilder } from "../controls.ts";
+export declare const animalControls: ControlBuilder;

package/dist/kitties/controls.js

@@ -0,0 +1,43 @@
+import { choice, fixedPalette, palette, slider } from "../controls.js";
+import { calmed, narrowed, possibilitiesSlider } from "../possibilities.js";
+import { createTraits } from "../traits.js";
+import { CALMING, NOTES } from "./calming.js";
+import { EARS, EYE_COLOURS, FUR_STYLES, FURS, MOODS, POSES, SPECIES, speciesOf, TILES, VIEWS } from "./index.js";
+const named = (list) => list.map(({ name: label }) => ({ label }));
+/** Cats, or Animals, which also picks the animal and hides what it doesn't have. */
+const controlsFor = (animals) => (name, overrides) => {
+    const t = calmed(createTraits(name, overrides), CALMING);
+    const list = (control) => narrowed(control, t, CALMING);
+    const species = animals ? speciesOf(t) : SPECIES[0];
+    return [
+        {
+            title: "Face",
+            controls: [
+                list(choice(t, "mood", "Expression", "list", named(MOODS))),
+                possibilitiesSlider(t, NOTES),
+                fixedPalette(t, "eyes.color", "Eye colour", EYE_COLOURS),
+                slider(t, "eye.size", "Eye size", 0, 100, "%"),
+                slider(t, "eye.gap", "Eye gap", 0, 100, "%"),
+                ...(species.whiskers ? [slider(t, "whisker.length", "Whiskers", 0, 100, "%")] : []),
+            ],
+        },
+        {
+            title: animals ? "Animal" : "Cat",
+            controls: [
+                ...(animals ? [choice(t, "animal", "Animal", "list", named(SPECIES))] : []),
+                // The owl is drawn from its own reference, in one view.
+                ...(species.view ? [] : [choice(t, "view", "View", "list", named(VIEWS))]),
+                choice(t, "ears", "Ears", "list", named(EARS)),
+                list(choice(t, "pose", "Pose", "list", named(POSES))),
+                ...(species.cheeks ? [] : [list(choice(t, "fur.style", "Cheeks", "list", named(FUR_STYLES)))]),
+                slider(t, "head.width", "Head width", 0, 100, "%"),
+                slider(t, "tilt", "Tilt", -5, 5, "°"),
+            ],
+        },
+        {
+            title: "Colour",
+            controls: [palette(t, "tile", "Colour", TILES), fixedPalette(t, "fur", "Fur", FURS)],
+        },
+    ];
+};
+export const animalControls = controlsFor(true);

package/dist/kitties/index.d.ts

@@ -0,0 +1,181 @@
+/**
+ * Cats, traced from the reference: a black cat in three-quarter view, its head tipped and
+ * coming in from the corner. Its ears have rounded tips and edges that bulge a little, and
+ * a dark inner ear. Each eye is an ellipse cut straight across by the lid through its
+ * middle, so the corner by the nose is sharp and the outer end round, and the lid's angle
+ * is most of the mood. The nose sits off towards the far eye, and the mouth is a thick
+ * grey line, longer on the near side, with a single fang.
+ *
+ * There are two views, each traced from its own reference: turned three-quarters, and nearly
+ * face on with a pink nose and an open mouth. Points are in tile units, traced from 1200 px
+ * drawings at a twelfth of their size. The face is drawn upright about the nose, then turned
+ * with the head by the view's tilt.
+ */
+import { type Overrides, type Traits } from "../traits.ts";
+export declare const TILES: string[];
+export declare const FURS: string[];
+export declare const EYE_COLOURS: string[];
+type Point = readonly [number, number];
+interface Ear {
+    inner: Point;
+    tip: Point;
+    outer: Point;
+}
+/** One way of seeing the cat, each traced from its own reference. */
+interface View {
+    name: string;
+    /** The middle of the head, which it grows about, and the nose, which the face hangs from. */
+    centre: Point;
+    nose: Point;
+    /** How far the face is tipped, and how big it is against the three-quarter one's. */
+    tilt: number;
+    /** Fits the traced drawing to the tile, before any pose. */
+    frame: string;
+    /** The head without its ears, clockwise from under the left ear, and which points are cheeks. */
+    head: Point[];
+    cheeks: number[];
+    body: Point[];
+    /** Each ear by where it meets the head and where its tip is. */
+    ears: [Ear, Ear];
+    /** Whiskers as root, bend and end, three a side. */
+    whiskers: Point[][];
+    /** The eyes in the face's frame, far then near. */
+    eyes: {
+        c: Point;
+        rx: number;
+        ry: number;
+    }[];
+    noseShape: string;
+    /** What the nose and the inside of the ears are tinted towards, and how far. */
+    noseTint: [string, number];
+    earTint: [string, number];
+    /** Grey whiskers all the way out, rather than fur over the tile. */
+    greyWhiskers?: boolean;
+    /** Pupils that hang as tall ovals, rather than circles. */
+    tallPupils?: boolean;
+    /** Pupils that look in towards the nose, a glare, rather than aside. */
+    pupilsIn?: boolean;
+}
+/** Neighbours are as unlike as possible, since each variant steps to the next. */
+export declare const VIEWS: View[];
+interface Pose {
+    name: string;
+    x: number;
+    y: number;
+    scale: number;
+    turn: number;
+    mirrored?: boolean;
+}
+/** The first is the reference, in from the corner. */
+export declare const POSES: Pose[];
+interface Ears {
+    name: string;
+    /** Length against the reference's, how far the tips lean out, and how round they are. */
+    height: number;
+    flare: number;
+    round: number;
+    notch?: boolean;
+    tuft?: boolean;
+    /** Short and folded forward, so the inside doesn't show. */
+    folded?: boolean;
+    /** One ear flopped out to the side. */
+    odd?: boolean;
+}
+/** Neighbours are as unlike as possible, since each variant steps to the next. */
+export declare const EARS: Ears[];
+/** Collars come in a few colours; the first is the reference's grey, taken from the fur. */
+export declare const COLLARS: string[];
+type EarKind = "point" | "tuft" | "round";
+/**
+ * An animal, drawn in the cat's finish: flat fur, details in grey line, the same eyes. Each
+ * has its own anatomy, though, so none reads as a cat with other ears.
+ */
+interface Species {
+    name: string;
+    /** Pointed like a cat's, a dog's or a tiger's, feather tufts like an owl's, or round like a bear's. */
+    ears: EarKind;
+    /** An owl has its discs, chest feathers and wing; a dog its muzzle and collar; a tiger its stripes. */
+    head?: "dog" | "owl" | "tiger";
+    /** How round the ear tips are at the least, and how far their edges bow out. */
+    earRound?: number;
+    earBulge?: number;
+    /** How far the inside of the ear is drawn in from its edge, for a wider border of fur. */
+    earInset?: number;
+    /** Cheeks it always has, rather than the name's. */
+    cheeks?: "Smooth" | "Fluffy" | "Chubby";
+    nose: "cat" | "dog" | "bear" | "beak" | "tiger";
+    whiskers?: boolean;
+    /** Shows the mood's fangs. */
+    fangs?: boolean;
+    /** Drawn from its own reference, rather than from the cat's views. */
+    view?: View;
+}
+/** The animals. Neighbours are as unlike as possible. */
+export declare const SPECIES: Species[];
+export declare const FUR_STYLES: {
+    name: string;
+}[];
+/** Open, shut, smiling shut, or cut by the lid at a slope towards the nose and a depth. */
+type Lid = "open" | "closed" | "happy" | readonly [slope: number, depth: number];
+type Pupil = "none" | "hang" | "big" | "tiny" | "slit" | "heart" | "cross";
+interface Mood {
+    name: string;
+    lids: [Lid, Lid];
+    pupil: Pupil;
+    mouth: keyof typeof MOUTHS;
+    fangs?: 1 | 2;
+}
+/** Every expression. The first two are the references. */
+export declare const MOODS: Mood[];
+/** In the face's frame: the nose at 0 0, the near side to the right. */
+declare const MOUTHS: {
+    none: string;
+    smirk: string;
+    w: string;
+    smile: string;
+    frown: string;
+    flat: string;
+    oh: string;
+    tongue: string;
+    open: string;
+};
+export declare const viewOf: (t: Traits) => View;
+export declare const speciesOf: (t: Traits) => Species;
+export declare const moodOf: (t: Traits) => Mood;
+export declare const poseOf: (t: Traits) => Pose;
+export declare const earsOf: (t: Traits) => Ears;
+export declare const furStyleOf: (t: Traits) => {
+    name: string;
+};
+export declare function coloursOf(t: Traits): {
+    tile: string;
+    fur: string;
+    eye: string;
+};
+export interface Kitty {
+    /** Clip paths and the tile's grain, which the drawing refers to by id. */
+    defs: string;
+    tile: string;
+    pose: string;
+    mirrored: boolean;
+    /** Body, head, fluff and whiskers. */
+    body: string;
+    ears: [string, string];
+    /** Whether the ears are drawn over the head rather than behind it. */
+    earsFront: boolean;
+    /** Each eye, with its pupil marked so it can look about inside it. */
+    eyes: string;
+    face: string;
+    /** What sits round the eyes and keeps still while they blink: an owl's disc, a dog's brows. */
+    discs: string;
+    blinkDelay: number;
+}
+/** Cats draws only cats; Animals picks the animal too, with ids of its own so both can be on the page. */
+export declare function createKitty(name: string, overrides?: Overrides, animals?: boolean, ids?: string): Kitty;
+export declare const TILE_SHAPE = "<rect width=\"100\" height=\"100\" rx=\"22.22\"/>";
+/** The id prefix each section's drawing uses. */
+export declare const prefixOf: (animals: boolean) => "animal" | "kitty";
+/** The tile and its grain, which sit still behind the animal. */
+export declare const tileMarkup: (fill: string, ids: string) => string;
+export declare const animalSvg: (name: string, overrides?: Overrides) => string;
+export {};