strokes-js 0.1.0

package/README.md

@@ -0,0 +1,211 @@
+# strokes-js
+
+Renders text as animated hand-drawn SVG. Each letter is a real monoline glyph path (not a font), drawn in with a stroke animation as its word scrolls into view — with per-letter randomness (rotation, baseline drift, scale, and multiple hand-drawn variants per character) so the same word never renders identically twice.
+
+- Zero dependencies, ESM, TypeScript strict, ~small
+- Full a–z, A–Z, 0–9, and punctuation (`. , ! ? ' -`) coverage
+- Scroll-triggered draw-in animation via `IntersectionObserver`, or static fully-drawn output
+- Styleable with one CSS custom property (`--hw-color`)
+
+## Install
+
+```bash
+npm install strokes-js
+```
+
+## Usage
+
+### Quick start — `write()`
+
+The simplest way to use the library: one call renders the text and wires up the animation.
+
+```html
+<div id="hello"></div>
+<script type="module">
+  import { write } from "strokes-js";
+
+  write("#hello", "Hello, world!");
+</script>
+```
+
+`write()` accepts a CSS selector string or an `HTMLElement` directly:
+
+```js
+write(document.getElementById("hello"), "Hello, world!");
+```
+
+By default, letters draw themselves in when the target element scrolls into view. Pass `{ animate: false }` for static, fully-drawn output with no scroll observer:
+
+```js
+write("#hello", "Static text", { animate: false });
+```
+
+### Manual control — `renderText()` + `attach()`
+
+For cases where you want the markup without the library touching the DOM directly (e.g. server-side rendering, or inserting the HTML yourself), use the two lower-level pieces `write()` is built from:
+
+```js
+import { renderText, attach } from "strokes-js";
+
+const el = document.getElementById("hello");
+el.innerHTML = renderText("Hello, world!"); // animate: true by default
+attach(el); // wires the scroll-triggered draw-in
+```
+
+`renderText()` returns a plain HTML string, so it also works outside the browser (no `document` access needed) — only `attach()` and `animateWriting()` touch the DOM.
+
+### Triggering the animation manually
+
+If you don't want scroll-triggering at all — e.g. you want the animation to start on a button click, a timer, or a route transition — skip `attach()` and call `animateWriting()` yourself on each rendered word:
+
+```js
+import { renderText, animateWriting } from "strokes-js";
+
+el.innerHTML = renderText("Hello, world!");
+button.addEventListener("click", () => {
+  for (const word of el.querySelectorAll(".hw-word")) {
+    animateWriting(word);
+  }
+});
+```
+
+### Styling color
+
+Stroke color is controlled entirely through the `--hw-color` CSS custom property (falls back to `#000`):
+
+```css
+#hello {
+  --hw-color: #c0392b;
+}
+```
+
+or per-render from JS:
+
+```js
+el.style.setProperty("--hw-color", "#c0392b");
+```
+
+## API
+
+### `write(target, text, options?)`
+
+One-call entry point: renders `text` into `target` and (unless `animate: false`) wires up the scroll-triggered draw-in animation.
+
+| Param     | Type                    | Description                                                                                 |
+| --------- | ----------------------- | ------------------------------------------------------------------------------------------- |
+| `target`  | `HTMLElement \| string` | Element to render into, or a CSS selector. No-ops silently if the selector matches nothing. |
+| `text`    | `string`                | Text to render.                                                                             |
+| `options` | `WriteOptions`          | See below.                                                                                  |
+
+`WriteOptions` = `RenderTextOptions & AttachOptions` (all fields optional, documented below).
+
+### `renderText(text, options?)`
+
+Returns an HTML string: a `<span class="hw-sentence">` wrapping one `<svg class="hw-word">` per word. Pure string output — safe to call without a `document` (e.g. during SSR).
+
+**`RenderTextOptions`**
+
+| Option    | Type      | Default | Description                                                                                                                                                                                                                                         |
+| --------- | --------- | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `animate` | `boolean` | `true`  | When `true`, each letter's path is rendered with `stroke-dasharray/dashoffset` primed for the draw-in transition (invisible until `animateWriting()` runs on it). When `false`, letters render fully drawn immediately, with no transition styling. |
+
+### `attach(el, options?)`
+
+Wires an `IntersectionObserver` to `el` so that when it scrolls into view, every `.hw-word` inside it is passed to `animateWriting()`.
+
+**`AttachOptions`** (a subset of standard `IntersectionObserverInit`, plus `once`)
+
+| Option       | Type                 | Default           | Description                                                                                                                                                                                                                 |
+| ------------ | -------------------- | ----------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `root`       | `Element \| null`    | `null` (viewport) | Passed through to `IntersectionObserver`.                                                                                                                                                                                   |
+| `rootMargin` | `string`             | `"0px"`           | Passed through to `IntersectionObserver`.                                                                                                                                                                                   |
+| `threshold`  | `number \| number[]` | `0`               | Passed through to `IntersectionObserver`.                                                                                                                                                                                   |
+| `once`       | `boolean`            | `true`            | If `true`, stops observing `el` after the first time it intersects (animation fires once). Set `false` to re-trigger every time it re-enters the viewport (combine with re-rendering if you want fresh variants each time). |
+
+### `animateWriting(el)`
+
+Starts the draw-in transition immediately on a rendered `.hw-word` element (or any element containing `.hw-letter` paths): adds the `hw-visible` class and sets each letter path's `stroke-dashoffset` to `0`. This is what `attach()` calls automatically on intersection — call it directly if you're driving the animation from something other than scroll (see [Triggering the animation manually](#triggering-the-animation-manually)).
+
+## How the animation works
+
+Each letter is an SVG `<path>` with `pathLength="1"`, `stroke-dasharray:1`, and `stroke-dashoffset:1` — the path is drawn but entirely hidden behind its own dash gap. `animateWriting()` sets `stroke-dashoffset` to `0`, and a CSS `transition` (declared inline per-path, staggered by letter index) animates the stroke drawing in left to right, letter by letter, word by word. Stagger and stroke duration are fixed internally (60ms per letter offset, 400ms draw per letter) — not currently configurable via options.
+
+## Handwriting randomness
+
+Two independent layers of randomness make repeated text look hand-written rather than stamped:
+
+1. **Variant selection** — most glyphs ship with multiple (typically 3) hand-drawn path variants. Each time a character is rendered, a variant is picked at random, with one rule: it never repeats the same variant used the previous time that character was rendered (tracked per-character, process-wide), so runs of the same letter don't look identical back to back.
+2. **Per-instance jitter** — independent of variant, every rendered letter gets a small random `rotate` (±7°), baseline `dy` drift (±1 unit), and `scale` (±10%), applied via an SVG transform pivoted around the letter's own center (so jitter never shifts later letters in a word out of position). This is freshly randomized on every render — it is not seeded or reproducible.
+
+Both layers use `Math.random()` directly and are **not deterministic** — re-rendering the same text will look slightly different each time. This is intentional (it's what makes it read as handwriting rather than a font).
+
+## Styling & class names
+
+| Class         | Applied to                  | Purpose                                                                                                                 |
+| ------------- | --------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
+| `hw-sentence` | outer `<span>`              | Wraps all words for one `renderText()` call; carries `aria-label` with the original text.                               |
+| `hw-word`     | one `<svg>` per word        | The unit `attach()`/`animateWriting()` operate on.                                                                      |
+| `hw-letter`   | one `<path>` per letter     | Individual glyph stroke.                                                                                                |
+| `hw-visible`  | added to `hw-word` elements | Set by `animateWriting()` once triggered; useful as a CSS hook if you want to react to "this word has started drawing." |
+
+Color is the one themeable value, via the `--hw-color` custom property (see [Styling color](#styling-color)). Stroke width (`2`) and letter height (`24` units, viewBox-relative) are currently fixed, not configurable.
+
+## Accessibility
+
+- The outer `hw-sentence` span carries `aria-label="<original text>"` (HTML-escaped), so screen readers announce the real text rather than trying to parse decorative SVG paths.
+- Every `hw-word` SVG has `aria-hidden="true"`, removing the decorative glyph paths from the accessibility tree.
+
+## Glyph coverage
+
+| Set         | Characters              |
+| ----------- | ----------------------- |
+| Lowercase   | `a`–`z`                 |
+| Uppercase   | `A`–`Z`                 |
+| Digits      | `0`–`9`                 |
+| Punctuation | `.` `,` `!` `?` `'` `-` |
+
+Characters outside this set (other punctuation, whitespace beyond the plain space used to split words, non-Latin scripts, emoji) are silently skipped — they contribute no path and no width. Unsupported _uppercase_ input falls back to the lowercase glyph if one exists (e.g. an accidental extra capital); punctuation is matched exactly, with no case folding.
+
+## Project structure
+
+```
+src/
+  index.ts                     — write(), public exports
+  renderer.ts                  — renderText(), animateWriting(), jitter/variant logic
+  observer.ts                  — attach(), IntersectionObserver wiring
+  glyphs/
+    types.ts                   — GlyphEntry / GlyphDatabase types
+    glyphs.ts                  — aggregates every glyph module into one lookup table
+    letters/letter-<x>.ts      — one file per lowercase letter (width + variant paths)
+    letters/letter-<x>-upper.ts — one file per uppercase letter
+    digits/digit-<n>.ts        — one file per digit
+    punctuation/punct-<name>.ts — one file per punctuation glyph
+scripts/
+  extract-glyphs.ts            — stub, not implemented
+demo/
+  index.html                   — live playground + full glyph gallery
+```
+
+Each glyph file exports a single `GlyphEntry`:
+
+```ts
+export interface GlyphEntry {
+  width: number; // advance width, in the same units as the 24-unit-tall viewBox
+  variants: string[]; // one or more monoline SVG path `d` strings, hand-drawn within 0 0 width 24
+}
+```
+
+Adding or editing a glyph means editing its own file under `glyphs/letters`, `glyphs/digits`, or `glyphs/punctuation` — no other file needs to change except `glyphs.ts`'s import/lookup if you're adding a brand-new character.
+
+## Demo
+
+`demo/index.html` is a static page (loads `../dist/index.js`, so run `npm run build` first) with:
+
+- a live playground — type any text, change stroke color, toggle animate on/off, replay
+- the full glyph gallery — every supported letter, digit, and punctuation mark, animated on scroll
+
+Open it with any static file server, e.g. `npx serve .` then visit `/demo/`.
+
+## License
+
+ISC

package/dist/glyphs/digits/digit-0.d.ts

@@ -0,0 +1,3 @@
+import type { GlyphEntry } from "../types.js";
+/** Real hand-drawn glyph: monoline digit "0", 3 wobble variants. */
+export declare const digit0: GlyphEntry;

package/dist/glyphs/digits/digit-0.js

@@ -0,0 +1,9 @@
+/** Real hand-drawn glyph: monoline digit "0", 3 wobble variants. */
+export const digit0 = {
+    width: 11,
+    variants: [
+        "M9.5 12 C 9.5 6.5 7.3 4 5 4 C 2.5 4 0.5 6.5 0.5 12 C 0.5 17.5 2.5 20.5 5 20.5 C 7.3 20.5 9.5 17.5 9.5 12",
+        "M9.6 11.8 C 9.5 6.6 7.1 3.8 5.0 3.8 C 2.7 3.8 0.6 6.4 0.7 11.8 C 0.5 17.6 2.4 20.3 4.9 20.4 C 7.1 20.3 9.6 17.6 9.5 12.1",
+        "M9.4 11.9 C 9.5 6.4 7.4 4.0 4.9 3.9 C 2.4 4.1 0.5 6.4 0.6 12.1 C 0.5 17.4 2.7 20.4 5.2 20.5 C 7.1 20.3 9.4 17.6 9.5 11.8",
+    ],
+};

package/dist/glyphs/digits/digit-1.d.ts

@@ -0,0 +1,3 @@
+import type { GlyphEntry } from "../types.js";
+/** Real hand-drawn glyph: monoline digit "1", 3 wobble variants. */
+export declare const digit1: GlyphEntry;

package/dist/glyphs/digits/digit-1.js

@@ -0,0 +1,9 @@
+/** Real hand-drawn glyph: monoline digit "1", 3 wobble variants. */
+export const digit1 = {
+    width: 10,
+    variants: [
+        "M2 7 L5.5 4 L5.5 20 M2.5 20 L8.5 20",
+        "M1.8 6.9 L5.3 4.0 L5.5 19.9 M2.5 20.1 L8.6 20.0",
+        "M2.1 6.9 L5.6 4.1 L5.3 20.0 M2.6 19.9 L8.3 19.9",
+    ],
+};

package/dist/glyphs/digits/digit-2.d.ts

@@ -0,0 +1,3 @@
+import type { GlyphEntry } from "../types.js";
+/** Real hand-drawn glyph: monoline digit "2", 3 wobble variants. */
+export declare const digit2: GlyphEntry;

package/dist/glyphs/digits/digit-2.js

@@ -0,0 +1,9 @@
+/** Real hand-drawn glyph: monoline digit "2", 3 wobble variants. */
+export const digit2 = {
+    width: 11,
+    variants: [
+        "M1.5 8 C 1.5 5 4 4 6 4 C 8.5 4 10 6 10 8.5 C 10 12.5 5.5 15 1.5 19.5 L10 19.5",
+        "M1.7 7.9 C 1.6 5.1 3.8 3.9 5.9 4.2 C 8.6 4.1 10.1 6.1 9.9 8.6 C 10.1 12.6 5.4 15.0 1.6 19.5 L10.1 19.4",
+        "M1.3 7.9 C 1.7 4.9 3.9 3.9 6.2 3.9 C 8.5 4.1 9.9 6.0 9.9 8.6 C 9.8 12.5 5.6 14.9 1.3 19.4 L10.0 19.7",
+    ],
+};

package/dist/glyphs/digits/digit-3.d.ts

@@ -0,0 +1,3 @@
+import type { GlyphEntry } from "../types.js";
+/** Real hand-drawn glyph: monoline digit "3", 3 wobble variants. */
+export declare const digit3: GlyphEntry;

package/dist/glyphs/digits/digit-3.js

@@ -0,0 +1,9 @@
+/** Real hand-drawn glyph: monoline digit "3", 3 wobble variants. */
+export const digit3 = {
+    width: 11,
+    variants: [
+        "M1.5 6 C 3 4.3 8.5 3.8 9 7.5 C 9.3 10 7 11.5 5 12 C 7.5 12.3 9.8 13.8 9.5 16.5 C 9.2 19.5 4 20.8 1.3 18.3",
+        "M1.3 5.9 C 2.8 4.3 8.4 4.0 8.8 7.7 C 9.3 9.9 6.9 11.6 4.9 12.2 C 7.3 12.2 10.0 13.8 9.4 16.7 C 9.4 19.5 3.9 21.0 1.4 18.2",
+        "M1.7 6.0 C 3.0 4.5 8.3 3.7 9.2 7.4 C 9.1 9.9 7.2 11.3 5.1 12.2 C 7.4 12.2 9.6 13.9 9.6 16.3 C 9.3 19.5 3.8 20.8 1.1 18.4",
+    ],
+};

package/dist/glyphs/digits/digit-4.d.ts

@@ -0,0 +1,3 @@
+import type { GlyphEntry } from "../types.js";
+/** Real hand-drawn glyph: monoline digit "4", 3 wobble variants. */
+export declare const digit4: GlyphEntry;

package/dist/glyphs/digits/digit-4.js

@@ -0,0 +1,9 @@
+/** Real hand-drawn glyph: monoline digit "4", 3 wobble variants. */
+export const digit4 = {
+    width: 11,
+    variants: [
+        "M8 4 L1 15 L10.5 15 M8 4 L8 20",
+        "M7.9 4.1 L0.8 15.0 L10.6 14.9 M8.0 3.9 L7.9 20.1",
+        "M8.2 3.9 L0.9 14.8 L10.4 14.9 M8.0 3.9 L7.9 20.1",
+    ],
+};

package/dist/glyphs/digits/digit-5.d.ts

@@ -0,0 +1,3 @@
+import type { GlyphEntry } from "../types.js";
+/** Real hand-drawn glyph: monoline digit "5", 3 wobble variants. */
+export declare const digit5: GlyphEntry;

package/dist/glyphs/digits/digit-5.js

@@ -0,0 +1,9 @@
+/** Real hand-drawn glyph: monoline digit "5", 3 wobble variants. */
+export const digit5 = {
+    width: 11,
+    variants: [
+        "M9 4 L2 4 L1.5 10.5 C 3 9 8.5 9.3 9.3 13.3 C 10 17 6.5 20.5 2 18.5",
+        "M9.1 3.9 L1.9 4.0 L1.5 10.5 C 3.0 8.8 8.5 9.2 9.3 13.2 C 9.8 16.9 6.3 20.5 1.8 18.5",
+        "M9.0 4.2 L2.2 4.0 L1.3 10.3 C 3.0 9.0 8.6 9.2 9.5 13.3 C 10.0 17.0 6.4 20.7 1.9 18.4",
+    ],
+};

package/dist/glyphs/digits/digit-6.d.ts

@@ -0,0 +1,3 @@
+import type { GlyphEntry } from "../types.js";
+/** Real hand-drawn glyph: monoline digit "6", 3 wobble variants. */
+export declare const digit6: GlyphEntry;

package/dist/glyphs/digits/digit-6.js

@@ -0,0 +1,9 @@
+/** Real hand-drawn glyph: monoline digit "6", 3 wobble variants. */
+export const digit6 = {
+    width: 11,
+    variants: [
+        "M9 5 C 5.5 4 1.5 7 1.5 13 C 1.5 18 4 20.7 6.3 20.5 C 9 20.3 10 17.5 9.8 15 C 9.5 12 6.5 11 4 12 C 2 12.8 1.5 15 1.5 15",
+        "M9.1 4.9 C 5.6 3.9 1.4 7.1 1.3 13.1 C 1.7 18.2 4.0 20.7 6.4 20.7 C 8.8 20.1 9.9 17.3 9.8 15.1 C 9.6 12.1 6.3 11.1 3.9 12.1 C 2.1 12.9 1.3 15.0 1.6 14.9",
+        "M8.8 4.9 C 5.3 4.1 1.3 7.0 1.7 12.8 C 1.3 18.2 3.9 20.6 6.3 20.6 C 9.2 20.5 10.2 17.4 10.0 15.2 C 9.5 12.0 6.5 11.0 4.0 12.1 C 1.9 12.9 1.6 15.1 1.6 15.0",
+    ],
+};

package/dist/glyphs/digits/digit-7.d.ts

@@ -0,0 +1,3 @@
+import type { GlyphEntry } from "../types.js";
+/** Real hand-drawn glyph: monoline digit "7", 3 wobble variants. */
+export declare const digit7: GlyphEntry;

package/dist/glyphs/digits/digit-7.js

@@ -0,0 +1,9 @@
+/** Real hand-drawn glyph: monoline digit "7", 3 wobble variants. */
+export const digit7 = {
+    width: 11,
+    variants: [
+        "M1.5 4 L10 4 L4 20",
+        "M1.6 3.8 L10.0 4.1 L4.2 20.1",
+        "M1.6 4.0 L10.0 3.8 L3.8 19.8",
+    ],
+};

package/dist/glyphs/digits/digit-8.d.ts

@@ -0,0 +1,3 @@
+import type { GlyphEntry } from "../types.js";
+/** Real hand-drawn glyph: monoline digit "8", 3 wobble variants. */
+export declare const digit8: GlyphEntry;

package/dist/glyphs/digits/digit-8.js

@@ -0,0 +1,9 @@
+/** Real hand-drawn glyph: monoline digit "8", 3 wobble variants. */
+export const digit8 = {
+    width: 12,
+    variants: [
+        "M5.5 4 C 8 4 9 5.8 9 7.3 C 9 9.5 6.5 11 5.5 11.5 C 4.5 11 2 9.5 2 7.3 C 2 5.8 3 4 5.5 4 M5.5 11.5 C 3.5 12 1 13.8 1 16.5 C 1 19 3 20.7 5.5 20.7 C 8 20.7 10 19 10 16.5 C 10 13.8 7.5 12 5.5 11.5",
+        "M5.3 4.0 C 7.9 4.2 8.9 5.8 8.9 7.2 C 9.1 9.7 6.4 10.8 5.3 11.7 C 4.6 10.8 1.9 9.7 1.9 7.5 C 1.9 5.8 3.0 3.8 5.4 4.0 M5.5 11.7 C 3.4 12.1 0.8 13.7 1.2 16.3 C 0.8 19.2 2.8 20.8 5.4 20.7 C 7.8 20.9 9.8 19.0 9.8 16.4 C 10.2 13.8 7.5 12.0 5.3 11.7",
+        "M5.3 3.9 C 7.8 3.8 9.0 5.8 9.0 7.1 C 8.9 9.7 6.6 11.1 5.4 11.6 C 4.5 11.1 2.1 9.4 1.9 7.3 C 2.0 5.7 3.1 4.0 5.6 3.9 M5.5 11.7 C 3.5 12.0 1.2 13.9 1.2 16.5 C 1.1 19.1 3.1 20.6 5.3 20.6 C 8.1 20.8 9.9 18.8 9.8 16.7 C 10.1 13.6 7.5 11.9 5.5 11.5",
+    ],
+};

package/dist/glyphs/digits/digit-9.d.ts

@@ -0,0 +1,3 @@
+import type { GlyphEntry } from "../types.js";
+/** Real hand-drawn glyph: monoline digit "9", 3 wobble variants. */
+export declare const digit9: GlyphEntry;

package/dist/glyphs/digits/digit-9.js

@@ -0,0 +1,9 @@
+/** Real hand-drawn glyph: monoline digit "9", 3 wobble variants. */
+export const digit9 = {
+    width: 11,
+    variants: [
+        "M9.5 13 C 9.5 8 7 5.3 4.7 5.5 C 2 5.7 1 8.5 1.2 11 C 1.5 14 4.5 15 7 14 C 9 13.2 9.5 11 9.5 11 C 9.5 11 9.7 16 8 18.5 C 6.7 20.3 3.5 20.5 1.5 19",
+        "M9.5 12.9 C 9.7 8.0 7.1 5.1 4.9 5.6 C 2.0 5.6 1.0 8.3 1.2 11.2 C 1.5 14.0 4.6 14.9 7.2 14.1 C 8.9 13.1 9.6 11.0 9.6 11.0 C 9.3 11.2 9.5 16.2 8.1 18.5 C 6.9 20.3 3.7 20.5 1.4 19.0",
+        "M9.3 13.2 C 9.6 7.8 7.2 5.1 4.8 5.3 C 2.0 5.8 1.1 8.6 1.0 11.2 C 1.4 13.8 4.5 15.1 7.0 14.0 C 8.9 13.1 9.6 11.1 9.6 10.8 C 9.3 10.8 9.8 16.2 7.9 18.4 C 6.6 20.3 3.6 20.4 1.5 19.1",
+    ],
+};

package/dist/glyphs/glyphs.d.ts

@@ -0,0 +1,3 @@
+import type { GlyphDatabase } from "./types.js";
+export type { GlyphEntry, GlyphDatabase } from "./types.js";
+export declare const glyphs: GlyphDatabase;

package/dist/glyphs/glyphs.js

@@ -0,0 +1,138 @@
+import { letterA } from "./letters/letter-a.js";
+import { letterAUpper } from "./letters/letter-a-upper.js";
+import { letterB } from "./letters/letter-b.js";
+import { letterBUpper } from "./letters/letter-b-upper.js";
+import { letterC } from "./letters/letter-c.js";
+import { letterCUpper } from "./letters/letter-c-upper.js";
+import { letterD } from "./letters/letter-d.js";
+import { letterDUpper } from "./letters/letter-d-upper.js";
+import { letterE } from "./letters/letter-e.js";
+import { letterEUpper } from "./letters/letter-e-upper.js";
+import { letterF } from "./letters/letter-f.js";
+import { letterFUpper } from "./letters/letter-f-upper.js";
+import { letterG } from "./letters/letter-g.js";
+import { letterGUpper } from "./letters/letter-g-upper.js";
+import { letterH } from "./letters/letter-h.js";
+import { letterHUpper } from "./letters/letter-h-upper.js";
+import { letterI } from "./letters/letter-i.js";
+import { letterIUpper } from "./letters/letter-i-upper.js";
+import { letterJ } from "./letters/letter-j.js";
+import { letterJUpper } from "./letters/letter-j-upper.js";
+import { letterK } from "./letters/letter-k.js";
+import { letterKUpper } from "./letters/letter-k-upper.js";
+import { letterL } from "./letters/letter-l.js";
+import { letterLUpper } from "./letters/letter-l-upper.js";
+import { letterM } from "./letters/letter-m.js";
+import { letterMUpper } from "./letters/letter-m-upper.js";
+import { letterN } from "./letters/letter-n.js";
+import { letterNUpper } from "./letters/letter-n-upper.js";
+import { letterO } from "./letters/letter-o.js";
+import { letterOUpper } from "./letters/letter-o-upper.js";
+import { letterP } from "./letters/letter-p.js";
+import { letterPUpper } from "./letters/letter-p-upper.js";
+import { letterQ } from "./letters/letter-q.js";
+import { letterQUpper } from "./letters/letter-q-upper.js";
+import { letterR } from "./letters/letter-r.js";
+import { letterRUpper } from "./letters/letter-r-upper.js";
+import { letterS } from "./letters/letter-s.js";
+import { letterSUpper } from "./letters/letter-s-upper.js";
+import { letterT } from "./letters/letter-t.js";
+import { letterTUpper } from "./letters/letter-t-upper.js";
+import { letterU } from "./letters/letter-u.js";
+import { letterUUpper } from "./letters/letter-u-upper.js";
+import { letterV } from "./letters/letter-v.js";
+import { letterVUpper } from "./letters/letter-v-upper.js";
+import { letterW } from "./letters/letter-w.js";
+import { letterWUpper } from "./letters/letter-w-upper.js";
+import { letterX } from "./letters/letter-x.js";
+import { letterXUpper } from "./letters/letter-x-upper.js";
+import { letterY } from "./letters/letter-y.js";
+import { letterYUpper } from "./letters/letter-y-upper.js";
+import { letterZ } from "./letters/letter-z.js";
+import { letterZUpper } from "./letters/letter-z-upper.js";
+import { digit0 } from "./digits/digit-0.js";
+import { digit1 } from "./digits/digit-1.js";
+import { digit2 } from "./digits/digit-2.js";
+import { digit3 } from "./digits/digit-3.js";
+import { digit4 } from "./digits/digit-4.js";
+import { digit5 } from "./digits/digit-5.js";
+import { digit6 } from "./digits/digit-6.js";
+import { digit7 } from "./digits/digit-7.js";
+import { digit8 } from "./digits/digit-8.js";
+import { digit9 } from "./digits/digit-9.js";
+import { punctPeriod } from "./punctuation/punct-period.js";
+import { punctComma } from "./punctuation/punct-comma.js";
+import { punctExclamation } from "./punctuation/punct-exclamation.js";
+import { punctQuestion } from "./punctuation/punct-question.js";
+import { punctApostrophe } from "./punctuation/punct-apostrophe.js";
+import { punctHyphen } from "./punctuation/punct-hyphen.js";
+export const glyphs = {
+    "A": letterAUpper,
+    "a": letterA,
+    "B": letterBUpper,
+    "b": letterB,
+    "C": letterCUpper,
+    "c": letterC,
+    "D": letterDUpper,
+    "d": letterD,
+    "E": letterEUpper,
+    "e": letterE,
+    "F": letterFUpper,
+    "f": letterF,
+    "G": letterGUpper,
+    "g": letterG,
+    "H": letterHUpper,
+    "h": letterH,
+    "I": letterIUpper,
+    "i": letterI,
+    "J": letterJUpper,
+    "j": letterJ,
+    "K": letterKUpper,
+    "k": letterK,
+    "L": letterLUpper,
+    "l": letterL,
+    "M": letterMUpper,
+    "m": letterM,
+    "N": letterNUpper,
+    "n": letterN,
+    "O": letterOUpper,
+    "o": letterO,
+    "P": letterPUpper,
+    "p": letterP,
+    "Q": letterQUpper,
+    "q": letterQ,
+    "R": letterRUpper,
+    "r": letterR,
+    "S": letterSUpper,
+    "s": letterS,
+    "T": letterTUpper,
+    "t": letterT,
+    "U": letterUUpper,
+    "u": letterU,
+    "V": letterVUpper,
+    "v": letterV,
+    "W": letterWUpper,
+    "w": letterW,
+    "X": letterXUpper,
+    "x": letterX,
+    "Y": letterYUpper,
+    "y": letterY,
+    "Z": letterZUpper,
+    "z": letterZ,
+    "0": digit0,
+    "1": digit1,
+    "2": digit2,
+    "3": digit3,
+    "4": digit4,
+    "5": digit5,
+    "6": digit6,
+    "7": digit7,
+    "8": digit8,
+    "9": digit9,
+    ".": punctPeriod,
+    ",": punctComma,
+    "!": punctExclamation,
+    "?": punctQuestion,
+    "'": punctApostrophe,
+    "-": punctHyphen,
+};

package/dist/glyphs/letters/letter-a-upper.d.ts

@@ -0,0 +1,3 @@
+import type { GlyphEntry } from "../types.js";
+/** Real hand-drawn glyph: two legs meeting at an apex, plus a crossbar. */
+export declare const letterAUpper: GlyphEntry;

package/dist/glyphs/letters/letter-a-upper.js

@@ -0,0 +1,9 @@
+/** Real hand-drawn glyph: two legs meeting at an apex, plus a crossbar. */
+export const letterAUpper = {
+    width: 16,
+    variants: [
+        "M1 20 L8 5 L15 20 M3.8 14 L12.2 14",
+        "M0.8 19.8 L8.2 4.8 L15.2 19.9 M3.9 14.2 L12.4 13.9",
+        "M1.2 20.1 L7.8 5.2 L14.8 20.2 M3.6 13.8 L12.0 14.1",
+    ],
+};

package/dist/glyphs/letters/letter-a.d.ts

@@ -0,0 +1,3 @@
+import type { GlyphEntry } from "../types.js";
+/** Real hand-drawn glyph: bowl + stem sharing one connecting point (single-story "a"). */
+export declare const letterA: GlyphEntry;

package/dist/glyphs/letters/letter-a.js

@@ -0,0 +1,9 @@
+/** Real hand-drawn glyph: bowl + stem sharing one connecting point (single-story "a"). */
+export const letterA = {
+    width: 13,
+    variants: [
+        "M11 9 C 9 6.5 5 6.5 3 9.5 C 1.5 12 1.5 16 4 18.5 C 6 20.5 9.5 20 11 17.5 L 11 9 L 11 20",
+        "M10.8 8.8 C 8.6 6.3 4.9 6.7 3.1 9.7 C 1.6 12.2 1.7 16.1 4.2 18.6 C 6.1 20.4 9.4 19.9 10.9 17.4 L 10.8 8.8 L 11.1 20.1",
+        "M11.2 9.3 C 9.4 6.7 5.1 6.4 3.0 9.4 C 1.4 11.9 1.9 15.9 4.3 18.4 C 6.0 20.3 9.6 20.2 11.1 17.7 L 11.2 9.3 L 10.9 19.8",
+    ],
+};

package/dist/glyphs/letters/letter-b-upper.d.ts

@@ -0,0 +1,3 @@
+import type { GlyphEntry } from "../types.js";
+/** Real hand-drawn glyph: monoline "B" (uppercase), 3 wobble variants. */
+export declare const letterBUpper: GlyphEntry;

package/dist/glyphs/letters/letter-b-upper.js

@@ -0,0 +1,9 @@
+/** Real hand-drawn glyph: monoline "B" (uppercase), 3 wobble variants. */
+export const letterBUpper = {
+    width: 12,
+    variants: [
+        "M2 4 L2 20 M2 4 C 7 4 8.5 6.3 8.5 8.3 C 8.5 10.3 7 12 2 12 M2 12 C 8.3 12 10 14.8 10 16.8 C 10 18.8 8.3 20 2 20",
+        "M2.1 3.9 L1.9 19.9 M1.8 3.9 C 7.1 4.1 8.3 6.1 8.5 8.4 C 8.3 10.1 7.0 12.0 2.0 12.1 M2.0 12.1 C 8.1 12.2 10.0 14.8 10.1 16.6 C 10.0 18.7 8.1 19.9 2.0 20.1",
+        "M1.9 4.2 L1.8 20.0 M2.1 4.1 C 7.2 4.0 8.6 6.3 8.6 8.4 C 8.5 10.3 7.2 12.0 2.1 12.0 M1.8 12.2 C 8.1 12.0 10.2 15.0 10.2 16.9 C 10.2 18.8 8.5 20.0 2.1 19.8",
+    ],
+};

package/dist/glyphs/letters/letter-b.d.ts

@@ -0,0 +1,3 @@
+import type { GlyphEntry } from "../types.js";
+/** Real hand-drawn glyph: monoline "b", 3 wobble variants. */
+export declare const letterB: GlyphEntry;

package/dist/glyphs/letters/letter-b.js

@@ -0,0 +1,9 @@
+/** Real hand-drawn glyph: monoline "b", 3 wobble variants. */
+export const letterB = {
+    width: 12,
+    variants: [
+        "M2 3 L2 20 M2 12 C 6 10 10.5 12.5 10.5 16 C 10.5 19.5 6 21 2 19",
+        "M1.8 2.8 L2.2 19.9 M1.9 11.8 C 6.1 10.2 10.7 12.3 10.4 15.8 C 10.6 19.5 5.8 21.2 2.1 19.2",
+        "M2.0 3.2 L2.2 20.0 M1.9 11.8 C 6.2 10.0 10.6 12.6 10.3 15.9 C 10.7 19.3 5.9 20.9 1.9 19.1",
+    ],
+};

package/dist/glyphs/letters/letter-c-upper.d.ts

@@ -0,0 +1,3 @@
+import type { GlyphEntry } from "../types.js";
+/** Real hand-drawn glyph: monoline "C" (uppercase), 3 wobble variants. */
+export declare const letterCUpper: GlyphEntry;

package/dist/glyphs/letters/letter-c-upper.js

@@ -0,0 +1,9 @@
+/** Real hand-drawn glyph: monoline "C" (uppercase), 3 wobble variants. */
+export const letterCUpper = {
+    width: 12,
+    variants: [
+        "M10.5 8 C 8.5 5 3.5 5 1.5 8.5 C 0 11.5 0 15.5 1.5 18.5 C 3.5 21.2 8.5 21 10.5 18",
+        "M10.3 8.1 C 8.3 4.8 3.7 4.9 1.4 8.6 C -0.1 11.7 0.0 15.4 1.6 18.4 C 3.3 21.1 8.5 21.2 10.4 18.0",
+        "M10.5 8.0 C 8.7 4.9 3.4 4.9 1.7 8.3 C 0.1 11.4 -0.2 15.7 1.5 18.5 C 3.4 21.2 8.6 21.2 10.7 18.0",
+    ],
+};

package/dist/glyphs/letters/letter-c.d.ts

@@ -0,0 +1,3 @@
+import type { GlyphEntry } from "../types.js";
+/** Real hand-drawn glyph: monoline "c", 3 wobble variants. */
+export declare const letterC: GlyphEntry;

package/dist/glyphs/letters/letter-c.js

@@ -0,0 +1,9 @@
+/** Real hand-drawn glyph: monoline "c", 3 wobble variants. */
+export const letterC = {
+    width: 11,
+    variants: [
+        "M9 9 C 6.5 6.5 2.5 7 1 10.5 C -0.2 13.5 0.3 17 3 19 C 5.5 20.7 8.5 20 9.5 17.5",
+        "M9.2 8.9 C 6.7 6.5 2.3 7.1 0.8 10.7 C 0.0 13.3 0.4 17.1 3.1 19.0 C 5.5 20.6 8.4 20.0 9.7 17.3",
+        "M9.1 9.0 C 6.4 6.7 2.3 7.2 1.2 10.4 C -0.0 13.3 0.2 17.2 3.1 18.8 C 5.4 20.9 8.7 19.9 9.6 17.6",
+    ],
+};

package/dist/glyphs/letters/letter-d-upper.d.ts

@@ -0,0 +1,3 @@
+import type { GlyphEntry } from "../types.js";
+/** Real hand-drawn glyph: monoline "D" (uppercase), 3 wobble variants. */
+export declare const letterDUpper: GlyphEntry;

package/dist/glyphs/letters/letter-d-upper.js

@@ -0,0 +1,9 @@
+/** Real hand-drawn glyph: monoline "D" (uppercase), 3 wobble variants. */
+export const letterDUpper = {
+    width: 13,
+    variants: [
+        "M2 4 L2 20 M2 4 C 8 4 11 8 11 12 C 11 16 8 20 2 20",
+        "M2.1 3.9 L2.0 19.9 M2.1 4.1 C 7.9 4.2 11.0 8.0 11.0 12.2 C 10.9 15.9 8.1 20.2 2.0 19.9",
+        "M1.9 4.1 L1.9 19.9 M1.9 4.1 C 7.9 4.1 11.0 8.1 11.2 11.8 C 10.9 16.0 8.2 19.9 2.0 20.1",
+    ],
+};

package/dist/glyphs/letters/letter-d.d.ts

@@ -0,0 +1,3 @@
+import type { GlyphEntry } from "../types.js";
+/** Real hand-drawn glyph: monoline "d", 3 wobble variants. */
+export declare const letterD: GlyphEntry;