npm - @flamingo-stack/openframe-frontend-core - Versions diffs - 0.0.498-1506.4000.1 → 0.0.498 - Mend

@flamingo-stack/openframe-frontend-core 0.0.498-1506.4000.1 → 0.0.498

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (290) hide show

package/dist/components/ui/markdown/sanitize.d.ts DELETED Viewed

@@ -1,153 +0,0 @@
-/**
- * Tags the TEXT pre-pass forwards as raw HTML. Anything outside this set
- * (plus per-composition `extraAllowedHtmlTags`) gets its angle brackets
- * escaped and renders as plain text.
- *
- * `video` is deliberately NOT in the baseline: chat strips <video>
- * server-side and playback goes through the <Video> SSOT. The rich
- * composition opts back in via `extraAllowedHtmlTags={['video', 'source']}`
- * so authored content (blog publisher video injection) keeps working.
- */
-export declare const SAFE_HTML_TAGS: Set<string>;
-/**
- * Inline SVG element set, in the CANONICAL case parse5 produces for SVG
- * foreign content (`linearGradient`, `clipPath`, … are camelCase in the
- * HTML parser's SVG adjustment table, so the sanitize schema must match
- * that spelling; the text pre-pass lowercases before lookup).
- *
- * Inline `<svg>` renders in real published posts (hand-authored diagrams
- * and inline icon markup — NOT `<use href>` sprite references, which are
- * deliberately dropped; see SVG_ATTRIBUTES). The Rich renderer had NO pre-pass
- * and NO sanitizer, so it always rendered; without this set the unified
- * engine would escape it to visible source text.
- *
- * SEVERAL OF THESE NAMES ARE ALSO HTML ELEMENTS (`title`, `desc`, `text`,
- * `g`, `line`, `use`, `symbol`, `marker`, `mask`, `pattern`) — admitting
- * them UNCONSTRAINED let a post or a chat message emit a bare `<title>`,
- * which React 19 hoists into `<head>` (browser-tab + SEO title hijack) and
- * whose RAWTEXT content model swallows the rest of the document when
- * unclosed. They are therefore pinned to an `svg` ancestor in
- * `SVG_ONLY_ANCESTORS` below; outside `<svg>` the sanitizer drops them.
- */
-export declare const SVG_TAGS: Set<string>;
-/** Effective pre-pass tag set for a composition (lowercased for lookup). */
-export declare function buildEffectiveTagSet(extraAllowedHtmlTags?: string[]): Set<string>;
-export interface BuildSanitizeSchemaOptions {
-    extraAllowedHtmlTags?: string[];
-}
-/**
- * The engine's sanitize schema: defaultSchema ∪ SAFE_HTML_TAGS ∪ extras.
- * - `extraAllowedHtmlTags` is unioned into tagNames here AND into the
- *   pre-pass set (buildEffectiveTagSet) — the coupled-allowlist invariant.
- * - `clobberPrefix: ''` + empty `clobber`: authored raw-HTML anchors
- *   (`<h2 id="…">`) keep their ids so `[jump](#anchor)` deep-links work.
- *   (The renderer's own heading ids are injected at the React layer,
- *   post-rehype, and were never affected.)
- * - `card`/`mention` protocols registered for href so chat markers survive
- *   (the urlTransform below is the second gate).
- */
-export declare function buildSanitizeSchema(options?: BuildSanitizeSchemaOptions): {
-    tagNames: string[];
-    attributes: Record<string, (string | [string, ...unknown[]])[]>;
-    ancestors: Record<string, string[]>;
-    required: Record<string, Record<string, unknown>>;
-    clobberPrefix: string;
-    clobber: never[];
-    protocols: {
-        href: string[];
-    };
-    allowComments?: boolean | null | undefined;
-    allowDoctypes?: boolean | null | undefined;
-    strip?: Array<string> | null | undefined;
-};
-export declare function rehypeStripUnsafe(): (tree: any) => void;
-/**
- * PARAGRAPH SEGMENTS, NOT LINES (round 18 — SECURITY). A CommonMark code span
- * CROSSES LINE BREAKS: `` `foo\n</textarea>` `` is one `inlineCode` node, so
- * that `</textarea>` is a code sample and not a closer — yet this scan (and
- * `PROTECTED_SPAN_RE`, whose body class is `[^\n]`) was strictly PER LINE, so
- * the mask never saw the span, the closer stayed visible in the haystack,
- * `hasLaterCloser` returned true, and a prose `<textarea>` above it stayed LIVE
- * (`escapeUnknownHtmlTags` returned the input BYTE-IDENTICAL; the renderer
- * emitted `<code>foo </textarea></code>` — proving the closer is a code sample
- * — beside a live textarea swallowing the prose). This is the shape that is not
- * a CONTAINER at all, so no container sweep could ever have reached it.
- *
- * A code span CANNOT cross a paragraph break, so the scan unit is a maximal run
- * of non-blank lines. Blank lines still terminate a segment, which keeps the
- * fail-CLOSED direction (an unterminated opener consumes at most its own
- * paragraph, never the rest of the document) and keeps the bound linear — the
- * `suffMax` / cursor structure is unchanged, `\n` is simply an ordinary
- * character inside a segment.
- *
- * `PROTECTED_SPAN_RE` (the CARVE) is deliberately left per-line: it rounds the
- * other way, so at worst a multi-line code sample renders as escaped text.
- */
-declare function findInlineCodeRanges(source: string): Array<[number, number]>;
-/** Exported for the differential fuzz against the retired regex. */
-export declare const __findInlineCodeRangesForTest: typeof findInlineCodeRanges;
-/**
- * Build the haystack `hasLaterCloser` searches: a LENGTH-PRESERVING lowercased
- * copy of the document with every region that cannot contain a REAL closing
- * tag blanked to spaces.
- *
- * Why this exists: the escaping pass carefully carves code out, but the
- * closer search used to run over the RAW document. So a `</textarea>` sitting
- * inside a code fence, an inline-code span, or another tag's attribute string
- * satisfied "is closed later", the prose opener was left LIVE, and parse5's
- * RAWTEXT span swallowed the rest of the message anyway — the whole fix was
- * one code sample away from being bypassed, which is exactly what an LLM
- * answer about HTML looks like.
- *
- * Masking (rather than deleting) keeps every index identical to the original
- * string, so the caller's offset arithmetic is unchanged. THE LENGTH
- * INVARIANT IS LOAD-BEARING — see `foldAsciiCase`.
- *
- * CARVE DECISION (deliberate, do not "unify"): these tracker-derived regions
- * are NOT fed to the escaping carve, even though that would stop an authored
- * EOF-terminated fence body from rendering as literal `&lt;their&gt;`.
- *
- * The genuine asymmetry is the EOF-TERMINATED fence, and only that one. The
- * tracker protects an unclosed opener all the way to end of input, so a single
- * stray ``` line — mid-stream, or inside an open raw-HTML block where a ```
- * line is content rather than a fence — would carve the ENTIRE remainder of the
- * document out of the escaping pass. `PROTECTED_SPAN_RE` protects nothing at
- * all there (it only recognizes a fence CLOSED by a same-marker run), so its
- * failure mode is bounded: a code sample renders as escaped text. In the carve
- * an over-detected region is a region that is NOT escaped — a fail-OPEN, i.e.
- * exactly the swallow this module exists to prevent — so the materially larger
- * fail-open surface decides it.
- *
- * SHARED over-detection (e.g. a ``` line inside an HTML block — `<div>`,
- * `<pre>`, `<details>` — where CommonMark says the line is HTML content, not a
- * fence) was previously dismissed here as "not an argument either way". THAT
- * WAS WRONG: it is precisely the residual fail-open. The intersection guard
- * below only reconciles DISAGREEMENT, so when BOTH engines open the same bogus
- * fence the guard is a no-op and a live `<textarea>` inside it is pushed
- * verbatim, swallowing the rest of the message (reproduced for all three tags).
- * What actually closes it is the CARVE BALANCE GUARD in
- * `escapeUnknownHtmlTags`: a protected span may contain no UNBALANCED RAWTEXT
- * opener. Neither engine needs to learn about HTML blocks for that to hold.
- *
- * What makes keeping two engines SAFE is therefore the pair of guards in
- * `escapeUnknownHtmlTags`: a carve span the mask did not blank is escaped
- * rather than pushed through verbatim, and a span carrying an unbalanced
- * RAWTEXT opener is escaped even when both engines agree. Over-detection can
- * then only cost cosmetics. Before the first guard the regex's info-string-tolerant
- * closer let it desync and open a span from a line CommonMark treats as
- * ordinary text, sheltering a live `<textarea>` from escaping entirely
- * (`mismatched-fence-carve-does-not-shelter-opener`). The remaining tradeoff is
- * pinned by `unclosed-fence-body-renders-escaped` rather than left as prose.
- */
-declare function buildCloserHaystack(text: string): string;
-/** Exported for the length-preservation invariant test only. */
-export declare const __buildCloserHaystackForTest: typeof buildCloserHaystack;
-export declare function escapeUnknownHtmlTags(text: string, allowedTags?: Set<string>): string;
-/**
- * Extends react-markdown's default safe-protocol allowlist with the two
- * internal schemes the chat remark plugins emit (`card://`, `mention://`),
- * for `href` ONLY. All other URLs go through `defaultUrlTransform`.
- */
-export declare function cardAwareUrlTransform(url: string, key: string): string;
-export {};
-//# sourceMappingURL=sanitize.d.ts.map

package/dist/components/ui/markdown/sanitize.d.ts.map DELETED Viewed

@@ -1 +0,0 @@

- {"version":3,"file":"sanitize.d.ts","sourceRoot":"","sources":["../../../../src/components/ui/markdown/sanitize.ts"],"names":[],"mappings":"AA4CA;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,aAqBzB,CAAA;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,QAAQ,aAKnB,CAAA;AAqDF,4EAA4E;AAC5E,wBAAgB,oBAAoB,CAAC,oBAAoB,CAAC,EAAE,MAAM,EAAE,GAAG,GAAG,CAAC,MAAM,CAAC,CAEjF;AAkGD,MAAM,WAAW,0BAA0B;IACzC,oBAAoB,CAAC,EAAE,MAAM,EAAE,CAAA;CAChC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,GAAE,0BAA+B;;;;;;;;;;;;;EAgG3E;AA2DD,wBAAgB,iBAAiB,KAEvB,MAAM,GAAG,UA6ElB;AA+HD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,iBAAS,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CA6ErE;AAED,oEAAoE;AACpE,eAAO,MAAM,6BAA6B,6BAAuB,CAAA;AA6/DjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,iBAAS,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CA0DjD;AAED,gEAAgE;AAChE,eAAO,MAAM,4BAA4B,4BAAsB,CAAA;AAkgB/D,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,EACZ,WAAW,GAAE,GAAG,CAAC,MAAM,CAAkB,GACxC,MAAM,CAgGR;AAoED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAItE"}

package/dist/components/ui/markdown/simple-markdown-renderer.d.ts DELETED Viewed

@@ -1,23 +0,0 @@
-/**
- * SimpleMarkdownRenderer — the chat/doc composition over the unified
- * `MarkdownEngine`. This IS the real component (not a compat alias): the
- * old 966-line standalone implementation was deleted in the unification;
- * its entire prop surface maps 1:1 onto the engine. Chat consumers keep
- * layering `additionalRemarkPlugins` (card/mention links) and
- * `componentOverrides` exactly as before.
- */
-import React from 'react';
-import { type MarkdownEngineProps } from './engine';
-import type { ResolveLinkResult } from '../../../types/doc-source';
-export type { ResolveLinkResult };
-export interface SimpleMarkdownRendererProps extends Omit<MarkdownEngineProps, 'extraAllowedHtmlTags'> {
-}
-/**
- * A type-narrowed ALIAS of the engine, not a wrapper: the composition adds
- * no behavior (it only hides `extraAllowedHtmlTags` from the prop surface),
- * and `MarkdownEngine` is already `memo`'d. Wrapping it in a second `memo`
- * bought nothing and cost an extra shallow-compare pass plus a fiber per
- * chat segment.
- */
-export declare const SimpleMarkdownRenderer: React.NamedExoticComponent<SimpleMarkdownRendererProps>;
-//# sourceMappingURL=simple-markdown-renderer.d.ts.map

package/dist/components/ui/markdown/simple-markdown-renderer.d.ts.map DELETED Viewed

@@ -1 +0,0 @@

- {"version":3,"file":"simple-markdown-renderer.d.ts","sourceRoot":"","sources":["../../../../src/components/ui/markdown/simple-markdown-renderer.tsx"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,EAAkB,KAAK,mBAAmB,EAAE,MAAM,UAAU,CAAC;AACpE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAEnE,YAAY,EAAE,iBAAiB,EAAE,CAAC;AAElC,MAAM,WAAW,2BACf,SAAQ,IAAI,CAAC,mBAAmB,EAAE,sBAAsB,CAAC;CAAG;AAE9D;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,EACf,KAAK,CAAC,oBAAoB,CAAC,2BAA2B,CAAC,CAAC"}

package/dist/components/ui/markdown/streaming.d.ts DELETED Viewed

@@ -1,78 +0,0 @@
-/**
- * Streaming helpers for the unified markdown engine (pure, no React).
- *
- * Design contract (unification plan §D1 "Streaming rendering performance"):
- * - Markdown is NOT context-free across blocks. The splitter only cuts at
- *   boundaries it can PROVE are atomic; when atomicity is unprovable the
- *   content is left in one unit (unmemoized) — correctness beats cache hits.
- * - Blocks containing `card://` / `mention://` markers are never memoized:
- *   their text is identical before/after the entity ref resolves, so a
- *   text-keyed cache would serve the stale unresolved card mid-stream.
- * - On stream completion the engine discards all of this and does ONE
- *   authoritative whole-document parse — streaming can never permanently
- *   diverge (late reference defs, footnotes, list renumbering self-heal).
- * - Tail completion auto-closes ONLY unterminated fenced code blocks
- *   (fence-count based — unambiguous). Inline emphasis/links are NOT
- *   auto-closed: a stray `*` in "2 * 3" or a non-link `[` would be
- *   mis-wrapped, which is worse than the brief flicker it prevents.
- */
-export interface StreamingBlock {
-    /** Raw markdown source of this unit (including trailing blank lines). */
-    text: string;
-    /** Position index — cache key component so identical blocks never alias. */
-    index: number;
-    /**
-     * 1-based line of this unit's first line WITHIN the whole document.
-     * Each unit is parsed by its own `ReactMarkdown`, so hast positions are
-     * unit-relative; the engine adds `startLine - 1` back to look ids up in
-     * the document-wide heading-id map (see ./heading-ids.ts).
-     */
-    startLine: number;
-    /**
-     * True when this unit may be render-cached: it is complete (not the
-     * trailing unit), atomic, and free of cross-block / late-resolving
-     * constructs (card/mention markers, reference definitions/uses,
-     * footnotes).
-     */
-    memoizable: boolean;
-}
-/**
- * Split streaming markdown into atomic units at blank lines that are
- * provably block boundaries. A blank line does NOT split when:
- *  - inside a fenced code block,
- *  - the next non-blank line is indented (loose-list / blockquote
- *    continuation cannot be ruled out),
- *  - the next non-blank line starts a list item or blockquote AND the
- *    previous unit ended in a list item or blockquote (loose list /
- *    multi-paragraph quote continuation).
- * The FINAL unit is always the live tail (never memoizable).
- *
- * BLANK LINES COME FROM `isBlankLine` (utils/markdown-fences), never from
- * `String.prototype.trim()`. This file is the THIRD consumer of that module
- * (it already instantiates `createFenceTracker`) and makes exactly the
- * CommonMark blank-line decision the helper was minted for, yet it kept four
- * hand-rolled `trim() === ''` tests — so the module's "every blank-line test"
- * SSOT claim was false here. `trim()` strips the full Unicode White_Space set
- * (U+00A0 NBSP, U+000B VT, U+000C FF, U+FEFF BOM), none of which CommonMark
- * treats as blank: `splitStreamingBlocks('foo\n<NBSP>\nbar\n\ntail')` returned
- * THREE units where the non-blank filler control (`foo\nx\nbar\n\ntail`)
- * returns TWO — one NBSP line cut a paragraph into two `ReactMarkdown` units on
- * the STREAMING path, rendering two `<p>` where the non-streaming and SEO twins
- * render one. Not a security hole (the fence tracker and `htmlBlocksCut` still
- * gate the cut), but a live divergence. It survived because the swallow sweep
- * drove only `SimpleMarkdownRenderer`; the sweep now drives this splitter too,
- * in both the exotic-blank and CRLF spellings.
- */
-export declare function splitStreamingBlocks(content: string): StreamingBlock[];
-/**
- * Auto-close an unterminated fenced code block at the streaming tail so the
- * half-open fence doesn't flip the rest of the message into code while
- * tokens arrive.
- *
- * Uses the SAME scanner as `splitStreamingBlocks` (never a parallel
- * fence-count heuristic — a naive count treats ``` and ~~~ as
- * interchangeable and appends a spurious closer to `` ```\n~~~\n``` ``),
- * and appends the RECORDED opener so a `~~~` block is closed with `~~~`.
- */
-export declare function completeStreamingTail(content: string): string;
-//# sourceMappingURL=streaming.d.ts.map

package/dist/components/ui/markdown/streaming.d.ts.map DELETED Viewed

@@ -1 +0,0 @@

- {"version":3,"file":"streaming.d.ts","sourceRoot":"","sources":["../../../../src/components/ui/markdown/streaming.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH,MAAM,WAAW,cAAc;IAC7B,yEAAyE;IACzE,IAAI,EAAE,MAAM,CAAA;IACZ,4EAA4E;IAC5E,KAAK,EAAE,MAAM,CAAA;IACb;;;;;OAKG;IACH,SAAS,EAAE,MAAM,CAAA;IACjB;;;;;OAKG;IACH,UAAU,EAAE,OAAO,CAAA;CACpB;AA2LD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,cAAc,EAAE,CAoHtE;AAED;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAO7D"}

package/dist/components/ui/markdown/text-size.d.ts DELETED Viewed

@@ -1,34 +0,0 @@
-/**
- * Text-size presets for the unified markdown engine.
- *
- * `default` / `compact` / `large` are carried over verbatim from the old
- * `SimpleMarkdownRenderer`. `article` is NEW — it reproduces the exact
- * typography the old `RichMarkdownRenderer` hardcoded per element, so
- * content surfaces (blog, case studies, releases, legal, docs) keep
- * byte-identical classes through the unification.
- *
- * ODS-TOKENS FLAG (ODS_TOKEN_RULES §Typography / §General): the `article`
- * preset carries raw px classes (`text-[32px] md:text-[40px] …`) because
- * ODS currently has NO composite tokens for long-form prose — `text-h1`/
- * `text-h2` are Azeret Mono UI-label scale and `text-h5` is uppercase,
- * so mapping prose headings onto them would visibly regress articles.
- * The `code` entry of EVERY preset (`text-[13px]` / `text-[14px]` /
- * `text-[16px]`), not just `article`'s, is raw px for the same reason: ODS
- * has no code/mono type scale. `base-components.tsx` carries the matching
- * flag for inline code's `text-[0.9em]` (the mono FAMILY is no longer an
- * exemption — both code surfaces now use `font-mono`).
- * Per the unification plan, the missing prose- and code-typography tokens
- * are FLAGGED here for addition to ODS; the raw-px carry-over is the
- * documented, review-gated exemption recorded in the unification PR.
- * Do NOT copy these px classes anywhere else.
- */
-export type TextSizeElement = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'p' | 'li' | 'blockquote' | 'code' | 'th' | 'td';
-export type TextSizeClassMap = Partial<Record<TextSizeElement, string>>;
-export type TextSizePreset = 'default' | 'compact' | 'large' | 'article';
-export type TextSizeConfig = TextSizePreset | TextSizeClassMap | {
-    preset: TextSizePreset;
-    overrides: TextSizeClassMap;
-};
-export declare const TEXT_SIZE_PRESETS: Record<TextSizePreset, Record<TextSizeElement, string>>;
-export declare function resolveTextSizeConfig(config?: TextSizeConfig): Record<TextSizeElement, string>;
-//# sourceMappingURL=text-size.d.ts.map

package/dist/components/ui/markdown/text-size.d.ts.map DELETED Viewed

@@ -1 +0,0 @@

- {"version":3,"file":"text-size.d.ts","sourceRoot":"","sources":["../../../../src/components/ui/markdown/text-size.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,MAAM,MAAM,eAAe,GACvB,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GACvC,GAAG,GAAG,IAAI,GAAG,YAAY,GAAG,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC;AAErD,MAAM,MAAM,gBAAgB,GAAG,OAAO,CAAC,MAAM,CAAC,eAAe,EAAE,MAAM,CAAC,CAAC,CAAC;AACxE,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,CAAC;AACzE,MAAM,MAAM,cAAc,GACtB,cAAc,GACd,gBAAgB,GAChB;IAAE,MAAM,EAAE,cAAc,CAAC;IAAC,SAAS,EAAE,gBAAgB,CAAA;CAAE,CAAC;AAE5D,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,cAAc,EAAE,MAAM,CAAC,eAAe,EAAE,MAAM,CAAC,CA6DrF,CAAC;AAEF,wBAAgB,qBAAqB,CAAC,MAAM,CAAC,EAAE,cAAc,GAAG,MAAM,CAAC,eAAe,EAAE,MAAM,CAAC,CAM9F"}

package/dist/utils/markdown-fences.d.ts DELETED Viewed

@@ -1,42 +0,0 @@
-/**
- * Fenced-code tracker — THE definition of "am I inside a code fence".
- * Server-safe: no React, no DOM.
- *
- * Lives in its own module because it is a GENERAL CommonMark fence machine
- * with two unrelated consumers: the heading scanner
- * (`utils/markdown-heading-id`) and the streaming block splitter
- * (`components/ui/markdown/streaming`). It used to live inside
- * `markdown-heading-id`, which meant a streaming renderer imported its fence
- * state machine from a module named after heading slugs. `markdown-heading-id`
- * re-exports these names so the public `utils` surface is unchanged.
- */
-/** True when `line` is a CommonMark blank line (spaces/tabs only, `\r`-tolerant). */
-export declare function isBlankLine(line: string): boolean;
-/**
- * What one source line is, relative to fenced code:
- *  - `open`  — this line opened a fence
- *  - `close` — this line closed the open fence
- *  - `inside`— this line is fence content (including a would-be delimiter that
- *              does NOT close the open fence: wrong marker char, too short, or
- *              carrying an info string)
- *  - `text`  — this line is ordinary markdown outside any fence
- *
- * NOTE: no consumer discriminates the three non-`text` roles today — both the
- * heading scanner and the streaming splitter only test `!== 'text'`, and the
- * closer-haystack mask below only tests `=== 'open'` / `=== 'close'`. The
- * four-value union is kept because the state machine already computes the
- * distinction for free and a future consumer (e.g. fence-aware syntax
- * post-processing) would otherwise have to re-derive it.
- */
-export type FenceLineRole = 'open' | 'close' | 'inside' | 'text';
-export interface FenceTracker {
-    /** Advance across one raw source line (mutates) and classify it. */
-    push(line: string): FenceLineRole;
-    /** Marker CHARACTER of the currently open fence (`` ` `` / `~`), or null. */
-    openChar(): string | null;
-    /** Run length of the currently open fence (a closer must be ≥ this). */
-    openLength(): number;
-}
-/** A fresh fenced-code state machine. Server-safe: no React, no DOM. */
-export declare function createFenceTracker(): FenceTracker;
-//# sourceMappingURL=markdown-fences.d.ts.map

package/dist/utils/markdown-fences.d.ts.map DELETED Viewed

@@ -1 +0,0 @@

- {"version":3,"file":"markdown-fences.d.ts","sourceRoot":"","sources":["../../src/utils/markdown-fences.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAoDH,qFAAqF;AACrF,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEjD;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAA;AAEhE,MAAM,WAAW,YAAY;IAC3B,oEAAoE;IACpE,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,CAAA;IACjC,6EAA6E;IAC7E,QAAQ,IAAI,MAAM,GAAG,IAAI,CAAA;IACzB,wEAAwE;IACxE,UAAU,IAAI,MAAM,CAAA;CACrB;AAED,wEAAwE;AACxE,wBAAgB,kBAAkB,IAAI,YAAY,CA8BjD"}

package/dist/utils/markdown-heading-id.d.ts DELETED Viewed

@@ -1,85 +0,0 @@
-/**
- * Markdown heading-id slug SSOT (server-safe: no React, no DOM).
- *
- * This algorithm previously existed in THREE byte-identical copies:
- *   - `components/ui/simple-markdown-renderer.tsx` (generateHeadingId)
- *   - `components/ui/rich-markdown-renderer.tsx` (generateHeadingId)
- *   - `utils/markdown-section-extractor.ts` (extractSections)
- *
- * The extractor is the PRODUCER of `sectionIds` and the renderers are the
- * CONSUMERS — if the two ever drift, deep-link anchors and scroll-spy
- * targets silently diverge. All three now call these helpers; the parity
- * test `components/ui/__tests__/markdown-parity.test.tsx` asserts
- * extractor-vs-renderer ID agreement over the fixture corpus.
- */
-/** Emoji ranges stripped from heading text before slugification. */
-export declare const HEADING_EMOJI_RE: RegExp;
-/** Remove emoji characters and trim. */
-export declare function stripHeadingEmojis(text: string): string;
-/**
- * Core slug chain WITHOUT the emoji strip (the extractor exposes emoji
- * stripping as an option, so the two steps are kept separable):
- * lowercase → drop non-word/space/hyphen chars → spaces to hyphens →
- * trim leading/trailing hyphens. May return `''` for symbol-only input —
- * callers apply their own fallback (`section-N`).
- */
-export declare function slugifyHeadingBase(text: string): string;
-/** The full default chain used by the renderers: emoji strip + slugify. */
-export declare function slugifyHeadingText(text: string): string;
-/**
- * Sharing the slug chain alone was not enough. The PRODUCER
- * (`utils/markdown-section-extractor`) and the CONSUMER
- * (`components/ui/markdown/heading-ids`) each carried their own copy of
- * "which lines are headings" and "how do duplicates get suffixed", and the
- * copies drifted:
- *   - the extractor toggled its code-block state on a bare
- *     `line.startsWith('```')`, so a `~~~`-fenced (or wider-backtick, or
- *     indented) block containing `## Setup` produced a SECTION from the
- *     extractor and NO id from the renderer — `sectionIdMap` then missed
- *     silently and the deep-link anchor pointed nowhere;
- *   - the extractor anchored ATX at column 0 while the renderer allowed the
- *     CommonMark 0..3-space indent;
- *   - the dedupe counter was hand-copied in both files, each with a comment
- *     saying "the two must agree".
- * Both now call `scanHeadings` + `createHeadingIdDeduper`. Server-safe: no
- * React, no DOM.
- */
-export { createFenceTracker, isBlankLine, type FenceTracker, type FenceLineRole, } from './markdown-fences';
-/** A heading the renderer will emit, located in the source. */
-export interface ScannedHeading {
-    /** 1-based line of the heading's FIRST line (setext: the title line). */
-    line: number;
-    level: number;
-    /** Raw title text, before `stripInlineMarkdown` / slugification. */
-    text: string;
-}
-export interface ScanHeadingsOptions {
-    /**
-     * Skip a leading YAML frontmatter block (`---` on line 1 through the next
-     * `---`). Only a DOCUMENT-LEADING block counts: a bare `---` mid-document
-     * is a thematic break or a setext underline, and treating it as a
-     * frontmatter toggle (what the extractor used to do) silently swallowed
-     * every heading until the next one.
-     */
-    skipFrontmatter?: boolean;
-    /** Include raw-HTML headings (`<h2>Title</h2>`). Default true. */
-    includeRawHtml?: boolean;
-    /**
-     * Skip fenced-code blocks. Default true — a `##` inside a code fence is
-     * code, not a heading, and the renderer emits no id for it.
-     */
-    skipFences?: boolean;
-}
-/**
- * Collect every heading the markdown renderer will emit, in document order.
- * THE single definition of "which lines are headings" for both the extractor
- * and the renderer's id map.
- */
-export declare function scanHeadings(content: string, options?: ScanHeadingsOptions): ScannedHeading[];
-/**
- * The duplicate-id suffix counter, as ONE closure both sides instantiate.
- * First occurrence keeps the bare slug; the Nth gets `-N`. Extractor and
- * renderer MUST use the same counter or `#anchor` deep links diverge.
- */
-export declare function createHeadingIdDeduper(): (cleanId: string) => string;
-//# sourceMappingURL=markdown-heading-id.d.ts.map

package/dist/utils/markdown-heading-id.d.ts.map DELETED Viewed

@@ -1 +0,0 @@

- {"version":3,"file":"markdown-heading-id.d.ts","sourceRoot":"","sources":["../../src/utils/markdown-heading-id.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,oEAAoE;AACpE,eAAO,MAAM,gBAAgB,QACsC,CAAA;AAEnE,wCAAwC;AACxC,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAOvD;AAED,2EAA2E;AAC3E,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEvD;AAKD;;;;;;;;;;;;;;;;;GAiBG;AAMH,OAAO,EACL,kBAAkB,EAClB,WAAW,EACX,KAAK,YAAY,EACjB,KAAK,aAAa,GACnB,MAAM,mBAAmB,CAAA;AAG1B,+DAA+D;AAC/D,MAAM,WAAW,cAAc;IAC7B,yEAAyE;IACzE,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,oEAAoE;IACpE,IAAI,EAAE,MAAM,CAAA;CACb;AAED,MAAM,WAAW,mBAAmB;IAClC;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,kEAAkE;IAClE,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAA;CACrB;AAkHD;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,mBAAwB,GAChC,cAAc,EAAE,CAwGlB;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,IAAI,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,CAUpE"}