@cbcruk/highlight-kit 0.1.0 → 0.2.0

package/dist/core-DDCXN2b_.d.ts

@@ -0,0 +1,527 @@
+//#region src/tokenize.d.ts
+/**
+ * Pure tokenizer: a string plus an ordered rule list in, character spans out.
+ *
+ * Nothing here touches the DOM, the `CSS.highlights` registry, or the
+ * `OpaqueRange` API, so the overlap rules — the part that is easy to get wrong —
+ * are testable without a browser. {@link ./value-range.ts} turns the spans this
+ * produces into live ranges inside an `<input>` or `<textarea>`.
+ */
+/** One pattern and the highlight name its matches are registered under. */
+interface TokenRule {
+  /** CSS `::highlight()` name for this rule's matches. Rules may share a name. */
+  name: string;
+  /**
+   * Text or expression to match. A `RegExp` keeps its own flags, so
+   * `caseSensitive` and `wholeWord` are ignored for one.
+   */
+  pattern: string | RegExp;
+  /**
+   * Case sensitive match. Ignored for `RegExp` patterns.
+   * @default false
+   */
+  caseSensitive?: boolean;
+  /**
+   * Match whole words only (wraps the pattern in `\b`). Ignored for `RegExp`
+   * patterns.
+   * @default false
+   */
+  wholeWord?: boolean;
+  /**
+   * Stacking order of this rule's highlight name against other names. When
+   * several rules share a name the highest value wins.
+   * @default 0
+   */
+  priority?: number;
+}
+/** One match: a half-open character span `[start, end)` and its rule. */
+interface Token {
+  /** The matching rule's highlight name. */
+  readonly name: string;
+  /** Start offset, in UTF-16 code units into the tokenized string. */
+  readonly start: number;
+  /** End offset, exclusive. */
+  readonly end: number;
+  /** Index of the rule in the rule list that produced this token. */
+  readonly rule: number;
+}
+/** How matches covering the same characters are resolved. */
+type OverlapStrategy = 'first' | 'all';
+/** Options for {@link tokenizeValue}. */
+interface TokenizeOptions {
+  /**
+   * How matches covering the same characters resolve.
+   *
+   * - `'first'` — scan left to right. At each position the earliest rule in the
+   *   list that matches *there* wins, and the scan jumps past its match, so a
+   *   comment rule swallows keywords inside the comment. Tokens never overlap.
+   * - `'all'` — every rule scans the whole string independently and every match
+   *   is emitted, overlaps included. Layering is left to `priority`.
+   *
+   * @default 'first'
+   */
+  overlap?: OverlapStrategy;
+}
+/** The spans of one highlight name, ready to hand to a controller. */
+interface NamedSpans {
+  /** CSS `::highlight()` name. */
+  name: string;
+  /** Highest `priority` among the rules that contributed to this name. */
+  priority: number;
+  /** Half-open `[start, end)` character spans, in the order tokenized. */
+  spans: ReadonlyArray<{
+    start: number;
+    end: number;
+  }>;
+}
+/**
+ * Match `rules` against `value` and return the character spans of every match.
+ *
+ * Offsets are UTF-16 code unit indices into `value`, the same units
+ * `selectionStart` uses, so they can be handed straight to
+ * `createValueRange()` when `value` came from `element.value`.
+ *
+ * Rule order is precedence: see {@link TokenizeOptions.overlap}.
+ *
+ * @param value - Text to scan, typically `element.value`
+ * @param rules - Ordered rules; earlier rules win under `'first'`
+ * @returns Tokens sorted by start offset. Empty when `value` or `rules` is empty
+ *
+ * @example A comment rule swallowing keywords inside it
+ * ```ts
+ * import { tokenizeValue } from '@cbcruk/highlight-kit'
+ *
+ * tokenizeValue('// return 1', [
+ *   { name: 'comment', pattern: /\/\/.*$/m },
+ *   { name: 'keyword', pattern: /\breturn\b/ },
+ * ])
+ * // [{ name: 'comment', start: 0, end: 11, rule: 0 }]
+ * ```
+ *
+ * @example Independent patterns, overlaps kept
+ * ```ts
+ * import { tokenizeValue } from '@cbcruk/highlight-kit'
+ *
+ * tokenizeValue('status:open', [
+ *   { name: 'field', pattern: /\w+:/ },
+ *   { name: 'all', pattern: /\w+/ },
+ * ], { overlap: 'all' })
+ * ```
+ */
+declare function tokenizeValue(value: string, rules: readonly TokenRule[], options?: TokenizeOptions): Token[];
+/**
+ * Collapse tokens into one entry per highlight name.
+ *
+ * Several rules may share a name; the resulting `priority` is the highest one
+ * any contributing rule declared, since a controller tracks a single priority
+ * per name.
+ *
+ * @param tokens - Tokens from {@link tokenizeValue}
+ * @param rules - The same rule list those tokens were produced from
+ * @returns One entry per name that matched at least once, in first-match order
+ */
+declare function groupTokens(tokens: readonly Token[], rules: readonly TokenRule[]): NamedSpans[];
+//#endregion
+//#region src/value-range.d.ts
+/** Form controls that can expose ranges over their value. */
+type ValueRangeElement = HTMLInputElement | HTMLTextAreaElement;
+/**
+ * A live range over a form control's value — the `OpaqueRange` returned by
+ * `createValueRange()`.
+ *
+ * Offsets are UTF-16 code unit indices into `element.value`, the same units as
+ * `selectionStart`/`selectionEnd`, and they shift as the value is edited.
+ *
+ * This is deliberately *not* typed as an `AbstractRange`. Shipping this API
+ * moved `startContainer`/`endContainer` off `AbstractRange` onto a new
+ * `NodeRange` interface, and on a value range both read `undefined`. Declaring
+ * them as `Node` would be a lie, so they are absent here: use
+ * {@link ValueRange.getBoundingClientRect} for geometry and `element.value` for
+ * text. There is also no `toString()` and no constructor.
+ */
+interface ValueRange {
+  /** Whether the range is empty. A collapsed range is never painted. */
+  readonly collapsed: boolean;
+  /** Start offset into the control's value, in UTF-16 code units. */
+  readonly startOffset: number;
+  /** End offset into the control's value, exclusive. */
+  readonly endOffset: number;
+  /** Client rects of the range, one per line box it covers. */
+  getClientRects(): DOMRectList;
+  /** Bounding box of the range. Empty once the range is disconnected. */
+  getBoundingClientRect(): DOMRect;
+  /**
+   * Stop tracking edits and collapse to offset 0, releasing the control's
+   * reference to this range.
+   *
+   * Optional because it ships in Chromium but is absent from the spec pull
+   * requests, so another engine may implement `OpaqueRange` without it.
+   */
+  disconnect?(): void;
+}
+/**
+ * Whether this browser implements `createValueRange()`.
+ *
+ * True only says the *engine* supports the API. It does not say a given element
+ * does — the method exists on `HTMLInputElement.prototype` for every input
+ * type and throws at call time for unsupported ones. Use
+ * {@link supportsValueRange} for a specific element.
+ */
+declare function isValueRangeSupported(): boolean;
+/**
+ * Whether `element` can produce value ranges: a `<textarea>`, or an `<input>`
+ * whose `type` is `text`, `search`, `tel`, `url`, or `password`.
+ *
+ * @param element - Element to test; `null`/`undefined` returns false
+ */
+declare function supportsValueRange(element: Element | null | undefined): element is ValueRangeElement;
+/**
+ * Narrow a highlight range to a value range.
+ *
+ * Tests for "not a DOM `Range`", so it also answers whether reading
+ * `startContainer` is safe — on a value range it is `undefined`.
+ */
+declare function isValueRange(range: HighlightRange): range is ValueRange;
+/**
+ * Create live ranges over `element`'s value for each of `spans`.
+ *
+ * Offsets are clamped into `[0, element.value.length]` rather than throwing the
+ * `IndexSizeError` the API raises for out-of-range offsets, and spans that
+ * clamp to nothing are dropped — a collapsed range is never painted.
+ *
+ * Every returned range holds a reference from `element` until
+ * {@link disconnectValueRanges} releases it.
+ *
+ * @param element - A control {@link supportsValueRange} accepts
+ * @param spans - Half-open `[start, end)` character spans
+ * @returns One range per non-empty span. Empty when the element is unsupported
+ *
+ * @example
+ * ```ts
+ * import { createValueRanges, highlights } from '@cbcruk/highlight-kit'
+ *
+ * const textarea = document.querySelector('textarea')!
+ * const ranges = createValueRanges(textarea, [{ start: 0, end: 5 }])
+ * highlights.set('note', 'my-source', ranges)
+ * ```
+ */
+declare function createValueRanges(element: ValueRangeElement, spans: ReadonlyArray<{
+  start: number;
+  end: number;
+}>): ValueRange[];
+/**
+ * Release `ranges` so their control stops tracking them.
+ *
+ * Safe to call twice, and on ranges already auto-disconnected by the element
+ * being removed or its `type` changing.
+ */
+declare function disconnectValueRanges(ranges: Iterable<ValueRange>): void;
+/** Options shared by {@link createValueRangeRegistry} and its wrappers. */
+interface ValueRangeBindingOptions {
+  /** The control whose value the ranges point into. */
+  element: ValueRangeElement;
+  /** Controller the ranges are registered with. @default the shared singleton */
+  controller?: HighlightController;
+  /** This binding's identity within each highlight name. @default a fresh symbol */
+  sourceId?: SourceId;
+}
+/**
+ * Owns one generation of value ranges on a control and swaps it atomically.
+ *
+ * This is the piece that makes repeated re-matching safe. A control retains
+ * every range `createValueRange()` returned and shifts all of their offsets on
+ * each edit, so re-registering without releasing the ranges from the previous
+ * pass leaves a growing pile of live ranges behind — invisible, because
+ * `Highlight` no longer holds them, but still updated on every keystroke.
+ * {@link ValueRangeRegistry.commit} disconnects the outgoing generation for you.
+ */
+interface ValueRangeRegistry {
+  /** Whether the element can actually produce value ranges. */
+  readonly supported: boolean;
+  /** Highlight names this registry currently has ranges registered under. */
+  readonly names: readonly string[];
+  /**
+   * Replace everything this registry owns with ranges for `groups`.
+   *
+   * Names the registry held but `groups` omits are unregistered. The outgoing
+   * ranges are disconnected only after the new ones are committed, so the
+   * highlight never blanks for a frame.
+   */
+  commit(groups: readonly NamedSpans[]): void;
+  /** Unregister every name and disconnect every range this registry created. */
+  dispose(): void;
+}
+/**
+ * Create a registry that keeps one generation of value ranges on `element`.
+ *
+ * Use it when you compute spans yourself; {@link createValueHighlighter} layers
+ * the tokenizer and an `input` listener on top.
+ *
+ * @example Marking a single span and replacing it later
+ * ```ts
+ * import { createValueRangeRegistry } from '@cbcruk/highlight-kit'
+ *
+ * const registry = createValueRangeRegistry({ element: textarea })
+ * registry.commit([{ name: 'note', priority: 0, spans: [{ start: 0, end: 4 }] }])
+ * registry.commit([{ name: 'note', priority: 0, spans: [{ start: 6, end: 9 }] }])
+ * registry.dispose()
+ * ```
+ */
+declare function createValueRangeRegistry({ element, controller, sourceId }: ValueRangeBindingOptions): ValueRangeRegistry;
+/** Options for {@link createValueHighlighter}. */
+interface ValueHighlighterOptions extends ValueRangeBindingOptions {
+  /** Ordered token rules. Earlier rules win; see {@link TokenRule}. */
+  rules: readonly TokenRule[];
+  /**
+   * How matches covering the same characters resolve.
+   * @default 'first'
+   */
+  overlap?: OverlapStrategy;
+  /**
+   * Re-tokenize on the element's own `input` events. Turn off to drive
+   * {@link ValueHighlighter.refresh} yourself.
+   * @default true
+   */
+  observe?: boolean;
+}
+/** A running tokenizer bound to one form control. */
+interface ValueHighlighter {
+  /** Whether the element can actually produce value ranges. */
+  readonly supported: boolean;
+  /** Highlight names that currently have at least one match. */
+  readonly names: readonly string[];
+  /**
+   * Re-tokenize the element's current value and re-register.
+   *
+   * Call this after assigning `element.value` programmatically: a whole-value
+   * assignment collapses every live range to offset 0 and fires no `input`
+   * event, so nothing else would notice.
+   */
+  refresh(): void;
+  /** Unregister every name and disconnect every range this highlighter created. */
+  dispose(): void;
+}
+/**
+ * Keep a form control's value tokenized and highlighted.
+ *
+ * Tokenizes once on creation and then on every `input` event, registering one
+ * highlight name per rule name and releasing the previous generation of ranges.
+ *
+ * Does nothing when the browser or the element is unsupported, so calling it
+ * unconditionally is safe — read {@link ValueHighlighter.supported} to decide
+ * whether to render a fallback.
+ *
+ * @example Search-query syntax in a text input
+ * ```ts
+ * import {
+ *   createValueHighlighter,
+ *   injectHighlightStyles,
+ * } from '@cbcruk/highlight-kit'
+ *
+ * injectHighlightStyles({
+ *   field: { color: '#2563eb' },
+ *   quoted: { backgroundColor: '#dbeafe' },
+ * })
+ *
+ * const input = document.querySelector('input')!
+ * const highlighter = createValueHighlighter({
+ *   element: input,
+ *   rules: [
+ *     { name: 'quoted', pattern: /"[^"]*"/ },
+ *     { name: 'field', pattern: /\b\w+:/ },
+ *   ],
+ * })
+ *
+ * highlighter.dispose()
+ * ```
+ */
+declare function createValueHighlighter({ rules, overlap, observe, ...binding }: ValueHighlighterOptions): ValueHighlighter;
+/**
+ * Scroll `element` just far enough for `range` to be visible inside it.
+ *
+ * `scrollIntoView()` is not an option: a value range has no node to call it on.
+ * This adjusts the control's own `scrollTop`/`scrollLeft` from the range's
+ * client rect, and unlike `setSelectionRange()` it leaves the user's selection
+ * and focus alone.
+ *
+ * No-op for a collapsed or disconnected range, whose rect is empty.
+ */
+declare function scrollValueRangeIntoView(element: ValueRangeElement, range: ValueRange): void;
+//#endregion
+//#region src/core.d.ts
+/**
+ * Either kind of range a highlight can hold.
+ *
+ * `Highlight` is setlike over `AbstractRange`, so DOM ranges and value ranges
+ * may share one highlight name. Only a value range lacks
+ * `startContainer`/`endContainer`; narrow with `isValueRange` before reading
+ * them.
+ */
+type HighlightRange = Range | ValueRange;
+/** Options controlling how a string pattern is matched against text. */
+interface MatchOptions {
+  /**
+   * Case sensitive match. Ignored for `RegExp` patterns, which keep their own flags.
+   * @default false
+   */
+  caseSensitive?: boolean;
+  /**
+   * Match whole words only (wraps the pattern in `\b`). Ignored for `RegExp` patterns.
+   * @default false
+   */
+  wholeWord?: boolean;
+}
+/** Reactive state of one highlight name, as exposed to subscribers. */
+interface HighlightSnapshot {
+  /** Whether this name currently has any registered ranges */
+  readonly active: boolean;
+  /** Number of ranges registered under this name */
+  readonly count: number;
+}
+/** A source contributing ranges, keyed by a unique id (e.g. React's useId) */
+type SourceId = string | symbol;
+/**
+ * Where reconciled ranges are written. The controller's bookkeeping always
+ * runs; only this side effect is swappable (CSS registry, no-op for tests/SSR).
+ */
+interface HighlightSink {
+  /** Replace the registered highlight for `name` with `ranges`. */
+  commit(name: string, ranges: HighlightRange[], priority: number): void;
+  /** Drop the registered highlight for `name`. */
+  remove(name: string): void;
+  /**
+   * When this returns false the controller skips bookkeeping entirely, so
+   * snapshots stay empty. Omit it to always track ranges.
+   */
+  isSupported?(): boolean;
+}
+/** Options for {@link createHighlightController}. */
+interface HighlightControllerOptions {
+  /** Where reconciled ranges are written. Defaults to {@link createCssHighlightSink}. */
+  sink?: HighlightSink;
+}
+/** Whether the CSS Custom Highlight API (`CSS.highlights` and `Highlight`) is available. */
+declare function isHighlightSupported(): boolean;
+/**
+ * Collect the text nodes under an element that contain non-whitespace text.
+ *
+ * Whitespace-only nodes (newlines, indentation between elements) are skipped,
+ * so this is suited to pattern matching, not to offset math against `textContent`.
+ */
+declare function getTextNodes(root: Node): Text[];
+/**
+ * Compute Range objects for every match of `pattern` within `root`.
+ * Pure: returns ranges, does not touch the registry.
+ */
+declare function computeRanges(root: Element, pattern: string | RegExp, options?: MatchOptions): Range[];
+/**
+ * Map flat character offsets onto Range objects. Useful when you already know positions.
+ *
+ * Offsets count over `root.textContent`, whitespace-only text nodes (newlines,
+ * indentation between elements) included, so positions computed from
+ * `textContent` or on a server against the same text line up. Unlike
+ * {@link computeRanges}, a span may cross text node boundaries; it yields one
+ * range per text node it touches. Out-of-bounds parts are ignored.
+ *
+ * @example
+ * ```ts
+ * import { rangesFromOffsets } from '@cbcruk/highlight-kit'
+ *
+ * const el = document.querySelector('#article')!
+ * const start = el.textContent!.indexOf('wisdom')
+ * rangesFromOffsets(el, [{ start, end: start + 'wisdom'.length }])
+ * ```
+ */
+declare function rangesFromOffsets(root: Element, spans: ReadonlyArray<{
+  start: number;
+  end: number;
+}>): Range[];
+/** Sink that writes to the document-global `CSS.highlights` registry. */
+declare function createCssHighlightSink(): HighlightSink;
+/** Side-effect-free sink: bookkeeping still runs, nothing is painted. */
+declare function createNoopSink(): HighlightSink;
+/**
+ * Tracks ranges per highlight name and source, and writes their union to a sink.
+ *
+ * Multiple sources may contribute to one name; each change reconciles the name
+ * into a single highlight and notifies `subscribe` listeners. Create instances
+ * with {@link createHighlightController} or use the shared {@link highlights}.
+ *
+ * @example
+ * ```ts
+ * import { computeRanges, highlights } from '@cbcruk/highlight-kit'
+ *
+ * const el = document.querySelector('#article')!
+ * highlights.set('search', 'my-source', computeRanges(el, 'wisdom'))
+ * highlights.getSnapshot('search') // { active: true, count: ... }
+ * highlights.remove('search', 'my-source')
+ * ```
+ */
+declare class HighlightController {
+  #private;
+  /** Create a controller that writes to `sink` (the CSS registry sink by default). */
+  constructor({ sink }?: HighlightControllerOptions);
+  /**
+   * Whether the sink reports support. `true` when the sink has no `isSupported`.
+   * When `false`, {@link HighlightController.set} is a no-op.
+   */
+  get supported(): boolean;
+  /** useSyncExternalStore: stable identity (arrow field on the instance). */
+  subscribe: (listener: () => void) => (() => void);
+  /** Snapshot for a given highlight name (referentially stable). */
+  getSnapshot: (name: string) => HighlightSnapshot;
+  /** Snapshots of every active name (referentially stable between changes). */
+  getSnapshots: () => Readonly<Record<string, HighlightSnapshot>>;
+  /** SSR / unsupported: constant empty snapshot. */
+  getServerSnapshot: () => HighlightSnapshot;
+  /** SSR / unsupported: constant empty record. */
+  getServerSnapshots: () => Readonly<Record<string, HighlightSnapshot>>;
+  /** Union of every source's ranges currently registered under `name`. */
+  getRanges(name: string): HighlightRange[];
+  /**
+   * Register/replace a source's ranges under a name, then reconcile.
+   * `priority` applies to the whole name; the most recent call wins.
+   */
+  set(name: string, sourceId: SourceId, ranges: HighlightRange[], priority?: number): void;
+  /** Remove a single source's contribution to a name. */
+  remove(name: string, sourceId: SourceId): void;
+  /** Drop a name entirely, regardless of sources. */
+  clear(name: string): void;
+  /** Drop everything this controller manages. */
+  clearAll(): void;
+}
+/**
+ * Create an isolated controller. Useful for tests (with {@link createNoopSink})
+ * or for scoping subscriptions via the React `HighlightProvider`. Highlight
+ * *names* are still document-global once painted by a CSS sink.
+ */
+declare function createHighlightController(options?: HighlightControllerOptions): HighlightController;
+/** The shared singleton. */
+declare const highlights: HighlightController;
+/**
+ * Build `::highlight(name)` CSS rules from a style map without injecting them.
+ *
+ * camelCase property names are converted to kebab-case; values are written as is.
+ *
+ * @example
+ * ```ts
+ * import { generateHighlightCSS } from '@cbcruk/highlight-kit'
+ *
+ * generateHighlightCSS({ search: { backgroundColor: 'yellow' } })
+ * // '::highlight(search) {\n  background-color: yellow;\n}'
+ * ```
+ */
+declare function generateHighlightCSS(styles: Record<string, Partial<CSSStyleDeclaration>>): string;
+/**
+ * Append a `<style>` element with `::highlight()` rules to `document.head`.
+ *
+ * An existing element with the same `id` is removed first, so calling it again
+ * replaces the previous rules.
+ *
+ * @param styles - Style declarations keyed by highlight name
+ * @param id - `id` of the `<style>` element
+ * @returns The inserted `<style>` element
+ */
+declare function injectHighlightStyles(styles: Record<string, Partial<CSSStyleDeclaration>>, id?: string): HTMLStyleElement;
+//#endregion
+export { scrollValueRangeIntoView as A, ValueRangeRegistry as C, disconnectValueRanges as D, createValueRanges as E, TokenRule as F, TokenizeOptions as I, groupTokens as L, NamedSpans as M, OverlapStrategy as N, isValueRange as O, Token as P, tokenizeValue as R, ValueRangeElement as S, createValueRangeRegistry as T, rangesFromOffsets as _, HighlightSnapshot as a, ValueRange as b, computeRanges as c, createNoopSink as d, generateHighlightCSS as f, isHighlightSupported as g, injectHighlightStyles as h, HighlightSink as i, supportsValueRange as j, isValueRangeSupported as k, createCssHighlightSink as l, highlights as m, HighlightControllerOptions as n, MatchOptions as o, getTextNodes as p, HighlightRange as r, SourceId as s, HighlightController as t, createHighlightController as u, ValueHighlighter as v, createValueHighlighter as w, ValueRangeBindingOptions as x, ValueHighlighterOptions as y };

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-import { a as MatchOptions, c as createCssHighlightSink, d as generateHighlightCSS, f as getTextNodes, g as rangesFromOffsets, h as isHighlightSupported, i as HighlightSnapshot, l as createHighlightController, m as injectHighlightStyles, n as HighlightControllerOptions, o as SourceId, p as highlights, r as HighlightSink, s as computeRanges, t as HighlightController, u as createNoopSink } from "./core-B8g04jvB.js";
-export { type HighlightController, HighlightControllerOptions, HighlightSink, HighlightSnapshot, MatchOptions, SourceId, computeRanges, createCssHighlightSink, createHighlightController, createNoopSink, generateHighlightCSS, getTextNodes, highlights, injectHighlightStyles, isHighlightSupported, rangesFromOffsets };
+import { A as scrollValueRangeIntoView, C as ValueRangeRegistry, D as disconnectValueRanges, E as createValueRanges, F as TokenRule, I as TokenizeOptions, L as groupTokens, M as NamedSpans, N as OverlapStrategy, O as isValueRange, P as Token, R as tokenizeValue, S as ValueRangeElement, T as createValueRangeRegistry, _ as rangesFromOffsets, a as HighlightSnapshot, b as ValueRange, c as computeRanges, d as createNoopSink, f as generateHighlightCSS, g as isHighlightSupported, h as injectHighlightStyles, i as HighlightSink, j as supportsValueRange, k as isValueRangeSupported, l as createCssHighlightSink, m as highlights, n as HighlightControllerOptions, o as MatchOptions, p as getTextNodes, r as HighlightRange, s as SourceId, t as HighlightController, u as createHighlightController, v as ValueHighlighter, w as createValueHighlighter, x as ValueRangeBindingOptions, y as ValueHighlighterOptions } from "./core-DDCXN2b_.js";
+export { type HighlightController, HighlightControllerOptions, HighlightRange, HighlightSink, HighlightSnapshot, MatchOptions, NamedSpans, OverlapStrategy, SourceId, Token, TokenRule, TokenizeOptions, ValueHighlighter, ValueHighlighterOptions, ValueRange, ValueRangeBindingOptions, ValueRangeElement, ValueRangeRegistry, computeRanges, createCssHighlightSink, createHighlightController, createNoopSink, createValueHighlighter, createValueRangeRegistry, createValueRanges, disconnectValueRanges, generateHighlightCSS, getTextNodes, groupTokens, highlights, injectHighlightStyles, isHighlightSupported, isValueRange, isValueRangeSupported, rangesFromOffsets, scrollValueRangeIntoView, supportsValueRange, tokenizeValue };

package/dist/index.js

@@ -1,2 +1,2 @@
-import { a as generateHighlightCSS, c as injectHighlightStyles, i as createNoopSink, l as isHighlightSupported, n as createCssHighlightSink, o as getTextNodes, r as createHighlightController, s as highlights, t as computeRanges, u as rangesFromOffsets } from "./core-LUnH63zG.js";
-export { computeRanges, createCssHighlightSink, createHighlightController, createNoopSink, generateHighlightCSS, getTextNodes, highlights, injectHighlightStyles, isHighlightSupported, rangesFromOffsets };
+import { _ as highlights, a as isValueRange, b as rangesFromOffsets, c as supportsValueRange, d as computeRanges, f as createCssHighlightSink, g as getTextNodes, h as generateHighlightCSS, i as disconnectValueRanges, l as groupTokens, m as createNoopSink, n as createValueRangeRegistry, o as isValueRangeSupported, p as createHighlightController, r as createValueRanges, s as scrollValueRangeIntoView, t as createValueHighlighter, u as tokenizeValue, v as injectHighlightStyles, y as isHighlightSupported } from "./value-range-CH2vegQi.js";
+export { computeRanges, createCssHighlightSink, createHighlightController, createNoopSink, createValueHighlighter, createValueRangeRegistry, createValueRanges, disconnectValueRanges, generateHighlightCSS, getTextNodes, groupTokens, highlights, injectHighlightStyles, isHighlightSupported, isValueRange, isValueRangeSupported, rangesFromOffsets, scrollValueRangeIntoView, supportsValueRange, tokenizeValue };