@flighthq/text-markup 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './markupClassStyles';
+export * from './markupNamedColors';
+export * from './markupTagRegistry';
+export * from './textMarkup';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from './markupClassStyles';
+export * from './markupNamedColors';
+export * from './markupTagRegistry';
+export * from './textMarkup';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,cAAc,CAAC"}

package/dist/markupClassStyles.d.ts

@@ -0,0 +1,17 @@
+import type { MarkupTagRegistry, TextFormat } from '@flighthq/types';
+/**
+ * Opts a registry's `<span class>` styling into a caller-provided class → format map — the Tier-1
+ * class-styling path over the standard dialect. `registerStandardMarkupTags` leaves the `classResolver`
+ * seam unset, so a bare `<span class="warn">…</span>` contributes nothing; calling this installs a
+ * resolver that looks each class name up in `styles` (returning null for unknown names), so the span
+ * then contributes `styles.warn`. A `class` naming several space-separated classes merges their formats
+ * left to right. Class names match exactly — CSS classes are case-sensitive.
+ *
+ * The map is the caller's own, so this carries no built-in style table: its weight is only ever what the
+ * caller registers, and a bundle that never calls this keeps `<span>` a no-op grouping element. It is a
+ * distinct export rather than a flag on `registerStandardMarkupTags` for the same reason as
+ * `registerMarkupNamedColors` — the opt-in boundary is what keeps the feature off a bundle that does not
+ * use it. Last-write-wins over any previously installed class resolver.
+ */
+export declare function registerMarkupClassStyles(registry: MarkupTagRegistry, styles: Readonly<Record<string, Readonly<Partial<TextFormat>>>>): void;
+//# sourceMappingURL=markupClassStyles.d.ts.map

package/dist/markupClassStyles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markupClassStyles.d.ts","sourceRoot":"","sources":["../src/markupClassStyles.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAuB,iBAAiB,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE1F;;;;;;;;;;;;;GAaG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,iBAAiB,EAC3B,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,GAC9D,IAAI,CAGN"}

package/dist/markupClassStyles.js

@@ -0,0 +1,19 @@
+/**
+ * Opts a registry's `<span class>` styling into a caller-provided class → format map — the Tier-1
+ * class-styling path over the standard dialect. `registerStandardMarkupTags` leaves the `classResolver`
+ * seam unset, so a bare `<span class="warn">…</span>` contributes nothing; calling this installs a
+ * resolver that looks each class name up in `styles` (returning null for unknown names), so the span
+ * then contributes `styles.warn`. A `class` naming several space-separated classes merges their formats
+ * left to right. Class names match exactly — CSS classes are case-sensitive.
+ *
+ * The map is the caller's own, so this carries no built-in style table: its weight is only ever what the
+ * caller registers, and a bundle that never calls this keeps `<span>` a no-op grouping element. It is a
+ * distinct export rather than a flag on `registerStandardMarkupTags` for the same reason as
+ * `registerMarkupNamedColors` — the opt-in boundary is what keeps the feature off a bundle that does not
+ * use it. Last-write-wins over any previously installed class resolver.
+ */
+export function registerMarkupClassStyles(registry, styles) {
+    const resolver = (className) => styles[className] ?? null;
+    registry.classResolver = resolver;
+}
+//# sourceMappingURL=markupClassStyles.js.map

package/dist/markupClassStyles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"markupClassStyles.js","sourceRoot":"","sources":["../src/markupClassStyles.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,yBAAyB,CACvC,QAA2B,EAC3B,MAA+D;IAE/D,MAAM,QAAQ,GAAwB,CAAC,SAAiB,EAAE,EAAE,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,IAAI,CAAC;IACvF,QAAQ,CAAC,aAAa,GAAG,QAAQ,CAAC;AACpC,CAAC"}

package/dist/markupNamedColors.d.ts

@@ -0,0 +1,17 @@
+import type { MarkupTagRegistry } from '@flighthq/types';
+/**
+ * Opts a registry's `<font color>` into the CSS named-color keywords — the separately-importable half
+ * of the standard dialect. `registerStandardMarkupTags` installs a hex-only color seam; calling this
+ * afterward swaps in a resolver that first tries hex (`#rgb`/`#rrggbb`/`0x`) then the ~148-entry CSS
+ * named-color table, so `<font color="red">` resolves to `#ff0000`. It augments the seam in place and
+ * leaves the `<font>` handler registration untouched, so a custom `<font>` handler that also consults
+ * `registry.colorResolver` keeps its behavior.
+ *
+ * This function is the ONLY importer of the named-color table, which is why the table is tree-shakable:
+ * a bundle that registers the standard tags but never calls `registerMarkupNamedColors` never pulls the
+ * ~148-entry table into its import graph. It is a distinct export rather than a flag on
+ * `registerStandardMarkupTags` on purpose — a flag would import the table unconditionally and defeat
+ * the tree-shaking.
+ */
+export declare function registerMarkupNamedColors(registry: MarkupTagRegistry): void;
+//# sourceMappingURL=markupNamedColors.d.ts.map

package/dist/markupNamedColors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markupNamedColors.d.ts","sourceRoot":"","sources":["../src/markupNamedColors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAIzD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,IAAI,CAE3E"}

package/dist/markupNamedColors.js

@@ -0,0 +1,180 @@
+import { resolveMarkupHexColor } from './markupTagRegistry';
+/**
+ * Opts a registry's `<font color>` into the CSS named-color keywords — the separately-importable half
+ * of the standard dialect. `registerStandardMarkupTags` installs a hex-only color seam; calling this
+ * afterward swaps in a resolver that first tries hex (`#rgb`/`#rrggbb`/`0x`) then the ~148-entry CSS
+ * named-color table, so `<font color="red">` resolves to `#ff0000`. It augments the seam in place and
+ * leaves the `<font>` handler registration untouched, so a custom `<font>` handler that also consults
+ * `registry.colorResolver` keeps its behavior.
+ *
+ * This function is the ONLY importer of the named-color table, which is why the table is tree-shakable:
+ * a bundle that registers the standard tags but never calls `registerMarkupNamedColors` never pulls the
+ * ~148-entry table into its import graph. It is a distinct export rather than a flag on
+ * `registerStandardMarkupTags` on purpose — a flag would import the table unconditionally and defeat
+ * the tree-shaking.
+ */
+export function registerMarkupNamedColors(registry) {
+    registry.colorResolver = resolveMarkupNamedColor;
+}
+// The hex-or-named color resolver installed by `registerMarkupNamedColors`. Hex is tried first (reusing
+// `resolveMarkupHexColor`), then the named-color table — so a `#`/`0x` value never pays a table lookup.
+function resolveMarkupNamedColor(value) {
+    const hex = resolveMarkupHexColor(value);
+    if (hex !== null)
+        return hex;
+    const named = markupNamedColors[value.trim().toLowerCase()];
+    return named === undefined ? null : named;
+}
+// The CSS Color Module Level 4 named-color keywords, packed as 24-bit RGB. Reachable only through
+// `registerMarkupNamedColors`; a bundle that never opts in tree-shakes it out.
+const markupNamedColors = {
+    aliceblue: 0xf0f8ff,
+    antiquewhite: 0xfaebd7,
+    aqua: 0x00ffff,
+    aquamarine: 0x7fffd4,
+    azure: 0xf0ffff,
+    beige: 0xf5f5dc,
+    bisque: 0xffe4c4,
+    black: 0x000000,
+    blanchedalmond: 0xffebcd,
+    blue: 0x0000ff,
+    blueviolet: 0x8a2be2,
+    brown: 0xa52a2a,
+    burlywood: 0xdeb887,
+    cadetblue: 0x5f9ea0,
+    chartreuse: 0x7fff00,
+    chocolate: 0xd2691e,
+    coral: 0xff7f50,
+    cornflowerblue: 0x6495ed,
+    cornsilk: 0xfff8dc,
+    crimson: 0xdc143c,
+    cyan: 0x00ffff,
+    darkblue: 0x00008b,
+    darkcyan: 0x008b8b,
+    darkgoldenrod: 0xb8860b,
+    darkgray: 0xa9a9a9,
+    darkgreen: 0x006400,
+    darkgrey: 0xa9a9a9,
+    darkkhaki: 0xbdb76b,
+    darkmagenta: 0x8b008b,
+    darkolivegreen: 0x556b2f,
+    darkorange: 0xff8c00,
+    darkorchid: 0x9932cc,
+    darkred: 0x8b0000,
+    darksalmon: 0xe9967a,
+    darkseagreen: 0x8fbc8f,
+    darkslateblue: 0x483d8b,
+    darkslategray: 0x2f4f4f,
+    darkslategrey: 0x2f4f4f,
+    darkturquoise: 0x00ced1,
+    darkviolet: 0x9400d3,
+    deeppink: 0xff1493,
+    deepskyblue: 0x00bfff,
+    dimgray: 0x696969,
+    dimgrey: 0x696969,
+    dodgerblue: 0x1e90ff,
+    firebrick: 0xb22222,
+    floralwhite: 0xfffaf0,
+    forestgreen: 0x228b22,
+    fuchsia: 0xff00ff,
+    gainsboro: 0xdcdcdc,
+    ghostwhite: 0xf8f8ff,
+    gold: 0xffd700,
+    goldenrod: 0xdaa520,
+    gray: 0x808080,
+    green: 0x008000,
+    greenyellow: 0xadff2f,
+    grey: 0x808080,
+    honeydew: 0xf0fff0,
+    hotpink: 0xff69b4,
+    indianred: 0xcd5c5c,
+    indigo: 0x4b0082,
+    ivory: 0xfffff0,
+    khaki: 0xf0e68c,
+    lavender: 0xe6e6fa,
+    lavenderblush: 0xfff0f5,
+    lawngreen: 0x7cfc00,
+    lemonchiffon: 0xfffacd,
+    lightblue: 0xadd8e6,
+    lightcoral: 0xf08080,
+    lightcyan: 0xe0ffff,
+    lightgoldenrodyellow: 0xfafad2,
+    lightgray: 0xd3d3d3,
+    lightgreen: 0x90ee90,
+    lightgrey: 0xd3d3d3,
+    lightpink: 0xffb6c1,
+    lightsalmon: 0xffa07a,
+    lightseagreen: 0x20b2aa,
+    lightskyblue: 0x87cefa,
+    lightslategray: 0x778899,
+    lightslategrey: 0x778899,
+    lightsteelblue: 0xb0c4de,
+    lightyellow: 0xffffe0,
+    lime: 0x00ff00,
+    limegreen: 0x32cd32,
+    linen: 0xfaf0e6,
+    magenta: 0xff00ff,
+    maroon: 0x800000,
+    mediumaquamarine: 0x66cdaa,
+    mediumblue: 0x0000cd,
+    mediumorchid: 0xba55d3,
+    mediumpurple: 0x9370db,
+    mediumseagreen: 0x3cb371,
+    mediumslateblue: 0x7b68ee,
+    mediumspringgreen: 0x00fa9a,
+    mediumturquoise: 0x48d1cc,
+    mediumvioletred: 0xc71585,
+    midnightblue: 0x191970,
+    mintcream: 0xf5fffa,
+    mistyrose: 0xffe4e1,
+    moccasin: 0xffe4b5,
+    navajowhite: 0xffdead,
+    navy: 0x000080,
+    oldlace: 0xfdf5e6,
+    olive: 0x808000,
+    olivedrab: 0x6b8e23,
+    orange: 0xffa500,
+    orangered: 0xff4500,
+    orchid: 0xda70d6,
+    palegoldenrod: 0xeee8aa,
+    palegreen: 0x98fb98,
+    paleturquoise: 0xafeeee,
+    palevioletred: 0xdb7093,
+    papayawhip: 0xffefd5,
+    peachpuff: 0xffdab9,
+    peru: 0xcd853f,
+    pink: 0xffc0cb,
+    plum: 0xdda0dd,
+    powderblue: 0xb0e0e6,
+    purple: 0x800080,
+    rebeccapurple: 0x663399,
+    red: 0xff0000,
+    rosybrown: 0xbc8f8f,
+    royalblue: 0x4169e1,
+    saddlebrown: 0x8b4513,
+    salmon: 0xfa8072,
+    sandybrown: 0xf4a460,
+    seagreen: 0x2e8b57,
+    seashell: 0xfff5ee,
+    sienna: 0xa0522d,
+    silver: 0xc0c0c0,
+    skyblue: 0x87ceeb,
+    slateblue: 0x6a5acd,
+    slategray: 0x708090,
+    slategrey: 0x708090,
+    snow: 0xfffafa,
+    springgreen: 0x00ff7f,
+    steelblue: 0x4682b4,
+    tan: 0xd2b48c,
+    teal: 0x008080,
+    thistle: 0xd8bfd8,
+    tomato: 0xff6347,
+    turquoise: 0x40e0d0,
+    violet: 0xee82ee,
+    wheat: 0xf5deb3,
+    white: 0xffffff,
+    whitesmoke: 0xf5f5f5,
+    yellow: 0xffff00,
+    yellowgreen: 0x9acd32,
+};
+//# sourceMappingURL=markupNamedColors.js.map

package/dist/markupNamedColors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"markupNamedColors.js","sourceRoot":"","sources":["../src/markupNamedColors.ts"],"names":[],"mappings":"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"}

package/dist/markupTagRegistry.d.ts

@@ -0,0 +1,41 @@
+import type { MarkupTagHandler, MarkupTagRegistry } from '@flighthq/types';
+/**
+ * Creates an empty markup tag registry — the meaning layer `parseTextMarkup` composes over the parse
+ * layer. Register handlers with `registerMarkupTag`, or populate the standard `htmlText` dialect with
+ * `registerStandardMarkupTags`. The registered set of tag names is the supported dialect; a custom
+ * registry that omits the standard tags lets them tree-shake out.
+ */
+export declare function createMarkupTagRegistry(): MarkupTagRegistry;
+/**
+ * Binds a tag name to its handler. The registry is open and last-write-wins: a user registers their
+ * own (vendor-prefixed) tags or overrides a standard one. The name is matched case-insensitively, so
+ * it is stored lowercased. Handlers are pure — they map this tag's attributes to its contribution and
+ * never see spans, ranges, or surrounding text; the parser owns composition and the format stack.
+ */
+export declare function registerMarkupTag(registry: Readonly<MarkupTagRegistry>, name: string, handler: MarkupTagHandler): void;
+/**
+ * Registers the standard `htmlText` dialect into `registry` — the default bundle `parseTextMarkup`
+ * uses when no registry is passed. Covers `<b>`/`<strong>`, `<i>`/`<em>`, `<u>`, `<s>`/`<strike>`,
+ * `<font color size face>` (color is `#rgb`/`#rrggbb`/`0x` only by default), `<a href target>`,
+ * `<p align>` (implicit line break), `<li type>` (break + bullet), `<br>` (a `\n`), `<span class>`
+ * (a transparent grouping element, styled only once class styles are registered), and `<textformat
+ * leftmargin blockindent indent rightmargin leading tabstops>`. Each handler returns a fresh result,
+ * so registrations share no mutable state.
+ *
+ * The `<font>` handler resolves color through the registry's `colorResolver` seam, which this installs
+ * as the hex-only `resolveMarkupHexColor`. A named color like `red` therefore resolves to no color by
+ * default (graceful, not an error). Call `registerMarkupNamedColors` afterward to opt the ~148-entry
+ * CSS named-color table in; a bundle that never does keeps the table tree-shaken out. The `<span>`
+ * handler consults the registry's `classResolver` seam, left unset here so a bare `<span class>` is
+ * inert; call `registerMarkupClassStyles` to bind a class → format map — the same tree-shakable opt-in
+ * shape as named colors.
+ */
+export declare function registerStandardMarkupTags(registry: MarkupTagRegistry): void;
+/**
+ * Resolves a hex `<font color>` value — `#rgb`, `#rrggbb`, or `0xRRGGBB` — to a packed 24-bit RGB
+ * integer, or null when unrecognized. This is the default color seam `registerStandardMarkupTags`
+ * installs; it imports no named-color table, so the standard dialect stays hex-only until a caller
+ * opts into `registerMarkupNamedColors`. Alpha is not modeled — `TextFormat.color` is opaque RGB.
+ */
+export declare function resolveMarkupHexColor(value: string): number | null;
+//# sourceMappingURL=markupTagRegistry.d.ts.map

package/dist/markupTagRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markupTagRegistry.d.ts","sourceRoot":"","sources":["../src/markupTagRegistry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,gBAAgB,EAChB,iBAAiB,EAIlB,MAAM,iBAAiB,CAAC;AAEzB;;;;;GAKG;AACH,wBAAgB,uBAAuB,IAAI,iBAAiB,CAE3D;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,QAAQ,CAAC,iBAAiB,CAAC,EACrC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,gBAAgB,GACxB,IAAI,CAEN;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,iBAAiB,GAAG,IAAI,CAgB5E;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAgBlE"}

package/dist/markupTagRegistry.js

@@ -0,0 +1,228 @@
+/**
+ * Creates an empty markup tag registry — the meaning layer `parseTextMarkup` composes over the parse
+ * layer. Register handlers with `registerMarkupTag`, or populate the standard `htmlText` dialect with
+ * `registerStandardMarkupTags`. The registered set of tag names is the supported dialect; a custom
+ * registry that omits the standard tags lets them tree-shake out.
+ */
+export function createMarkupTagRegistry() {
+    return { handlers: new Map() };
+}
+/**
+ * Binds a tag name to its handler. The registry is open and last-write-wins: a user registers their
+ * own (vendor-prefixed) tags or overrides a standard one. The name is matched case-insensitively, so
+ * it is stored lowercased. Handlers are pure — they map this tag's attributes to its contribution and
+ * never see spans, ranges, or surrounding text; the parser owns composition and the format stack.
+ */
+export function registerMarkupTag(registry, name, handler) {
+    registry.handlers.set(name.toLowerCase(), handler);
+}
+/**
+ * Registers the standard `htmlText` dialect into `registry` — the default bundle `parseTextMarkup`
+ * uses when no registry is passed. Covers `<b>`/`<strong>`, `<i>`/`<em>`, `<u>`, `<s>`/`<strike>`,
+ * `<font color size face>` (color is `#rgb`/`#rrggbb`/`0x` only by default), `<a href target>`,
+ * `<p align>` (implicit line break), `<li type>` (break + bullet), `<br>` (a `\n`), `<span class>`
+ * (a transparent grouping element, styled only once class styles are registered), and `<textformat
+ * leftmargin blockindent indent rightmargin leading tabstops>`. Each handler returns a fresh result,
+ * so registrations share no mutable state.
+ *
+ * The `<font>` handler resolves color through the registry's `colorResolver` seam, which this installs
+ * as the hex-only `resolveMarkupHexColor`. A named color like `red` therefore resolves to no color by
+ * default (graceful, not an error). Call `registerMarkupNamedColors` afterward to opt the ~148-entry
+ * CSS named-color table in; a bundle that never does keeps the table tree-shaken out. The `<span>`
+ * handler consults the registry's `classResolver` seam, left unset here so a bare `<span class>` is
+ * inert; call `registerMarkupClassStyles` to bind a class → format map — the same tree-shakable opt-in
+ * shape as named colors.
+ */
+export function registerStandardMarkupTags(registry) {
+    registry.colorResolver = resolveMarkupHexColor;
+    registerMarkupTag(registry, 'a', markupAnchorTagHandler);
+    registerMarkupTag(registry, 'b', markupBoldTagHandler);
+    registerMarkupTag(registry, 'br', markupBreakTagHandler);
+    registerMarkupTag(registry, 'em', markupItalicTagHandler);
+    registerMarkupTag(registry, 'font', createMarkupFontTagHandler(registry));
+    registerMarkupTag(registry, 'i', markupItalicTagHandler);
+    registerMarkupTag(registry, 'li', markupListItemTagHandler);
+    registerMarkupTag(registry, 'p', markupParagraphTagHandler);
+    registerMarkupTag(registry, 's', markupStrikethroughTagHandler);
+    registerMarkupTag(registry, 'span', createMarkupSpanTagHandler(registry));
+    registerMarkupTag(registry, 'strike', markupStrikethroughTagHandler);
+    registerMarkupTag(registry, 'strong', markupBoldTagHandler);
+    registerMarkupTag(registry, 'textformat', markupTextformatTagHandler);
+    registerMarkupTag(registry, 'u', markupUnderlineTagHandler);
+}
+/**
+ * Resolves a hex `<font color>` value — `#rgb`, `#rrggbb`, or `0xRRGGBB` — to a packed 24-bit RGB
+ * integer, or null when unrecognized. This is the default color seam `registerStandardMarkupTags`
+ * installs; it imports no named-color table, so the standard dialect stays hex-only until a caller
+ * opts into `registerMarkupNamedColors`. Alpha is not modeled — `TextFormat.color` is opaque RGB.
+ */
+export function resolveMarkupHexColor(value) {
+    const color = value.trim().toLowerCase();
+    if (color.startsWith('#')) {
+        const hex = color.slice(1);
+        if (hex.length === 3) {
+            const parsed = Number.parseInt(`${hex[0]}${hex[0]}${hex[1]}${hex[1]}${hex[2]}${hex[2]}`, 16);
+            return Number.isNaN(parsed) ? null : parsed;
+        }
+        const parsed = Number.parseInt(hex, 16);
+        return Number.isNaN(parsed) ? null : parsed;
+    }
+    if (color.startsWith('0x')) {
+        const parsed = Number.parseInt(color.slice(2), 16);
+        return Number.isNaN(parsed) ? null : parsed;
+    }
+    return null;
+}
+// Builds the `<span>` handler bound to `registry`, so it consults the live `classResolver` seam at
+// parse time — letting `registerMarkupClassStyles` add class styling after registration without
+// re-registering the handler. With no resolver set, or a `class` naming only unknown classes, the span
+// contributes nothing (a transparent grouping element). Space-separated class names in one `class`
+// attribute merge left to right, so a later class overrides an earlier one on a shared field.
+function createMarkupSpanTagHandler(registry) {
+    return (attributes) => {
+        const resolve = registry.classResolver;
+        const classes = attributes.class;
+        if (resolve === undefined || classes === undefined)
+            return {};
+        const format = {};
+        for (const name of classes.split(/\s+/)) {
+            if (name.length === 0)
+                continue;
+            const contribution = resolve(name);
+            if (contribution !== null)
+                Object.assign(format, contribution);
+        }
+        return format;
+    };
+}
+// Builds the `<font>` handler bound to `registry`, so it can consult the live `colorResolver` seam at
+// parse time — letting `registerMarkupNamedColors` widen color support after registration without
+// re-registering the handler. Color parsing goes through the seam only (`resolveMarkupHexColor` when
+// unset), which is what keeps the named-color table off this handler's import graph.
+function createMarkupFontTagHandler(registry) {
+    return (attributes) => {
+        const format = {};
+        const color = attributes.color;
+        if (color !== undefined) {
+            const resolve = registry.colorResolver ?? resolveMarkupHexColor;
+            const parsed = resolve(color);
+            if (parsed !== null)
+                format.color = parsed;
+        }
+        const size = attributes.size;
+        if (size !== undefined) {
+            const parsed = parseMarkupNumber(size);
+            if (parsed !== null)
+                format.size = parsed;
+        }
+        const face = attributes.face ?? attributes.font;
+        if (face !== undefined && face.length > 0)
+            format.font = face;
+        return format;
+    };
+}
+function isMarkupAlign(value) {
+    switch (value.toLowerCase()) {
+        case 'center':
+        case 'end':
+        case 'justify':
+        case 'left':
+        case 'right':
+        case 'start':
+            return true;
+        default:
+            return false;
+    }
+}
+function isMarkupListMarker(value) {
+    switch (value.toLowerCase()) {
+        case 'circle':
+        case 'decimal':
+        case 'disc':
+        case 'none':
+        case 'square':
+            return true;
+        default:
+            return false;
+    }
+}
+function markupAnchorTagHandler(attributes) {
+    const format = {};
+    if (attributes.href !== undefined)
+        format.url = attributes.href;
+    if (attributes.target !== undefined)
+        format.target = attributes.target;
+    return format;
+}
+function markupBoldTagHandler() {
+    return { bold: true };
+}
+function markupBreakTagHandler() {
+    return { text: '\n' };
+}
+function markupItalicTagHandler() {
+    return { italic: true };
+}
+function markupListItemTagHandler(attributes) {
+    const format = { bullet: true };
+    const marker = attributes.type;
+    if (marker !== undefined && isMarkupListMarker(marker))
+        format.listMarker = marker.toLowerCase();
+    return { breakBefore: true, format };
+}
+function markupParagraphTagHandler(attributes) {
+    const format = {};
+    const align = attributes.align;
+    if (align !== undefined && isMarkupAlign(align))
+        format.align = align.toLowerCase();
+    return { breakBefore: true, format };
+}
+function markupStrikethroughTagHandler() {
+    return { strikethrough: true };
+}
+function markupTextformatTagHandler(attributes) {
+    const format = {};
+    const blockIndent = readMarkupNumberAttribute(attributes, 'blockindent');
+    if (blockIndent !== null)
+        format.blockIndent = blockIndent;
+    const indent = readMarkupNumberAttribute(attributes, 'indent');
+    if (indent !== null)
+        format.indent = indent;
+    const leading = readMarkupNumberAttribute(attributes, 'leading');
+    if (leading !== null)
+        format.leading = leading;
+    const leftMargin = readMarkupNumberAttribute(attributes, 'leftmargin');
+    if (leftMargin !== null)
+        format.leftMargin = leftMargin;
+    const rightMargin = readMarkupNumberAttribute(attributes, 'rightmargin');
+    if (rightMargin !== null)
+        format.rightMargin = rightMargin;
+    const tabStops = readMarkupTabStopsAttribute(attributes, 'tabstops');
+    if (tabStops !== null)
+        format.tabStops = tabStops;
+    return format;
+}
+function markupUnderlineTagHandler() {
+    return { underline: true };
+}
+function parseMarkupNumber(value) {
+    const parsed = Number.parseFloat(value);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function readMarkupNumberAttribute(attributes, name) {
+    const raw = attributes[name];
+    return raw === undefined ? null : parseMarkupNumber(raw);
+}
+function readMarkupTabStopsAttribute(attributes, name) {
+    const raw = attributes[name];
+    if (raw === undefined)
+        return null;
+    const stops = [];
+    for (const part of raw.split(',')) {
+        const parsed = parseMarkupNumber(part.trim());
+        if (parsed !== null)
+            stops.push(parsed);
+    }
+    return stops;
+}
+//# sourceMappingURL=markupTagRegistry.js.map

package/dist/markupTagRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"markupTagRegistry.js","sourceRoot":"","sources":["../src/markupTagRegistry.ts"],"names":[],"mappings":"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"}

package/dist/textMarkup.d.ts

@@ -0,0 +1,42 @@
+import type { MarkupTagRegistry, RichTextContent } from '@flighthq/types';
+/**
+ * Serializes a `RichTextContent` back into `htmlText`-subset markup — the inverse of
+ * `parseTextMarkup` for everything the rich-text model can express. The emitted tag set is the fixed
+ * standard dialect that reproduces the `formatRanges`: `<b>`/`<i>`/`<u>`/`<s>` for the style booleans,
+ * `<font color size face>` for color/size/font, `<a href target>` for links, `<p align>` for
+ * alignment, `<li>` for bullets, and `<textformat …>` for the block metrics. Colors always emit as
+ * `#rrggbb` (a named-color source like `red` normalizes to `#ff0000`). Text is escaped (`&` `<` `>`);
+ * attribute values additionally escape `"`.
+ *
+ * The round-trip guarantee is `parseTextMarkup(formatTextMarkup(parseTextMarkup(x)))` equals
+ * `parseTextMarkup(x)` — a fixed point over the modeled tags. `<p>`/`<li>` imply a collapsing line
+ * break before their content; the resulting `\n` carries no block format and re-parses as a plain
+ * newline that the block tag's own collapse rule does not double, so the fixed point holds. Format
+ * fields with no `htmlText` representation (`kerning`, `letterSpacing`) cannot be expressed and are
+ * omitted; `parseTextMarkup` never produces them, so the fixed point is unaffected.
+ */
+export declare function formatTextMarkup(content: Readonly<RichTextContent>): string;
+/**
+ * Parses `htmlText`-style markup into Flight's rich-text model — a plain `text` string plus the
+ * `TextFormatRange[]` a `RichText`/`TextLabel` node renders. This is the explicit, Flight-way
+ * replacement for the `textField.htmlText = "…"` magic property: the caller invokes it and assigns
+ * the result, rather than the runtime silently parsing markup on assignment.
+ *
+ * Parsing is two layers. The parse layer here tokenizes the markup (a lenient, text-node-preserving
+ * pass — not the strict document tree of `@flighthq/xml`) and owns composition: it walks the tags,
+ * maintains a format stack (push a tag's handler contribution on open, pop on close), and emits the
+ * `text` and `TextFormatRange[]`. The meaning layer is the `registry` — an open map of tag name →
+ * handler that decides what each tag contributes. When no `registry` is passed the standard
+ * `htmlText` dialect is used (`registerStandardMarkupTags`), so the default is backward-compatible;
+ * pass a custom registry to add, replace, or narrow the supported tags.
+ *
+ * Nested tags compose — `<font color="#f00"><b>x</b></font>` yields one range carrying both `color`
+ * and `bold`. An unregistered tag keeps its enclosed text but applies no format. Entities
+ * (`&amp; &lt; &gt; &quot; &apos; &#nn; &#xhh;`) decode; unknown named entities are left verbatim.
+ *
+ * Malformed markup is recovered best-effort, never thrown: unclosed tags simply extend to the end of
+ * the text, a stray `<` with no `>` stays literal text, and an extra closing tag is ignored. The
+ * result is always a valid `RichTextContent`.
+ */
+export declare function parseTextMarkup(html: string, registry?: Readonly<MarkupTagRegistry>): RichTextContent;
+//# sourceMappingURL=textMarkup.d.ts.map

package/dist/textMarkup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"textMarkup.d.ts","sourceRoot":"","sources":["../src/textMarkup.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAGV,iBAAiB,EAEjB,eAAe,EAGhB,MAAM,iBAAiB,CAAC;AAIzB;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,QAAQ,CAAC,eAAe,CAAC,GAAG,MAAM,CAe3E;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,QAAQ,CAAC,iBAAiB,CAAC,GAAG,eAAe,CAcrG"}