tegaki 0.0.1 → 0.2.3

package/CHANGELOG.md

@@ -0,0 +1,25 @@
+# tegaki
+
+## 0.2.3
+
+### Patch Changes
+
+- [`d171776`](https://github.com/KurtGokhan/tegaki/commit/d171776e48eae2063246209e8b56bf9e9185f4c7) Thanks [@KurtGokhan](https://github.com/KurtGokhan)! - Fix layout issues when font is being loaded. Fix layout being calculated with ligatures.
+
+## 0.2.2
+
+### Patch Changes
+
+- [`4f5c639`](https://github.com/KurtGokhan/tegaki/commit/4f5c639799056093a8797dbb6a84cd6989500811) Thanks [@KurtGokhan](https://github.com/KurtGokhan)! - changeset fix
+
+## 0.2.1
+
+### Patch Changes
+
+- [`1b079f5`](https://github.com/KurtGokhan/tegaki/commit/1b079f5dd6cb174b9b272c5e217dd1df1e5c0b12) Thanks [@KurtGokhan](https://github.com/KurtGokhan)! - initial release
+
+## 0.2.0
+
+### Minor Changes
+
+- [`273bd36`](https://github.com/KurtGokhan/tegaki/commit/273bd36ece40ad3629aad2f62d3bcf3849a59cf0) Thanks [@KurtGokhan](https://github.com/KurtGokhan)! - Beta release of Tegaki, a handwriting animation library for JavaScript and React. This release includes basic support for rendering handwriting animations, as well as a browser based animation generator. Future updates will focus on improving stroke orders for better natural handwriting estimation. We welcome feedback and contributions from the community to help make Tegaki even better!

package/FONTS-LICENSE.md

@@ -0,0 +1,67 @@
+# Bundled Font Licenses
+
+The `tegaki` package includes pre-generated bundles for the following fonts.
+All fonts are licensed under the [SIL Open Font License, Version 1.1](https://openfontlicense.org/).
+
+## Caveat
+
+- **Designer**: Impallari Type
+- **Copyright**: Copyright 2014 The Caveat Project Authors (https://github.com/googlefonts/caveat)
+- **License**: SIL Open Font License, Version 1.1
+
+## Italianno
+
+- **Designer**: Robert Leuschke
+- **Copyright**: Copyright 2009 The Italianno Project Authors (https://github.com/googlefonts/italianno)
+- **License**: SIL Open Font License, Version 1.1
+
+## Tangerine
+
+- **Designer**: Toshi Omagari
+- **Copyright**: Copyright (c) 2010 by Toshi Omagari
+- **License**: SIL Open Font License, Version 1.1
+
+## Parisienne
+
+- **Designer**: Brian J. Bonislawsky (Astigmatic)
+- **Copyright**: Copyright (c) 2012 by Brian J. Bonislawsky DBA Astigmatic (AOETI)
+- **License**: SIL Open Font License, Version 1.1
+
+---
+
+## SIL Open Font License, Version 1.1
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+the Font Software, to use, study, copy, merge, embed, modify, redistribute, and
+sell modified and unmodified copies of the Font Software, subject to the
+following conditions:
+
+1. Neither the Font Software nor any of its individual components, in Original
+   or Modified Versions, may be sold by itself.
+
+2. Original or Modified Versions of the Font Software may be bundled,
+   redistributed and/or sold with any software, provided that each copy contains
+   the above copyright notice and this license. These can be included either as
+   stand-alone text files, human-readable headers or in the appropriate
+   machine-readable metadata fields within text or binary files as long as those
+   fields can be easily viewed by the user.
+
+3. No Modified Version of the Font Software may use the Reserved Font Name(s)
+   unless explicit written permission is granted by the corresponding Copyright
+   Holder.
+
+4. The Font Software, modified or unmodified, in part or in whole, must be
+   distributed entirely under this license, and must not be distributed under
+   any other license.
+
+5. The Font Software may not be used in products or activities that are illegal
+   or harmful, or promote illegal or harmful actions.
+
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF COPYRIGHT, PATENT, TRADEMARK, OR
+OTHER RIGHT. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL,
+OR CONSEQUENTIAL DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER
+DEALINGS IN THE FONT SOFTWARE.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Gokhan Kurt
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,261 @@
+<p align="center">
+  <img src="media/tegaki-card.png" alt="Tegaki" width="640" />
+</p>
+
+<h3 align="center">Handwriting animation for any font</h3>
+
+<p align="center">
+  Tegaki (手書き) generates stroke data from fonts and renders animated handwriting in React.<br />
+  No manual path authoring. No native dependencies. Just pick a font.
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/tegaki"><img src="https://img.shields.io/npm/v/tegaki" alt="npm" /></a>
+  <a href="https://github.com/KurtGokhan/tegaki/blob/main/LICENSE"><img src="https://img.shields.io/npm/l/tegaki" alt="license" /></a>
+</p>
+
+---
+
+## How it works
+
+**1. Generate** a font bundle from any Google Font (or a local `.ttf`):
+
+```bash
+npx tegaki-generator generate "Caveat"
+```
+
+Each glyph is run through a processing pipeline — flatten bezier curves, rasterize, skeletonize via Zhang-Suen thinning, trace polylines, compute stroke widths via distance transform, determine stroke order — and the result is a set of animated SVGs with timing data.
+
+**2. Render** the animated text in React:
+
+```tsx
+import { TegakiRenderer } from 'tegaki';
+import font from './output/caveat/bundle.ts';
+
+await font.registerFontFace();
+
+function App() {
+  return (
+    <TegakiRenderer font={font} style={{ fontSize: '48px' }}>
+      Hello World
+    </TegakiRenderer>
+  );
+}
+```
+
+The text draws itself stroke by stroke, with accurate widths and natural timing.
+
+## Install
+
+```bash
+npm install tegaki
+```
+
+The generator is a separate package, only needed at build time:
+
+```bash
+npm install -D tegaki-generator
+```
+
+## Built-in fonts
+
+Tegaki ships with pre-generated bundles for four Google Fonts, ready to use without running the generator:
+
+- **Caveat** — `tegaki/fonts/caveat`
+- **Italianno** — `tegaki/fonts/italianno`
+- **Tangerine** — `tegaki/fonts/tangerine`
+- **Parisienne** — `tegaki/fonts/parisienne`
+
+```tsx
+import { TegakiRenderer } from 'tegaki';
+import caveat from 'tegaki/fonts/caveat';
+
+await caveat.registerFontFace();
+
+function App() {
+  return (
+    <TegakiRenderer font={caveat} style={{ fontSize: '48px' }}>
+      Hello World
+    </TegakiRenderer>
+  );
+}
+```
+
+These bundles include all printable ASCII characters (letters, digits, punctuation). For other fonts, use the generator.
+
+All bundled fonts are licensed under the [SIL Open Font License](https://openfontlicense.org/). See [FONTS-LICENSE.md](packages/renderer/FONTS-LICENSE.md) for full attribution.
+
+## `<TegakiRenderer>` props
+
+| Prop | Type | Default | Description |
+|------|------|---------|-------------|
+| `font` | `TegakiBundle` | — | Font bundle with animated glyph SVGs |
+| `text` | `string` | — | Text to animate (or pass as `children`) |
+| `children` | `string \| number` | — | Text content, coerced to string |
+| `time` | `TimeControlProp` | — | Time control mode (see below) |
+| `onComplete` | `() => void` | — | Called when animation reaches the end |
+| `mode` | `'svg' \| 'canvas'` | `'svg'` | Rendering mode |
+| `showOverlay` | `boolean` | `false` | Show debug text overlay |
+
+Plus all standard `<div>` props (`className`, `style`, etc.).
+
+### Time control modes
+
+The `time` prop accepts three modes via a discriminated union:
+
+| Value | Mode | Description |
+|-------|------|-------------|
+| *omitted* | Uncontrolled | Auto-plays with default settings |
+| `number` | Controlled | Shorthand for `{ mode: 'controlled', value: n }` |
+| `'css'` | CSS | Shorthand for `{ mode: 'css' }` |
+| `{ mode: 'controlled', value }` | Controlled | You drive the time directly |
+| `{ mode: 'uncontrolled', ... }` | Uncontrolled | Component manages playback |
+| `{ mode: 'css' }` | CSS | Driven by `--tegaki-progress` CSS property |
+
+#### Uncontrolled
+
+The component manages its own playback — auto-plays on mount, responds to `speed`, `playing`, and `loop`.
+
+```tsx
+// Default: auto-play at 1x
+<TegakiRenderer font={font}>Hello</TegakiRenderer>
+
+// With options
+<TegakiRenderer font={font} time={{ mode: 'uncontrolled', speed: 2, loop: true }}>
+  Hello
+</TegakiRenderer>
+```
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `initialTime` | `number` | `0` | Starting time in seconds |
+| `speed` | `number` | `1` | Playback speed multiplier |
+| `playing` | `boolean` | `true` | Whether animation is playing |
+| `loop` | `boolean` | `false` | Restart when animation ends |
+| `onTimeChange` | `(time: number) => void` | — | Called each frame with current time |
+
+#### Controlled
+
+You provide the exact time. Useful for syncing with a slider, streaming text, or external state.
+
+```tsx
+<TegakiRenderer font={font} time={currentTime}>Hello</TegakiRenderer>
+```
+
+#### CSS
+
+Animation progress is driven by the `--tegaki-progress` CSS custom property (0–1). This enables pure-CSS control via animations, transitions, or scroll-timeline — no JS bridge needed.
+
+```tsx
+<TegakiRenderer font={font} time="css" style={...}>Hello</TegakiRenderer>
+```
+
+```css
+/* Example: scroll-driven animation */
+.scroll-container {
+  overflow-x: scroll;
+  scroll-timeline: --tegaki inline;
+}
+
+.tegaki-wrapper {
+  animation: tegaki-reveal linear both;
+  animation-timeline: --tegaki;
+}
+
+@keyframes tegaki-reveal {
+  from { --tegaki-progress: 0; }
+  to   { --tegaki-progress: 1; }
+}
+```
+
+### CSS custom properties
+
+The component exposes these CSS custom properties on its root element in all modes:
+
+| Property | Direction | Description |
+|----------|-----------|-------------|
+| `--tegaki-duration` | Output | Total animation length in seconds |
+| `--tegaki-time` | Output | Current time in seconds |
+| `--tegaki-progress` | Input (CSS mode) / Output | Current progress (0–1) |
+
+All three are registered via `CSS.registerProperty` as `<number>` with `inherits: true`, making them animatable and transitionable.
+
+### `computeTimeline(text, font)`
+
+Returns timing info for a string without rendering anything:
+
+```ts
+import { computeTimeline } from 'tegaki';
+
+const { entries, totalDuration } = computeTimeline('Hello', font);
+// totalDuration: 2.45 (seconds)
+// entries: [{ char: 'H', offset: 0, duration: 0.52, hasSvg: true }, ...]
+```
+
+## Generating font bundles
+
+```bash
+npx tegaki-generator generate [family] [options]
+```
+
+| Option | Description | Default |
+|--------|-------------|---------|
+| `family` | Google Fonts family name | `Caveat` |
+| `-o, --output` | Output directory | `output/<family>` |
+| `-r, --resolution` | Bitmap resolution for skeletonization | `400` |
+| `-c, --chars` | Characters to process | printable ASCII |
+| `-f, --force` | Re-download cached font | `false` |
+| `-d, --debug` | Write intermediate visualizations | `false` |
+| `-l, --lineCap` | Stroke cap style (`auto`/`round`/`butt`/`square`) | `auto` |
+| `--skeletonMethod` | Algorithm (`zhang-suen` / `guo-hall` / `lee` / `medial-axis` / `thin` / `voronoi`) | `zhang-suen` |
+
+Output structure:
+
+```
+output/caveat/
+  font.json        # Full glyph data (coordinates, strokes, timing)
+  caveat.ttf       # Original font file
+  bundle.ts        # Import this in your app
+  svg/
+    A.svg          # Animated SVG per glyph
+    A.tsx          # React component per glyph
+    ...
+```
+
+Import `bundle.ts` — it bundles all glyph components and font metadata into a `TegakiBundle`.
+
+## Pipeline
+
+The entire processing pipeline is pure TypeScript — no canvas, no native image libraries, no Python. It runs identically in Node/Bun and in the browser.
+
+```
+Font file
+  → Flatten bezier curves to polylines
+  → Rasterize to binary bitmap (scanline fill, nonzero winding)
+  → Skeletonize to 1px-wide skeleton (Zhang-Suen thinning)
+  → Trace skeleton into polylines (spur pruning + RDP simplification)
+  → Compute stroke width at each point (distance transform)
+  → Order strokes top-to-bottom, left-to-right
+  → Generate animated SVG with per-stroke timing
+```
+
+## Packages
+
+| Package | npm | Description |
+|---------|-----|-------------|
+| [`tegaki`](packages/renderer) | [![npm](https://img.shields.io/npm/v/tegaki)](https://www.npmjs.com/package/tegaki) | React component for animated handwriting |
+| [`tegaki-generator`](packages/generator) | [![npm](https://img.shields.io/npm/v/tegaki-generator)](https://www.npmjs.com/package/tegaki-generator) | CLI that generates font bundles |
+| [`@tegaki/website`](packages/website) | — | Interactive preview app |
+
+## Contributing
+
+```bash
+bun install          # Install dependencies
+bun dev              # Start dev server (website)
+bun start            # Run the CLI (generator)
+bun checks           # Lint + typecheck + tests
+```
+
+## License
+
+[MIT](LICENSE)

package/dist/index.d.mts

@@ -0,0 +1,257 @@
+import * as _$react from "react";
+import { ComponentProps } from "react";
+import * as _$react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region src/types.d.ts
+type LineCap = 'round' | 'butt' | 'square';
+interface Point {
+  x: number;
+  y: number;
+}
+interface TimedPoint extends Point {
+  t: number;
+  width: number;
+}
+interface BBox {
+  x1: number;
+  y1: number;
+  x2: number;
+  y2: number;
+}
+interface Stroke {
+  points: TimedPoint[];
+  order: number;
+  length: number;
+  animationDuration: number;
+  delay: number;
+}
+interface GlyphData {
+  char: string;
+  unicode: number;
+  advanceWidth: number;
+  boundingBox: BBox;
+  path: string;
+  skeleton: Point[][];
+  strokes: Stroke[];
+  totalLength: number;
+  totalAnimationDuration: number;
+}
+interface FontOutput {
+  font: {
+    family: string;
+    style: string;
+    unitsPerEm: number;
+    ascender: number;
+    descender: number;
+    lineCap: LineCap;
+  };
+  glyphs: Record<string, GlyphData>;
+}
+interface PathCommand {
+  type: 'M' | 'L' | 'Q' | 'C' | 'Z';
+  x: number;
+  y: number;
+  x1?: number;
+  y1?: number;
+  x2?: number;
+  y2?: number;
+}
+interface TegakiGlyphData {
+  advanceWidth: number;
+  strokes: {
+    points: {
+      x: number;
+      y: number;
+      t: number;
+      width: number;
+    }[];
+    delay: number;
+    animationDuration: number;
+  }[];
+}
+type BaseEffectConfig = {
+  enabled?: boolean;
+};
+/** A length value: plain number is pixels, string `"${number}em"` is relative to font size. */
+type CSSLength = number | `${number}em`;
+type TegakiEffectConfigs = {
+  glow: BaseEffectConfig & {
+    radius?: CSSLength;
+    color?: string;
+    offsetX?: number;
+    offsetY?: number;
+  };
+  wobble: BaseEffectConfig & {
+    amplitude?: number;
+    frequency?: number;
+    mode?: 'sine' | 'noise';
+  };
+  pressureWidth: BaseEffectConfig & {
+    strength?: number;
+  };
+  taper: BaseEffectConfig & {
+    startLength?: number;
+    endLength?: number;
+  };
+  gradient: BaseEffectConfig & {
+    colors?: string[] | 'rainbow';
+    saturation?: number;
+    lightness?: number;
+  };
+};
+type TegakiEffectName = keyof TegakiEffectConfigs;
+/** Effects that can only appear once (cannot be used with custom keys). */
+type TegakiSingletonEffectName = 'pressureWidth' | 'wobble' | 'taper' | 'gradient';
+/** Effects that can be duplicated with custom keys. */
+type TegakiMultiEffectName = Exclude<TegakiEffectName, TegakiSingletonEffectName>;
+type TegakiCustomEffect = { [K in TegakiMultiEffectName]: TegakiEffectConfigs[K] & {
+  effect: K;
+  order?: number;
+} }[TegakiMultiEffectName];
+/** Validates an effects object: known keys infer `effect`, unknown keys require it (singleton effects excluded). */
+type TegakiEffects<T> = { [K in keyof T]: K extends TegakiEffectName ? (TegakiEffectConfigs[K] & {
+  effect?: K;
+  order?: number;
+}) | boolean : TegakiCustomEffect | boolean };
+interface TegakiBundle {
+  family: string;
+  lineCap: LineCap;
+  fontUrl: string;
+  unitsPerEm: number;
+  ascender: number;
+  descender: number;
+  glyphs: Record<string, _$react.FC<_$react.SVGProps<SVGSVGElement>>>;
+  glyphData?: Record<string, TegakiGlyphData>;
+  glyphTimings: Record<string, number>;
+  registerFontFace: () => Promise<void>;
+}
+//#endregion
+//#region src/lib/effects.d.ts
+interface ResolvedEffect<K extends TegakiEffectName = TegakiEffectName> {
+  effect: K;
+  order: number;
+  config: TegakiEffectConfigs[K];
+}
+//#endregion
+//#region src/lib/drawGlyph.d.ts
+interface GlyphPosition {
+  /** X offset in CSS pixels */
+  x: number;
+  /** Y offset in CSS pixels (top of em square) */
+  y: number;
+  /** Font size in CSS pixels */
+  fontSize: number;
+  /** Units per em from the font */
+  unitsPerEm: number;
+  /** Font ascender in font units */
+  ascender: number;
+  /** Font descender in font units (negative) */
+  descender: number;
+}
+/**
+ * Draw a single glyph's strokes onto a canvas context, animated up to `localTime`.
+ * `localTime` is seconds relative to this glyph's start (0 = glyph begins).
+ */
+declare function drawGlyph(ctx: CanvasRenderingContext2D, glyph: TegakiGlyphData, pos: GlyphPosition, localTime: number, lineCap: LineCap, color: string, effects?: ResolvedEffect[], seed?: number, segmentSize?: number): void;
+//#endregion
+//#region src/lib/timeline.d.ts
+interface TimelineConfig {
+  /** Pause between glyphs (seconds). Default: `0.1` */
+  glyphGap?: number;
+  /** Pause after a space character (seconds). Default: `0.15` */
+  wordGap?: number;
+  /** Pause after a newline / line break (seconds). Default: `0.3` */
+  lineGap?: number;
+  /** Duration for characters without glyph SVGs (seconds). Default: `0.2` */
+  unknownDuration?: number;
+}
+interface TimelineEntry {
+  char: string;
+  offset: number;
+  duration: number;
+  hasSvg: boolean;
+}
+interface Timeline {
+  entries: TimelineEntry[];
+  totalDuration: number;
+}
+declare function computeTimeline(text: string, font: TegakiBundle, config?: TimelineConfig): Timeline;
+//#endregion
+//#region src/lib/utils.d.ts
+type Coercible = string | number | boolean | null | undefined | readonly Coercible[];
+//#endregion
+//#region src/lib/TegakiRenderer.d.ts
+type TimeControlMode = {
+  controlled: {
+    mode: 'controlled'; /** Current time in seconds. */
+    value: number;
+  };
+  uncontrolled: {
+    mode: 'uncontrolled'; /** Initial time in seconds. Default: `0` */
+    initialTime?: number; /** Playback speed multiplier. Default: `1` */
+    speed?: number; /** Whether animation is playing. Default: `true` */
+    playing?: boolean; /** Loop animation when it reaches the end. Default: `false` */
+    loop?: boolean;
+    /**
+     * Catch-up strength. When positive, playback speeds up when there is a
+     * large amount of remaining animation and decays back to normal gradually.
+     * `0` disables catch-up (default). Higher values ramp up more aggressively.
+     * Typical range: `0.2` – `2`.
+     */
+    catchUp?: number; /** Called on every frame with the current time. */
+    onTimeChange?: (time: number) => void;
+  };
+  css: {
+    mode: 'css';
+  };
+};
+/**
+ * A plain number is shorthand for `{ mode: 'controlled', value: number }`.
+ * `'css'` is shorthand for `{ mode: 'css' }`.
+ * Omit for uncontrolled mode with default settings.
+ */
+type TimeControlProp = null | undefined | number | 'css' | TimeControlMode[keyof TimeControlMode];
+interface TegakiRendererProps<E extends TegakiEffects<E> = Record<string, never>> extends Omit<ComponentProps<'div'>, 'children'> {
+  /** TegakiBundle with font data and animated glyph SVGs. */
+  font?: TegakiBundle;
+  /** Text to animate. Takes precedence over children. */
+  text?: string;
+  /** Children coerced to string. Strings and numbers are kept; everything else is ignored. */
+  children?: Coercible;
+  /**
+   * Time control. Accepts a number (controlled shorthand), or an object
+   * specifying the mode (`'controlled'`, `'uncontrolled'`, or `'css'`).
+   * Omit for uncontrolled playback with default settings.
+   */
+  time?: TimeControlProp;
+  /** Called once when the animation reaches the end of the timeline. */
+  onComplete?: () => void;
+  /** Rendering mode. `'canvas'` draws strokes on a `<canvas>` (requires
+   * `font.glyphData`), `'svg'` uses animated SVG elements. Default: `'canvas'` */
+  mode?: 'canvas' | 'svg';
+  /** Visual effects applied during canvas rendering. */
+  effects?: E;
+  /** Maximum segment size in pixels for effect subdivision. Lower values produce
+   * smoother effects but cost more to render. Default: `2` */
+  segmentSize?: number;
+  /** Timeline timing configuration (gap between glyphs, words, lines, etc.). */
+  timing?: TimelineConfig;
+  /** Show debug text overlay. */
+  showOverlay?: boolean;
+}
+declare function TegakiRenderer<const E extends TegakiEffects<E> = Record<string, never>>({
+  font,
+  text,
+  children,
+  time: timeProp,
+  onComplete,
+  mode,
+  effects,
+  segmentSize,
+  timing,
+  showOverlay,
+  ...props
+}: TegakiRendererProps<E>): _$react_jsx_runtime0.JSX.Element;
+//#endregion
+export { BBox, CSSLength, FontOutput, GlyphData, LineCap, PathCommand, Point, Stroke, TegakiBundle, type TegakiEffectConfigs, TegakiEffectName, type TegakiEffects, TegakiGlyphData, TegakiMultiEffectName, TegakiRenderer, type TegakiRendererProps, TegakiSingletonEffectName, type TimeControlMode, type TimeControlProp, TimedPoint, type Timeline, type TimelineConfig, computeTimeline, drawGlyph };
+//# sourceMappingURL=index.d.mts.map