fractalpop 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 FractalMandala
+
+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,232 @@
+# fractalpop
+
+`fractalpop` is the engine. It highlights a string of source code and returns
+an HTML string — no DOM, no runtime dependencies. Use it directly on any
+platform, or through one of the adapter packages.
+
+## Install
+
+```sh
+npm install fractalpop
+```
+
+## Quick start
+
+Call `highlight()` with your code and a language. The result is a string of
+nested `<span>` elements that you drop into a `<pre><code>` block.
+
+```ts
+import { highlight } from 'fractalpop'
+
+const html = highlight('const ready = true', { lang: 'ts' })
+// <span class="fp__line"><span class="fp__token--keyword" style="color:var(--fp-keyword)">const</span> …
+```
+
+The output is HTML-encoded, so it is safe to inject with `innerHTML`,
+`{@html}`, or `dangerouslySetInnerHTML`.
+
+## `highlight(code, options)`
+
+`highlight` takes the source string and an options object. It returns an HTML string.
+
+| Option | Type | Default | Purpose |
+| --- | --- | --- | --- |
+| `lang` | `string` | `'typescript'` | Language id, extension, or alias (see [Languages](#languages)). |
+| `cx` | `Partial<Record<TokenType, string>>` | — | Extra class name to add per token type. |
+| `mark` | `(token: MarkToken) => void` | — | Mutate a single token before it renders. |
+| `markLine` | `(line: MarkLine) => void` | — | Mutate a whole line before it renders. |
+
+`cx`, `mark`, and `markLine` are the only customization hooks, and they control
+performance. When you pass **none** of them, `render` takes a fast path: it
+concatenates strings with no per-token object allocation. Passing any hook
+switches to the slower path that builds mutable token and line objects so the
+hooks can run. If you do not need customization, pass no hooks.
+
+### Emphasis with `cx`
+
+`cx` appends a class to every token of a given type. This is the Tailwind-
+friendly way to emphasize tokens without writing selectors.
+
+```ts
+highlight(code, {
+  lang: 'sass',
+  cx: { keyword: 'font-bold', comment: 'italic opacity-70' },
+})
+```
+
+### Line highlighting with `markLine`
+
+Each line exposes its zero-based `index`. Add a class when the line is one you
+want to highlight.
+
+```ts
+const active = new Set([2, 3]) // 1-based line numbers
+
+highlight(code, {
+  lang: 'ts',
+  markLine(line) {
+    if (active.has(line.index + 1)) line.className += ' fp__line--highlighted'
+  },
+})
+```
+
+## Theming
+
+fractalpop does not ship colors. Every token renders with
+`class="fp__token--<type>"` and an inline `style="color:var(--fp-<type>)"`, so a
+theme is a block of CSS variables you set on any ancestor.
+
+```css
+:root {
+  --fp-identifier: #354150;
+  --fp-keyword: #f47067;
+  --fp-string: #00a99a;
+  --fp-class: #8d85ff;
+  --fp-property: #4e8fdf;
+  --fp-entity: #665ac7;
+  --fp-jsxliterals: #bf7db6;
+  --fp-sign: #8996a3;
+  --fp-comment: #a19595;
+}
+
+.fp__line--highlighted {
+  background: #fff8c5;
+}
+```
+
+For dark mode, redefine the same variables under a selector or media query — for
+example `:root[data-theme='dark']` or `@media (prefers-color-scheme: dark)`.
+
+### Token types
+
+Token types are a small, fixed list. Keeping it stable keeps themes portable.
+
+| Type | CSS variable | Typical meaning |
+| --- | --- | --- |
+| `identifier` | `--fp-identifier` | Plain identifiers and default text. |
+| `keyword` | `--fp-keyword` | Language keywords. |
+| `string` | `--fp-string` | Strings, regex literals, template text. |
+| `class` | `--fp-class` | Capitalized names, numbers, `null`, types. |
+| `property` | `--fp-property` | Object/CSS properties, Sass `$variables`. |
+| `entity` | `--fp-entity` | Function and mixin names. |
+| `jsxliterals` | `--fp-jsxliterals` | JSX text between tags. |
+| `sign` | `--fp-sign` | Punctuation and operators. |
+| `comment` | `--fp-comment` | Comments. |
+
+Two more types, `break` (newlines) and `space` (horizontal whitespace), are
+preserved for faithful output but carry no color.
+
+## Languages
+
+fractalpop ships metadata and configs for **32 languages**, but the default
+entry only **registers** TypeScript and plaintext — the rest stay tree-
+shakeable. Register what you need yourself, or import `fractalpop/full` to
+register all 32 up front. Resolve a name, file extension, or alias to a
+canonical id with `lang()`.
+
+```ts
+import { lang, findLanguage, allLanguages } from 'fractalpop/lang'
+
+lang('tsx')     // 'typescript'
+lang('.scss')   // 'scss'  (metadata is known; register the config to highlight)
+lang('yml')     // 'yaml'
+lang('nope')    // undefined
+```
+
+The four languages built with the most care are the ones fractalpop exists for:
+
+- `sass` — indented Sass (no braces, no semicolons).
+- `scss` — the brace dialect, sharing Sass's value coloring.
+- `svelte` — the composite: `<script lang="ts">` + markup + `<style lang="sass">`.
+- `typescript` / `javascript` — a full JS/JSX/TS runtime (regex literals,
+  template interpolation, JSX, and the TS-generic-vs-JSX distinction).
+
+The rest is the general pack: `css`, `html`, `markdown`, `diff`, `plaintext`,
+`c`, `cpp`, `csharp`, `go`, `java`, `rust`, `json`, `shell`, `sql`, `yaml`,
+`toml`, `python`, `ruby`, `php`, `kotlin`, `swift`, `lua`, `graphql`, `hcl`,
+`dockerfile`, `powershell`, `zig`.
+
+## Subpath exports
+
+The package exposes several entries so you only bundle what you need.
+
+| Import | Exposes |
+| --- | --- |
+| `fractalpop` | `highlight`, registry utilities, and the option/token types. **Only TypeScript and plaintext are registered by default.** |
+| `fractalpop/full` | Everything from `fractalpop`, with all 32 languages registered. |
+| `fractalpop/core` | `parse`, `tokenize`, `render` (→ string), `generate` (→ AST). |
+| `fractalpop/lang` | `lang`, `findLanguage`, `allLanguages`. |
+| `fractalpop/lang/<id>` | A single language config (tree-shakeable). |
+| `fractalpop/gpu` | Async WebGPU highlighting via optional peer `gpu-lexer`. |
+
+`generate` returns a hast-like AST, which is what a unified/rehype pipeline
+consumes. `render` returns the HTML string that `highlight` wraps.
+
+```ts
+import { parse, generate } from 'fractalpop/core'
+import { lang, getLanguageConfig } from 'fractalpop/full'
+
+const parsed = parse(code, getLanguageConfig(lang('sass')!))
+const tree = generate(parsed) // element/text nodes, one per line and token
+```
+
+## Registry utilities
+
+The default `fractalpop` entry only registers TypeScript and plaintext. Use
+these utilities to control which languages are available at runtime.
+
+The registry is a single module-level singleton shared by every entry point
+(`fractalpop/full` re-exports and mutates the same core as `fractalpop`), so a
+registration made through one import path is visible to all others in the same
+app.
+
+```ts
+import {
+  registerLanguage,
+  setDefaults,
+  importDefaults,
+  canonicalizeLang,
+  getRegisteredLanguages,
+} from 'fractalpop'
+
+registerLanguage({ id: 'python', extension: 'py', aliases: ['python3'] }, pythonConfig)
+setDefaults({ python: pythonConfig, rust: rustConfig })
+await importDefaults(['python', 'rust'])
+canonicalizeLang('tsx') // 'typescript'
+```
+
+| Function | Purpose |
+| --- | --- |
+| `registerLanguage(language, config?)` | Register one language, optionally with its parse config. |
+| `setDefaults(languagesOrConfigs)` | Replace the default set. Accepts `Language[]` or `Record<string, ParseOptions>`. |
+| `importDefaults(ids)` | Asynchronously import and register languages by id. |
+| `canonicalizeLang(name)` | Resolve a name/alias/extension to the canonical id. |
+| `getRegisteredLanguages()` | List currently registered languages. |
+
+## Related Packages
+
+- [@fractalpop/svelte](https://www.npmjs.com/package/@fractalpop/svelte) — Svelte 5 components and action
+- [@fractalpop/mdsvex](https://www.npmjs.com/package/@fractalpop/mdsvex) — Highlighter hook for MDSveX in SvelteKit
+- [@fractalpop/remark](https://www.npmjs.com/package/@fractalpop/remark) — Remark plugin for Markdown & MDX
+
+## Benchmarks
+
+fractalpop, Sugar High, PrismJS, and highlight.js highlighting the same generated TypeScript files:
+
+<!-- benchmark:start -->
+Measured 2026-09-12 with Node v24.19.0, darwin arm64, Apple M3 Pro.
+
+| TypeScript | fractalpop 0.1.0 | Sugar High 2.4.0 | PrismJS 1.30.0 | highlight.js 11.12.0 |
+| --- | ---: | ---: | ---: | ---: |
+| Minified (KiB) | 12.35 | 27.29 | 14.57 | 29.49 |
+| Gzip (KiB) | 5.28 | 10.09 | 5.57 | 11.28 |
+| 11 KiB | 1.87 | 1.91 | 1.42 | 2.39 |
+| 100 KiB | 19.49 | 19.61 | 14.05 | 23.57 |
+| 500 KiB | 98.13 | 100.04 | 90.45 | 117.98 |
+
+Median milliseconds per file; lower is better. 5 timed samples after warmup.
+Sizes are TypeScript-only browser bundles, minified with Bun; gzip uses level 9. Theme CSS is excluded.
+Loading and initialization are excluded. Each library highlights the same generated TypeScript
+into HTML using an explicit language. Grammars and HTML output differ; this is not a measure
+of highlighting quality or browser rendering speed. Results vary by machine and workload.
+<!-- benchmark:end -->

package/dist/core.d.ts

@@ -0,0 +1,110 @@
+/**
+ * fractalpop core — token model, line assembly, and rendering.
+ *
+ * Design: tokens are numeric `[type, value]` pairs during lexing (fast Set/array
+ * work); the string type names are resolved only at render. Output is an HTML
+ * string with no DOM required — so SSR and client produce identical markup.
+ */
+/** The stable, ordered token-type list. This list is the theming contract:
+ * each type maps to one CSS variable `--fp-<type>` and one class `fp__token--<type>`. */
+declare const TokenTypes: readonly ["identifier", "keyword", "string", "class", "property", "entity", "jsxliterals", "sign", "comment", "break", "space"];
+type TokenType = (typeof TokenTypes)[number];
+/** A lexer emits these: `[numericType, value]`. */
+type Token = [number, string];
+declare const FractalPop: {
+    readonly TokenTypes: readonly ["identifier", "keyword", "string", "class", "property", "entity", "jsxliterals", "sign", "comment", "break", "space"];
+    readonly TokenMap: Map<"string" | "identifier" | "keyword" | "class" | "property" | "entity" | "jsxliterals" | "sign" | "comment" | "break" | "space", number>;
+};
+interface ParsedToken {
+    type: TokenType;
+    value: string;
+}
+interface ParsedLine {
+    index: number;
+    value: string;
+    tokens: ParsedToken[];
+    annotations: string[];
+}
+interface ParsedCode {
+    value: string;
+    lines: ParsedLine[];
+}
+/** Mutable token handed to `mark`. Hooks may change className/style/properties. */
+interface MarkToken {
+    type: TokenType;
+    value: string;
+    className: string;
+    style: Record<string, string | number>;
+    properties: Record<string, string | number | boolean>;
+}
+/** Mutable line handed to `markLine`. Hooks may change className/style/properties. */
+interface MarkLine {
+    index: number;
+    value: string;
+    tokens: ParsedToken[];
+    annotations: string[];
+    className: string;
+    style: Record<string, string | number>;
+    properties: Record<string, string | number | boolean>;
+}
+interface DisplayOptions {
+    /** Extra class name appended per token type, e.g. `{ keyword: 'font-bold' }`. */
+    cx?: Partial<Record<TokenType, string>>;
+    /** Mutate a single token before it renders. */
+    mark?: (token: MarkToken) => void;
+    /** Mutate a whole line before it renders (used for line highlighting). */
+    markLine?: (line: MarkLine) => void;
+}
+/** hast-like AST node (element or text). Consumed by the remark adapter. */
+interface AstText {
+    type: 'text';
+    value: string;
+}
+interface AstElement {
+    type: 'element';
+    tagName: string;
+    tokenType?: TokenType;
+    children: Array<AstElement | AstText>;
+    properties: Record<string, unknown>;
+}
+/** Build a hast-like AST (one element per line, one per token). For unified/hast pipelines. */
+declare function generate(parsed: ParsedCode, options?: DisplayOptions): AstElement[];
+/** Render parsed lines to an HTML string. Fast path when no display hooks are set. */
+declare function render(parsed: ParsedCode, options?: DisplayOptions): string;
+
+/**
+ * fractalpop core — the general-purpose lexer and `parse`.
+ *
+ * A single left-to-right scan classifies keyword/string/comment/sign languages.
+ * Complex languages (CSS, Sass, Svelte) supply a `tokenize` override that runs
+ * this plain lexer and then post-processes the token array.
+ */
+
+interface ParseOptions {
+    keywords?: Set<string>;
+    typeKeywords?: Set<string>;
+    onCommentStart?: (curr: string, next: string, index: number, code: string) => number | boolean;
+    onCommentEnd?: (prev: string, curr: string, index: number, code: string, start: number) => number | boolean;
+    onLiteral?: (curr: string, index: number, code: string) => number | null | undefined;
+    onQuote?: (curr: string, index: number, code: string) => number | null | undefined;
+    quotedKeys?: boolean;
+    caseInsensitive?: boolean;
+    templateStrings?: boolean;
+    /** JS runtime: enable JSX tag parsing. */
+    jsx?: boolean;
+    /** JS runtime: enable regex-literal detection. */
+    regex?: boolean;
+    /** JS runtime: force TypeScript keyword set (else heuristic detection). */
+    typescript?: boolean;
+    /** Full tokenize override for complex languages. */
+    tokenize?: (code: string, options: ParseOptions) => Token[];
+    /** Per-line annotation hook (adds classes like `fp__line--<annotation>`). */
+    annotateLine?: (line: ParsedLine) => void;
+}
+/** General lexer. Returns `[numericType, value]` pairs. */
+declare function tokenize(code: string, options?: ParseOptions): Token[];
+/** Tokenize + assemble into lines, running any per-line annotation hook. */
+declare function parse(code: string, options?: ParseOptions): ParsedCode;
+
+export { FractalPop, generate, parse, render, tokenize };
+export type { ParseOptions };

package/dist/core.js

@@ -0,0 +1,313 @@
+/**
+ * fractalpop core — token model, line assembly, and rendering.
+ *
+ * Design: tokens are numeric `[type, value]` pairs during lexing (fast Set/array
+ * work); the string type names are resolved only at render. Output is an HTML
+ * string with no DOM required — so SSR and client produce identical markup.
+ */ /** The stable, ordered token-type list. This list is the theming contract:
+ * each type maps to one CSS variable `--fp-<type>` and one class `fp__token--<type>`. */ const TokenTypes = [
+    'identifier',
+    'keyword',
+    'string',
+    'class',
+    'property',
+    'entity',
+    'jsxliterals',
+    'sign',
+    'comment',
+    'break',
+    'space'
+];
+// Numeric indices, used everywhere in the hot path.
+const T_IDENTIFIER = 0;
+const T_KEYWORD = 1;
+const T_STRING = 2;
+const T_CLASS = 3;
+const T_PROPERTY = 4;
+const T_SIGN = 7;
+const T_COMMENT = 8;
+const T_BREAK = 9;
+const T_SPACE = 10;
+const FractalPop = {
+    TokenTypes,
+    TokenMap: new Map(TokenTypes.map((type, index)=>[
+            type,
+            index
+        ]))
+};
+/** Split a flat token stream into lines, handling embedded newlines. */ function assemble(value, tokens) {
+    const lines = [];
+    let lineIndex = 0;
+    const lineTokens = [];
+    let lastWasBreak = false;
+    function flushLine(tokens) {
+        lines.push({
+            index: lineIndex++,
+            value: tokens.map(([, tokenValue])=>tokenValue).join(''),
+            tokens: tokens.map(([type, tokenValue])=>({
+                    type: TokenTypes[type],
+                    value: tokenValue
+                })),
+            annotations: []
+        });
+    }
+    for(let index = 0; index < tokens.length; index++){
+        const token = tokens[index];
+        const [type, tokenValue] = token;
+        if (type !== T_BREAK) {
+            if (tokenValue.includes('\n')) {
+                const values = tokenValue.split('\n');
+                for(let part = 0; part < values.length; part++){
+                    lineTokens.push([
+                        type,
+                        values[part]
+                    ]);
+                    if (part < values.length - 1) {
+                        flushLine(lineTokens);
+                        lineTokens.length = 0;
+                    }
+                }
+            } else {
+                lineTokens.push(token);
+            }
+            lastWasBreak = false;
+        } else {
+            if (lastWasBreak) {
+                flushLine([]);
+            } else {
+                flushLine(lineTokens);
+                lineTokens.length = 0;
+            }
+            if (index === tokens.length - 1) flushLine([]);
+            lastWasBreak = true;
+        }
+    }
+    if (lineTokens.length) flushLine(lineTokens);
+    return {
+        value,
+        lines
+    };
+}
+function lineClassName(annotations) {
+    return `fp__line${annotations.map((annotation)=>` fp__line--${annotation}`).join('')}`;
+}
+function createLine(parsedLine, markLine) {
+    const line = {
+        index: parsedLine.index,
+        value: parsedLine.value,
+        tokens: parsedLine.tokens,
+        annotations: parsedLine.annotations,
+        className: lineClassName(parsedLine.annotations),
+        style: {},
+        properties: {}
+    };
+    markLine?.(line);
+    return line;
+}
+function createToken({ type, value }, cx, mark) {
+    const extraClassName = cx?.[type];
+    const token = {
+        type,
+        value,
+        className: `fp__token--${type}${extraClassName ? ` ${extraClassName}` : ''}`,
+        style: {
+            color: `var(--fp-${type})`
+        },
+        properties: {}
+    };
+    mark?.(token);
+    return token;
+}
+/** Build a hast-like AST (one element per line, one per token). For unified/hast pipelines. */ function generate(parsed, options) {
+    const cx = options?.cx;
+    const mark = options?.mark;
+    const markLine = options?.markLine;
+    return parsed.lines.map((parsedLine)=>{
+        const line = createLine(parsedLine, markLine);
+        return {
+            type: 'element',
+            tagName: 'span',
+            children: parsedLine.tokens.map((parsedToken)=>{
+                const token = createToken(parsedToken, cx, mark);
+                return {
+                    type: 'element',
+                    tokenType: token.type,
+                    tagName: 'span',
+                    children: [
+                        {
+                            type: 'text',
+                            value: token.value
+                        }
+                    ],
+                    properties: {
+                        ...token.properties,
+                        className: token.className,
+                        style: token.style
+                    }
+                };
+            }),
+            properties: {
+                ...line.properties,
+                className: line.className,
+                style: line.style
+            }
+        };
+    });
+}
+/** Render parsed lines to an HTML string. Fast path when no display hooks are set. */ function render(parsed, options) {
+    const cx = options?.cx;
+    const mark = options?.mark;
+    const markLine = options?.markLine;
+    // Fast path: no per-token object allocation, straight string concat.
+    if (!cx && !mark && !markLine) {
+        return parsed.lines.map((line)=>{
+            const className = lineClassName(line.annotations);
+            const children = line.tokens.map(({ type, value })=>`<span class="fp__token--${type}" style="color:var(--fp-${type})">${encode(value)}</span>`).join('');
+            return `<span class="${encode(className)}">${children}</span>`;
+        }).join('\n');
+    }
+    // Hook path: build mutable objects and run cx/mark/markLine.
+    return parsed.lines.map((parsedLine)=>{
+        const line = createLine(parsedLine, markLine);
+        const children = parsedLine.tokens.map((parsedToken)=>{
+            const token = createToken(parsedToken, cx, mark);
+            return `<span ${attributes({
+                ...token.properties,
+                className: token.className,
+                style: token.style
+            })}>${encode(token.value)}</span>`;
+        }).join('');
+        return `<span ${attributes({
+            ...line.properties,
+            className: line.className,
+            style: line.style
+        })}>${children}</span>`;
+    }).join('\n');
+}
+const entities = {
+    '&': '&amp;',
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    "'": '&#039;'
+};
+const encode = (value)=>value.replace(/[&<>"']/g, (character)=>entities[character]);
+function attributes(values) {
+    const styleValue = values.style ?? {};
+    const style = Object.entries(styleValue).map(([key, value])=>`${key.replace(/[A-Z]/g, (match)=>`-${match.toLowerCase()}`)}:${value}`).join(';');
+    const properties = Object.entries(values).filter(([key, value])=>/^[\w:-]+$/.test(key) && key !== 'className' && key !== 'style' && value !== false && value != null).map(([key, value])=>value === true ? key : `${key}="${encode(String(value))}"`).join(' ');
+    const className = values.className || '';
+    return `class="${encode(className)}"${style ? ` style="${encode(style)}"` : ''}${properties ? ` ${properties}` : ''}`;
+}
+
+const signs = new Set('+-*/%=!&|^~?:.,;()[]{}<>#@\\'.split(''));
+const noComment = ()=>0;
+const isWord = (value)=>value === '_' || value === '$' || /[\p{L}\p{N}]/u.test(value);
+function isQuotedKey(code, index) {
+    while(index < code.length && /\s/.test(code[index]))index++;
+    return code[index] === ':';
+}
+/** General lexer. Returns `[numericType, value]` pairs. */ function tokenize(code, options) {
+    if (typeof options?.tokenize === 'function') return options.tokenize(code, options);
+    const keywords = options?.keywords || new Set();
+    const typeKeywords = options?.typeKeywords || new Set();
+    const onCommentStart = options?.onCommentStart || noComment;
+    const onCommentEnd = options?.onCommentEnd || noComment;
+    const normalize = options?.caseInsensitive ? (value)=>value.toLowerCase() : (value)=>value;
+    const tokens = [];
+    let lastSignificant = '';
+    function append(type, value) {
+        if (!value) return;
+        tokens.push([
+            type,
+            value
+        ]);
+        if (type !== T_SPACE && type !== T_BREAK) lastSignificant = value;
+    }
+    for(let i = 0; i < code.length;){
+        const curr = code[i];
+        const next = code[i + 1] ?? '';
+        const commentType = onCommentStart(curr, next, i, code);
+        if (commentType) {
+            const start = i++;
+            while(i < code.length){
+                if (onCommentEnd(code[i - 1], code[i], i, code, start) == commentType) {
+                    i++;
+                    break;
+                }
+                i++;
+            }
+            append(T_COMMENT, code.slice(start, i));
+            continue;
+        }
+        const literalLength = options?.onLiteral?.(curr, i, code);
+        if (literalLength) {
+            append(T_STRING, code.slice(i, i + literalLength));
+            i += literalLength;
+            continue;
+        }
+        if (typeof options?.onQuote === 'function' && curr === "'") {
+            const length = options.onQuote(curr, i, code);
+            if (typeof length === 'number' && length >= 1) {
+                append(T_IDENTIFIER, code.slice(i, i + length));
+                i += length;
+                continue;
+            }
+        }
+        if (curr === '"' || curr === "'" || options?.templateStrings && curr === '`') {
+            const quote = curr;
+            const start = i++;
+            while(i < code.length){
+                if (code[i] === quote && code[i - 1] !== '\\') {
+                    i++;
+                    break;
+                }
+                i++;
+            }
+            const value = code.slice(start, i);
+            append(options?.quotedKeys && isQuotedKey(code, i) ? T_PROPERTY : T_STRING, value);
+            continue;
+        }
+        if (curr === '\n') {
+            append(T_BREAK, curr);
+            i++;
+            continue;
+        }
+        if (/[^\S\r\n]/.test(curr)) {
+            const start = i++;
+            while(i < code.length && /[^\S\r\n]/.test(code[i]))i++;
+            append(T_SPACE, code.slice(start, i));
+            continue;
+        }
+        if (isWord(curr)) {
+            const start = i++;
+            while(i < code.length && isWord(code[i]))i++;
+            if (/^\d/.test(curr) && code[i] === '.' && /\d/.test(code[i + 1] || '')) {
+                i++;
+                while(i < code.length && isWord(code[i]))i++;
+            }
+            const value = code.slice(start, i);
+            const normalized = normalize(value);
+            const type = typeKeywords.has(normalized) ? T_CLASS : keywords.has(normalized) ? T_KEYWORD : lastSignificant === '.' ? T_PROPERTY : /^\d/.test(value) || value === 'null' || /^\p{Lu}/u.test(value) ? T_CLASS : T_IDENTIFIER;
+            append(type, value);
+            continue;
+        }
+        if (signs.has(curr)) {
+            append(T_SIGN, curr);
+            i++;
+            continue;
+        }
+        append(T_STRING, curr);
+        i++;
+    }
+    return tokens;
+}
+/** Tokenize + assemble into lines, running any per-line annotation hook. */ function parse(code, options) {
+    const parsed = assemble(code, tokenize(code, options));
+    if (options?.annotateLine) {
+        for (const line of parsed.lines)options.annotateLine(line);
+    }
+    return parsed;
+}
+
+export { FractalPop, generate, parse, render, tokenize };

package/dist/full.d.ts

@@ -0,0 +1 @@
+export * from './index.js';