otomate 0.2.1 → 0.3.1

package/SKILL.md

@@ -0,0 +1,371 @@
+---
+name: otomate
+description: Integrate the otomate library to read, write, and diff Word documents (.docx) and HTML via a Universal Document Model. Use when building apps that generate Word docs from HTML or CSS, construct structured documents programmatically, apply tracked changes, round-trip .docx files, or template documents with {{placeholders}}. Triggers on phrases like "generate a Word doc", "build a docx", "convert HTML to docx", "use otomate", "tracked changes in Word", "docx template injection".
+---
+
+# Integrating otomate
+
+This is a condensed integration guide for AI coding assistants. Read it end-to-end before writing any code that imports from `otomate`.
+
+## TL;DR — 30 seconds
+
+otomate turns HTML or structured data into `.docx` files (and back), using a single JSON-serializable tree called the **UDM**. For 80% of real use cases you only need three calls:
+
+```typescript
+import { readHtml, writeDocx, diff, writeDiffDocx } from "otomate";
+
+// 1. HTML → .docx (Word file)
+const tree = readHtml(htmlString, { css: optionalCssString });
+const buffer: Uint8Array = await writeDocx(tree);
+
+// 2. Tracked changes between two versions
+const delta = diff(oldTree, newTree);
+const trackedBuffer = await writeDiffDocx(newTree, delta, { author: "Me" });
+```
+
+`writeDocx` / `readDocx` / `writeDiffDocx` are **async** — always `await` them. `readHtml` / `writeHtml` are synchronous.
+
+## Mental model
+
+- **UDM = Universal Document Model.** A plain, JSON-serializable tree of nodes (`root` → `paragraph` → `text`, etc.). Every format (HTML, docx) converts to and from UDM; diffs operate on UDM.
+- **Marks are flat, not nested.** Bold + italic text is one `{ type: "text", value: "x", marks: [{type:"strong"},{type:"emphasis"}] }` node, not `strong(emphasis(text("x")))`. This matters when you build trees programmatically — use marks, don't nest inline wrappers.
+- **`classes: string[]` is first-class** on every node. HTML classes, Word paragraph styles, and Markdown attributes all map here.
+- **Format-specific metadata lives under `data`.** `data.html` for HTML-only fields (id, aria-*, data-*, style), `data.docx` for Word-specific state, `data.css` for parsed CSS rules.
+- **Lossless round-trips via an embedded snapshot.** When otomate writes a .docx, it embeds a JSON snapshot of the UDM inside the ZIP and binds it to the document.xml via a SHA-256 hash. `readDocx` uses the snapshot only if the hash still matches — i.e. the file hasn't been edited in Word. Otherwise it falls back to OOXML parsing (which is lossy for `div`/`figure`/`data.html.*`/custom marks).
+
+## Package map
+
+You only need one import in almost all cases:
+
+```typescript
+import { /* anything */ } from "otomate";
+```
+
+The `otomate` umbrella re-exports everything from these sub-packages:
+
+| Package | What's inside |
+|---|---|
+| `@otomate/core` | UDM types (`Root`, `Paragraph`, `Heading`, …), builders (`root()`, `paragraph()`, `text()`, `strong()`, `withClasses()`, `withData()`), traversal (`visit`, `nodeAtPath`), hashing |
+| `@otomate/diff` | Tree diff engine (`diff()`) + Myers text diff (`diffText()`) |
+| `@otomate/html` | `readHtml`, `writeHtml`, `renderDiffHtml`, `parseCssRules` |
+| `@otomate/docx` | `readDocx`, `writeDocx`, `writeDiffDocx`, `extractDocx`, `packDocx` |
+| `@otomate/css-docx` | `cssToRunProps`, `cssToParaProps`, `parseColor`, `parseLengthTwips`, `buildStyleElement` |
+| `@otomate/inject` | `inject()` for `{{placeholder}}` template filling |
+
+Direct sub-package imports (`import { readDocx } from "@otomate/docx"`) work too and have the same shapes. Prefer the umbrella unless you need to tree-shake aggressively.
+
+## The five entry points
+
+### `readHtml(html, options?): Root`
+**Sync.** Parses an HTML string into a UDM tree.
+- `html` — any HTML fragment or full document
+- `options.css?` — additional CSS string merged with inline `<style>` blocks found in the HTML. Both sources are parsed and stored on `tree.data.css`. Inline `<style>` blocks are extracted automatically — you don't need to strip them first.
+- Returns: `Root` (the top of the UDM tree)
+
+### `writeHtml(tree, options?): string`
+**Sync.** Serializes a UDM tree back to HTML.
+- `options.restoreAttributes?` (default `true`) — restore `id`/`data-*`/`style`/`aria-*` from `node.data.html`
+- `options.prettyPrint?` (default `false`) — indent output
+- Returns: HTML string
+
+### `readDocx(buffer): Promise<Root>`
+**Async.** Parses a `.docx` buffer (ZIP + OOXML) into a UDM tree.
+- `buffer` — `ArrayBuffer` or `Uint8Array`. Don't pass a file path; read the file yourself first (`fs.readFileSync(path)` in Node).
+- Returns: `Promise<Root>`. If the file was written by otomate and is unchanged, the snapshot path gives a perfect round-trip. Otherwise falls back to OOXML parsing.
+
+### `writeDocx(tree, options?): Promise<Uint8Array>`
+**Async.** Serializes a UDM tree into a `.docx` buffer.
+- `options.cssClasses?` — extra CSS class → declarations map, merged with `tree.data.css.classRules`. Explicit options win over tree-embedded CSS.
+- Returns: `Promise<Uint8Array>`. Write with `fs.writeFileSync("out.docx", buffer)`.
+
+### `writeDiffDocx(newTree, diffResult, options?): Promise<Uint8Array>`
+**Async.** Serializes a tree with tracked changes (`<w:ins>` / `<w:del>`) so Word's Accept/Reject-All flow works.
+- `newTree` — the "after" tree
+- `diffResult` — output from `diff(oldTree, newTree)`
+- `options.author?` (default `"Otomate"`) — shown on each revision
+- `options.date?` (default `"2024-01-01T00:00:00Z"`) — ISO 8601 string on each revision
+- All `DocxWriteOptions` fields (e.g. `cssClasses`) are also accepted
+- Returns: `Promise<Uint8Array>`
+
+## Pattern recipes
+
+### R1. HTML (from a CMS) → branded Word doc with CSS
+
+```typescript
+import { readHtml, writeDocx } from "otomate";
+import { writeFileSync } from "node:fs";
+
+const htmlFromCms = `
+  <style>
+    .intro { font-style: italic; color: #666; }
+    h1 { color: #1e3a5f; }
+  </style>
+  <h1>Quarterly Report</h1>
+  <p class="intro">Summary of Q1 results.</p>
+  <p>Revenue is up 12%.</p>
+`;
+
+const tree = readHtml(htmlFromCms);     // inline <style> auto-extracted
+const buffer = await writeDocx(tree);
+writeFileSync("report.docx", buffer);
+```
+
+To override or supplement inline styles (e.g. brand CSS applied to every doc), pass `options.css`:
+
+```typescript
+const brandCss = `h1 { font-family: Georgia; font-size: 28pt; color: #003366; }`;
+const tree = readHtml(htmlFromCms, { css: brandCss });
+```
+
+### R2. Build a document programmatically from app data
+
+No HTML round-trip needed; construct the tree directly via `@otomate/core` builders:
+
+```typescript
+import {
+  root, heading, paragraph, text, strong, emphasis,
+  list, listItem, table, tableRow, tableCell, withClasses,
+  writeDocx,
+} from "otomate";
+
+const doc = root(
+  heading(1, text("Project Proposal")),
+  paragraph(
+    text("This quarter we will "),
+    text("ship", [strong()]),
+    text(" the "),
+    text("redesign", [emphasis()]),
+    text("."),
+  ),
+  heading(2, text("Key Milestones")),
+  list(true,  // ordered
+    listItem(paragraph(text("Kickoff (week 1)"))),
+    listItem(paragraph(text("Beta (week 6)"))),
+    listItem(paragraph(text("Launch (week 12)"))),
+  ),
+  withClasses(
+    paragraph(text("Confidential — do not redistribute.")),
+    "footer-note",
+  ),
+);
+
+const buffer = await writeDocx(doc, {
+  cssClasses: {
+    "footer-note": { "font-size": "9pt", color: "#888", "font-style": "italic" },
+  },
+});
+```
+
+Key things to notice:
+- `text(value, marks)` — marks are the second argument
+- `list(ordered, ...items)` — `true` for `<ol>`, `false` for `<ul>`
+- `tableRow(isHeader, ...cells)` — `isHeader: true` produces `<th>` cells
+- `withClasses(node, ...classes)` / `withData(node, data)` return the same node, so they chain inline
+
+### R3. Round-trip a Word file (read, optionally mutate, write back)
+
+```typescript
+import { readDocx, writeDocx } from "otomate";
+import { readFileSync, writeFileSync } from "node:fs";
+
+const buf = await readFileSync("input.docx");
+const tree = await readDocx(buf);
+
+// Optional: mutate the tree. E.g. change the first heading's text.
+if (tree.children[0]?.type === "heading") {
+  (tree.children[0].children[0] as any).value = "New Title";
+}
+
+const out = await writeDocx(tree);
+writeFileSync("output.docx", out);
+```
+
+**If you don't mutate the tree, the output is byte-close to the input.** The embedded UDM snapshot + hash means the reader picked the lossless path; any mutation will invalidate the snapshot on write and the output will reflect your changes.
+
+### R4. Tracked changes between two versions
+
+```typescript
+import { readHtml, diff, writeDiffDocx } from "otomate";
+
+const oldTree = readHtml("<h1>Product Roadmap</h1><p>Q1 2024 goals...</p>");
+const newTree = readHtml("<h1>Product Roadmap 2024</h1><p>Revised Q1 goals...</p>");
+
+const delta = diff(oldTree, newTree);
+
+const trackedBuffer = await writeDiffDocx(newTree, delta, {
+  author: "Jane Editor",
+  date: "2024-04-07T10:30:00Z",
+});
+writeFileSync("roadmap-tracked.docx", trackedBuffer);
+```
+
+The resulting `.docx` opens in Word with all changes as revisions. Word's "Accept All" / "Reject All" buttons work.
+
+> **For the full round-trip flow** — generating the diff, writing tracked-changes docx, re-importing, re-rendering HTML with revisions visible, and accepting changes — read `guides/html-to-docx-and-back.md` in this package. It walks through a 7-stage reference implementation and includes a long troubleshooting section covering every real pitfall: wrong `renderDiffHtml` argument order, nested deletes not rendering as `<w:del>`, async-forgot-await traps, stale-dist issues, CSS class-name sanitization, hyperlink rId collisions, and more.
+
+### R5. Template injection with `{{placeholders}}`
+
+```typescript
+import { readDocx, inject, writeDocx } from "otomate";
+
+const template = await readDocx(readFileSync("offer-template.docx"));
+
+const filled = inject(template, {
+  companyName: "Acme Corp",
+  employee: { name: "Jane Smith", title: "Engineer" },
+  benefits: [
+    { name: "Health", coverage: "Full" },
+    { name: "401k", coverage: "6% match" },
+  ],
+});
+
+writeFileSync("jane-offer.docx", await writeDocx(filled));
+```
+
+Placeholder syntax inside the Word template:
+- `{{fieldName}}` — simple substitution
+- `{{employee.name}}` — dot-path
+- `{{#each benefits}}...{{name}}: {{coverage}}...{{/each}}` — loops
+- `{{#if condition}}...{{/if}}` — conditionals
+
+### R6. Branded CSS shared across every generated doc
+
+Build the CSS once, attach it to every tree:
+
+```typescript
+const BRAND_CSS = `
+  h1 { font-family: Georgia; font-size: 28pt; color: #003366; }
+  h2 { font-family: Georgia; font-size: 18pt; color: #003366; }
+  p  { font-family: Calibri;  font-size: 11pt; color: #333;    line-height: 1.5; }
+  .intro { font-style: italic; color: #666; }
+`;
+
+async function generate(html: string): Promise<Uint8Array> {
+  return writeDocx(readHtml(html, { css: BRAND_CSS }));
+}
+```
+
+Alternatively, pass `cssClasses` directly to `writeDocx` — it's merged on top of any `tree.data.css` the HTML reader produced.
+
+## UDM node reference
+
+All types live in `@otomate/core` and are re-exported from `otomate`. Required fields are **bold**.
+
+### Block nodes
+
+| Type | Required | Optional |
+|---|---|---|
+| `root` | **`type: "root"`**, **`children: BlockNode[]`** | `classes`, `data`, `id` |
+| `paragraph` | **`type: "paragraph"`**, **`children: InlineNode[]`** | `classes`, `data`, `id` |
+| `heading` | **`type: "heading"`**, **`depth: 1..6`**, **`children: InlineNode[]`** | `classes`, `data`, `id` |
+| `blockquote` | **`type: "blockquote"`**, **`children: BlockNode[]`** | same |
+| `list` | **`type: "list"`**, **`ordered: boolean`**, **`children: ListItem[]`** | `start?: number`, `classes`, `data` |
+| `listItem` | **`type: "listItem"`**, **`children: BlockNode[]`** | `checked?: boolean` |
+| `codeBlock` | **`type: "codeBlock"`**, **`value: string`** | `lang?: string`, `meta?: string` |
+| `table` | **`type: "table"`**, **`children: TableRow[]`** | same |
+| `tableRow` | **`type: "tableRow"`**, **`children: TableCell[]`** | `isHeader?: boolean` |
+| `tableCell` | **`type: "tableCell"`**, **`children: BlockNode[]`** | `colspan?: number`, `rowspan?: number`, `align?: "left"\|"center"\|"right"` |
+| `thematicBreak` | **`type: "thematicBreak"`** | — |
+| `div` | **`type: "div"`**, **`children: BlockNode[]`** | same |
+| `figure` | **`type: "figure"`**, **`children: (BlockNode \| FigCaption)[]`** | same |
+| `figCaption` | **`type: "figCaption"`**, **`children: InlineNode[]`** | same |
+| `html` | **`type: "html"`**, **`value: string`** | raw-HTML passthrough — use sparingly |
+
+### Inline nodes
+
+| Type | Required | Optional |
+|---|---|---|
+| `text` | **`type: "text"`**, **`value: string`** | `marks?: Mark[]` |
+| `break` | **`type: "break"`** | (line break) |
+| `image` | **`type: "image"`**, **`url: string`** | `alt?: string`, `title?: string` |
+| `inlineCode` | **`type: "inlineCode"`**, **`value: string`** | — |
+
+### Marks (applied to `text` nodes via `marks[]`)
+
+Built-in: `strong`, `emphasis`, `strikethrough`, `underline`, `superscript`, `subscript`, `code`, `link` (needs `attrs.url`), `highlight` (optional `attrs.color`). Custom mark types are allowed — the writer preserves them via the UDM snapshot.
+
+## CSS → OOXML cheat-sheet
+
+These CSS properties are understood by `writeDocx` (via `@otomate/css-docx`). Anything not listed is silently ignored.
+
+**Run (text) properties**
+
+| CSS | OOXML |
+|---|---|
+| `font-family: Arial` | `w:rFonts` |
+| `font-size: 14pt` | `w:sz` (half-points) |
+| `font-weight: bold` / `≥700` | `w:b` |
+| `font-style: italic` | `w:i` |
+| `color: #333` | `w:color` |
+| `background-color: yellow` | `w:shd` |
+| `background: #cee6ce` (shorthand) | `w:shd` — first color token wins |
+| `text-decoration: underline` | `w:u val="single"` |
+| `text-decoration: line-through` | `w:strike` |
+
+**Paragraph properties**
+
+| CSS | OOXML |
+|---|---|
+| `text-align: left/center/right/justify` | `w:jc` |
+| `margin-top/bottom: 12pt` | `w:spacing before/after` (twips) |
+| `line-height: 1.5` | `w:spacing line` |
+| `margin-left/right: 0.5in` | `w:ind left/right` (twips) |
+| `border: 1pt solid #000` (and `border-top/right/bottom/left`) | `w:pBdr` (per side) |
+| `border-style: solid` + `border-color: #5cb85c` + `border-width: 3px` (separated) | `w:pBdr` — each property accepts the 1–4 value CSS shorthand (top/right/bottom/left) |
+| `background-color: #fafafa` | `w:shd` |
+| `background: #fafafa` (shorthand) | `w:shd` — first color token wins |
+
+**Color formats accepted**: named colors, `#rgb`, `#rrggbb`, `#rrggbbaa`, `rgb()`, `rgba()`, `hsl()`, `hsla()`. Alpha is dropped (OOXML has no alpha channel).
+
+**Length units accepted**: `px`, `pt`, `em`, `rem`, `cm`, `mm`, `in`. Percentages (`%`) are **not** supported for paragraph spacing — OOXML has no basis to resolve them against.
+
+## Gotchas (ranked by how often they bite)
+
+1. **`writeDocx`, `readDocx`, `writeDiffDocx` are async.** Forgetting `await` leaves you holding a `Promise<Uint8Array>` instead of a buffer — `fs.writeFileSync` will then fail or write garbage. `readHtml`/`writeHtml` are synchronous; don't await them.
+2. **Works in both Node ≥20 and modern browsers** — the docx path uses the Web Crypto API internally (not `node:crypto`), so the library is fully universal. You can `readDocx`/`writeDocx` in a browser, a worker, Deno, Bun, or an edge runtime the same way you would in Node.
+3. **Pass a buffer, not a path.** `readDocx(buffer)` expects `Uint8Array` or `ArrayBuffer`. Call `fs.readFileSync("file.docx")` first.
+4. **Marks are flat.** Put bold on a text node via `text("x", [strong()])`, not `strong(text("x"))`. The builders enforce this — `strong()` returns a `Mark`, not a wrapper node.
+5. **CSS class names get sanitized for OOXML.** Only `[A-Za-z0-9_\-:]` survives and the result is clamped to 31 characters. A class like `"my class!"` becomes `"myclass"` in the generated Word style. Keep class names alphanumeric if you want 1:1 fidelity.
+6. **`readDocx` prefers the embedded snapshot only if its hash matches.** If a user opened the file in Word and saved it, the snapshot is ignored and you get the OOXML-parsed tree — which is lossy for `div`, `figure`, custom marks, `data.html.*` attributes, and the original CSS rules. If your downstream workflow involves users editing in Word, don't rely on those features surviving.
+7. **The umbrella export is the safest import path.** `import { X } from "otomate"` re-exports the complete public API. Direct sub-package imports (`@otomate/docx`) work but mean you have to track dependencies yourself.
+8. **`writeDocx` mutates nothing** — it always returns a fresh `Uint8Array`. Safe to call multiple times on the same tree.
+9. **Tables need a `<w:p/>` after them** per Word's quirk. The writer handles this automatically; you don't need to think about it when building trees.
+
+## How to verify your integration
+
+Drop this into a scratch file and run it with `tsx` or `node --import tsx`:
+
+```typescript
+import { readHtml, writeDocx, readDocx } from "otomate";
+import assert from "node:assert/strict";
+
+const HTML = `
+  <style>.title { color: red; }</style>
+  <h1 class="title">Hello</h1>
+  <p>World <strong>bold</strong>.</p>
+`;
+
+const tree = readHtml(HTML);
+assert.equal(tree.children[0]?.type, "heading");
+assert.equal((tree.data as any)?.css?.classRules?.title?.color, "red");
+
+const buf = await writeDocx(tree);
+assert.ok(buf.byteLength > 1000, "docx should be at least 1kb");
+
+const reread = await readDocx(buf);
+// Snapshot path: structure survives exactly
+assert.equal((reread.children[0] as any)?.children?.[0]?.value, "Hello");
+
+console.log("otomate integration OK");
+```
+
+If any assertion fails or the script throws, **do not generate further code using the library** — report the failure to the user and investigate.
+
+## Where to look for more detail
+
+- **Full HTML ↔ docx walkthrough with troubleshooting**: `guides/html-to-docx-and-back.md` (next to this file in `node_modules/otomate/`). A 7-stage end-to-end implementation guide covering the tracked-changes round-trip, plus a long troubleshooting section that catalogs every real trap encountered while building the reference test. **Read this before integrating the tracked-changes flow.**
+- **Types**: `packages/core/src/types.ts` — canonical definitions of every node
+- **Builders**: `packages/core/src/builders.ts` — the exact signature of every factory
+- **CSS mapping**: `packages/css-docx/src/convert.ts` — every CSS property the library understands
+- **End-to-end examples**: `packages/docx/src/__tests__/realworld.test.ts` — the most realistic usage patterns the library is tested against
+- **Architecture**: the repo's top-level `README.md`

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export { type UdmNode, type UdmParent, type UdmLiteral, type Root, type Paragraph, type Heading, type Blockquote, type List, type ListItem, type CodeBlock, type Table, type TableRow, type TableCell, type ThematicBreak, type Div, type Figure, type FigCaption, type Math, type FootnoteDefinition, type Html, type Text, type Break, type Image, type FootnoteReference, type InlineCode, type InlineMath, type Mark, type InlineNode, type BlockNode, type AnyNode, type Position, type Point, isParent, isLiteral, isText, root, paragraph, heading, blockquote, list, listItem, codeBlock, table, tableRow, tableCell, thematicBreak, div, text, lineBreak, image, strong, emphasis, strikethrough, underline, code, link, highlight, withClasses, withData, withId, visit, nodeCount, collectNodes, pathTo, nodeAtPath, hashNode, invalidateHash, } from "@otomate/core";
 export { diff, diffText, type DiffResult, type DiffOptions, type EditOperation, type TextChange, type NodeMapping, } from "@otomate/diff";
 export { readHtml, writeHtml, renderDiffHtml, parseCssClasses, parseCssRules, type HtmlReadOptions, type HtmlWriteOptions, type DiffHtmlOptions, type CssClassRules, type CssParsedRules, } from "@otomate/html";
-export { readDocx, writeDocx, type DocxReadOptions, type DocxWriteOptions, } from "@otomate/docx";
+export { readDocx, writeDocx, writeDiffDocx, extractDocx, packDocx, type DocxReadOptions, type DocxWriteOptions, type DiffDocxOptions, } from "@otomate/docx";
 export { inject, normalizeTextRuns, parseTokens, splitByPlaceholders, hasPlaceholders, resolveValue, valueToString, isTruthy, type InjectData, type InjectOptions, type PlaceholderToken, type PlaceholderHit, type RichContent, } from "@otomate/inject";
 export { cssToRunProps, cssToParaProps, parseColor, parseLengthTwips, parseLengthHalfPts, runPropsToXml, paraPropsToXml, buildStyleElement, type OoxmlRunProps, type OoxmlParaProps, } from "@otomate/css-docx";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAKA,OAAO,EAEL,KAAK,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,UAAU,EAC7C,KAAK,IAAI,EAAE,KAAK,SAAS,EAAE,KAAK,OAAO,EAAE,KAAK,UAAU,EACxD,KAAK,IAAI,EAAE,KAAK,QAAQ,EAAE,KAAK,SAAS,EACxC,KAAK,KAAK,EAAE,KAAK,QAAQ,EAAE,KAAK,SAAS,EACzC,KAAK,aAAa,EAAE,KAAK,GAAG,EAAE,KAAK,MAAM,EAAE,KAAK,UAAU,EAC1D,KAAK,IAAI,EAAE,KAAK,kBAAkB,EAAE,KAAK,IAAI,EAC7C,KAAK,IAAI,EAAE,KAAK,KAAK,EAAE,KAAK,KAAK,EACjC,KAAK,iBAAiB,EAAE,KAAK,UAAU,EAAE,KAAK,UAAU,EACxD,KAAK,IAAI,EAAE,KAAK,UAAU,EAAE,KAAK,SAAS,EAAE,KAAK,OAAO,EACxD,KAAK,QAAQ,EAAE,KAAK,KAAK,EAEzB,QAAQ,EAAE,SAAS,EAAE,MAAM,EAE3B,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,EACpD,SAAS,EAAE,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,aAAa,EAAE,GAAG,EACzD,IAAI,EAAE,SAAS,EAAE,KAAK,EACtB,MAAM,EAAE,QAAQ,EAAE,aAAa,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EACjE,WAAW,EAAE,QAAQ,EAAE,MAAM,EAE7B,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,EAAE,UAAU,EAElD,QAAQ,EAAE,cAAc,GACzB,MAAM,eAAe,CAAC;AAGvB,OAAO,EACL,IAAI,EACJ,QAAQ,EACR,KAAK,UAAU,EAAE,KAAK,WAAW,EACjC,KAAK,aAAa,EAAE,KAAK,UAAU,EAAE,KAAK,WAAW,GACtD,MAAM,eAAe,CAAC;AAGvB,OAAO,EACL,QAAQ,EAAE,SAAS,EAAE,cAAc,EACnC,eAAe,EAAE,aAAa,EAC9B,KAAK,eAAe,EAAE,KAAK,gBAAgB,EAAE,KAAK,eAAe,EACjE,KAAK,aAAa,EAAE,KAAK,cAAc,GACxC,MAAM,eAAe,CAAC;AAGvB,OAAO,EACL,QAAQ,EAAE,SAAS,EACnB,KAAK,eAAe,EAAE,KAAK,gBAAgB,GAC5C,MAAM,eAAe,CAAC;AAGvB,OAAO,EACL,MAAM,EACN,iBAAiB,EACjB,WAAW,EAAE,mBAAmB,EAAE,eAAe,EACjD,YAAY,EAAE,aAAa,EAAE,QAAQ,EACrC,KAAK,UAAU,EAAE,KAAK,aAAa,EACnC,KAAK,gBAAgB,EAAE,KAAK,cAAc,EAAE,KAAK,WAAW,GAC7D,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EACL,aAAa,EAAE,cAAc,EAC7B,UAAU,EAAE,gBAAgB,EAAE,kBAAkB,EAChD,aAAa,EAAE,cAAc,EAAE,iBAAiB,EAChD,KAAK,aAAa,EAAE,KAAK,cAAc,GACxC,MAAM,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAKA,OAAO,EAEL,KAAK,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,UAAU,EAC7C,KAAK,IAAI,EAAE,KAAK,SAAS,EAAE,KAAK,OAAO,EAAE,KAAK,UAAU,EACxD,KAAK,IAAI,EAAE,KAAK,QAAQ,EAAE,KAAK,SAAS,EACxC,KAAK,KAAK,EAAE,KAAK,QAAQ,EAAE,KAAK,SAAS,EACzC,KAAK,aAAa,EAAE,KAAK,GAAG,EAAE,KAAK,MAAM,EAAE,KAAK,UAAU,EAC1D,KAAK,IAAI,EAAE,KAAK,kBAAkB,EAAE,KAAK,IAAI,EAC7C,KAAK,IAAI,EAAE,KAAK,KAAK,EAAE,KAAK,KAAK,EACjC,KAAK,iBAAiB,EAAE,KAAK,UAAU,EAAE,KAAK,UAAU,EACxD,KAAK,IAAI,EAAE,KAAK,UAAU,EAAE,KAAK,SAAS,EAAE,KAAK,OAAO,EACxD,KAAK,QAAQ,EAAE,KAAK,KAAK,EAEzB,QAAQ,EAAE,SAAS,EAAE,MAAM,EAE3B,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,EACpD,SAAS,EAAE,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,aAAa,EAAE,GAAG,EACzD,IAAI,EAAE,SAAS,EAAE,KAAK,EACtB,MAAM,EAAE,QAAQ,EAAE,aAAa,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EACjE,WAAW,EAAE,QAAQ,EAAE,MAAM,EAE7B,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,EAAE,UAAU,EAElD,QAAQ,EAAE,cAAc,GACzB,MAAM,eAAe,CAAC;AAGvB,OAAO,EACL,IAAI,EACJ,QAAQ,EACR,KAAK,UAAU,EAAE,KAAK,WAAW,EACjC,KAAK,aAAa,EAAE,KAAK,UAAU,EAAE,KAAK,WAAW,GACtD,MAAM,eAAe,CAAC;AAGvB,OAAO,EACL,QAAQ,EAAE,SAAS,EAAE,cAAc,EACnC,eAAe,EAAE,aAAa,EAC9B,KAAK,eAAe,EAAE,KAAK,gBAAgB,EAAE,KAAK,eAAe,EACjE,KAAK,aAAa,EAAE,KAAK,cAAc,GACxC,MAAM,eAAe,CAAC;AAGvB,OAAO,EACL,QAAQ,EAAE,SAAS,EAAE,aAAa,EAClC,WAAW,EAAE,QAAQ,EACrB,KAAK,eAAe,EAAE,KAAK,gBAAgB,EAAE,KAAK,eAAe,GAClE,MAAM,eAAe,CAAC;AAGvB,OAAO,EACL,MAAM,EACN,iBAAiB,EACjB,WAAW,EAAE,mBAAmB,EAAE,eAAe,EACjD,YAAY,EAAE,aAAa,EAAE,QAAQ,EACrC,KAAK,UAAU,EAAE,KAAK,aAAa,EACnC,KAAK,gBAAgB,EAAE,KAAK,cAAc,EAAE,KAAK,WAAW,GAC7D,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EACL,aAAa,EAAE,cAAc,EAC7B,UAAU,EAAE,gBAAgB,EAAE,kBAAkB,EAChD,aAAa,EAAE,cAAc,EAAE,iBAAiB,EAChD,KAAK,aAAa,EAAE,KAAK,cAAc,GACxC,MAAM,mBAAmB,CAAC"}