prompt-area 0.1.0

package/dist/helpers/index.d.ts

@@ -0,0 +1,374 @@
+/**
+ * PromptArea component types
+ *
+ * A lightweight contentEditable-based text input that supports:
+ * - Trigger characters (/, @, #) that activate handlers
+ * - Immutable chips for resolved mentions/commands
+ * - Configurable trigger behavior (dropdown vs callback)
+ * - Simple inline markdown rendering
+ */
+/**
+ * A segment of content within the editable text.
+ * The document model is an ordered array of these segments.
+ */
+type TextSegment = {
+    type: 'text';
+    text: string;
+};
+type ChipSegment = {
+    type: 'chip';
+    /** The trigger character that created this chip (e.g., '@', '#') */
+    trigger: string;
+    /** The resolved value/ID (e.g., user ID, file ID) */
+    value: string;
+    /** The display text shown in the chip */
+    displayText: string;
+    /** Optional data payload attached to the chip */
+    data?: unknown;
+    /**
+     * True when this chip was auto-created by pressing space (resolveOnSpace).
+     * Backspace on an auto-resolved chip reverts it to plain text instead of deleting.
+     */
+    autoResolved?: boolean;
+};
+type Segment = TextSegment | ChipSegment;
+/**
+ * Determines where a trigger character is valid.
+ * - 'start': Only valid at the very start of input or after a newline (e.g., slash commands)
+ * - 'any': Valid after any whitespace boundary (e.g., @mentions)
+ */
+type TriggerPosition = 'start' | 'any';
+/**
+ * Defines how a trigger behaves when activated.
+ * - 'dropdown': Shows a popover with suggestions from `onSearch`
+ * - 'callback': Fires `onActivate` immediately without a dropdown
+ */
+type TriggerMode = 'dropdown' | 'callback';
+/**
+ * Visual style for rendered chips.
+ * - 'pill': Button-like pill with background color, padding, border-radius (default)
+ * - 'inline': Bold inline text that flows naturally with surrounding content
+ */
+type ChipStyle = 'pill' | 'inline';
+/**
+ * A suggestion item shown in the trigger dropdown.
+ */
+type TriggerSuggestion = {
+    /** Unique value/ID for this suggestion */
+    value: string;
+    /** Display label shown in the dropdown */
+    label: string;
+    /** Optional description shown below the label */
+    description?: string;
+    /** Optional icon element rendered before the label */
+    icon?: React.ReactNode;
+    /** Optional arbitrary data passed through on selection */
+    data?: unknown;
+};
+/**
+ * Configuration for a trigger character.
+ */
+type TriggerConfig = {
+    /** The trigger character (e.g., '/', '@', '#') */
+    char: string;
+    /** Where this trigger is valid */
+    position: TriggerPosition;
+    /** How this trigger behaves */
+    mode: TriggerMode;
+    /**
+     * For 'dropdown' mode: called with the current query to fetch suggestions.
+     * Should return a list of suggestions to display.
+     *
+     * Receives an options object with an `AbortSignal` that is aborted when a
+     * newer search supersedes this one. Pass it to `fetch()` or other async
+     * APIs to cancel in-flight work automatically.
+     */
+    onSearch?: (query: string, options: {
+        signal: AbortSignal;
+    }) => TriggerSuggestion[] | Promise<TriggerSuggestion[]>;
+    /**
+     * For 'dropdown' mode: called when a suggestion is selected.
+     * Return the display text for the chip, or void to use `suggestion.label`.
+     */
+    onSelect?: (suggestion: TriggerSuggestion) => string | void;
+    /**
+     * For 'callback' mode: called when the trigger is activated.
+     * Receives the full input text and cursor position.
+     */
+    onActivate?: (context: TriggerActivateContext) => void;
+    /**
+     * When true, pressing space while this trigger is active (with a non-empty query)
+     * auto-resolves the typed text into a chip without selecting from the dropdown.
+     * The auto-resolved chip can be reverted to plain text with backspace.
+     * Useful for free-form tags (e.g., #hashtag).
+     */
+    resolveOnSpace?: boolean;
+    /**
+     * Visual style for chips created by this trigger.
+     * - 'pill' (default): Button-like pill with background, padding, border-radius
+     * - 'inline': Bold inline text without pill styling
+     */
+    chipStyle?: ChipStyle;
+    /** CSS class name(s) applied to chips created by this trigger */
+    chipClassName?: string;
+    /** Label used for accessibility (e.g., "mention", "command") */
+    accessibilityLabel?: string;
+    /**
+     * Debounce delay in milliseconds before calling `onSearch`.
+     * Defaults to 0 (immediate). The initial empty-query search always fires
+     * immediately regardless of this setting so the dropdown appears instantly.
+     */
+    searchDebounceMs?: number;
+    /**
+     * Called when `onSearch` rejects or throws (non-abort errors only).
+     * Use this to log errors or show toast notifications.
+     */
+    onSearchError?: (error: unknown) => void;
+    /**
+     * Message shown in the dropdown when `onSearch` returns an empty array.
+     * If omitted, the popover hides when there are no results (current behavior).
+     */
+    emptyMessage?: string;
+};
+/**
+ * Context passed to callback-mode trigger handlers.
+ */
+type TriggerActivateContext = {
+    /** The full plain text content at the time of activation */
+    text: string;
+    /** The cursor offset position */
+    cursorPosition: number;
+    /** Function to insert a chip at the current cursor position */
+    insertChip: (chip: Omit<ChipSegment, 'type'>) => void;
+};
+/**
+ * Represents an active trigger being typed by the user.
+ */
+type ActiveTrigger = {
+    /** The trigger config that was activated */
+    config: TriggerConfig;
+    /** Position (character offset) where the trigger character was typed */
+    startOffset: number;
+    /** The text typed after the trigger character so far */
+    query: string;
+};
+/**
+ * An image attachment displayed in the prompt area.
+ * State is managed externally by the parent component.
+ */
+type PromptAreaImage = {
+    /** Unique identifier for this image */
+    id: string;
+    /** URL to display (CDN URL or temporary blob URL for preview) */
+    url: string;
+    /** Optional alt text for accessibility */
+    alt?: string;
+    /** When true, shows a loading indicator over the thumbnail */
+    loading?: boolean;
+};
+/**
+ * A file attachment displayed in the prompt area.
+ * State is managed externally by the parent component.
+ */
+type PromptAreaFile = {
+    /** Unique identifier for this file */
+    id: string;
+    /** Display filename (e.g., "report.pdf") */
+    name: string;
+    /** File size in bytes */
+    size?: number;
+    /** MIME type (used for icon selection, e.g., "application/pdf") */
+    type?: string;
+    /** When true, shows a loading indicator over the file card */
+    loading?: boolean;
+};
+
+/**
+ * Pure logic engine for the PromptArea component.
+ * No DOM dependencies - fully testable in Node.
+ */
+
+/**
+ * Converts an array of segments to a plain text string.
+ * Chips are represented as `{trigger}{displayText}` (e.g., "@Alice").
+ */
+declare function segmentsToPlainText(segments: Segment[]): string;
+/**
+ * Converts plain text into a single text segment.
+ * Used for initial value conversion from plain strings.
+ */
+declare function plainTextToSegments(text: string): Segment[];
+/**
+ * Checks whether a trigger character at the given position in text
+ * is valid according to the position rule.
+ *
+ * @param text - The full text content
+ * @param charIndex - The index of the trigger character in the text
+ * @param position - The position rule to validate against
+ */
+declare function isValidTriggerPosition(text: string, charIndex: number, position: TriggerPosition): boolean;
+/**
+ * Scans backwards from the cursor position to detect if the user is
+ * currently typing a trigger word.
+ *
+ * Returns the active trigger info, or null if no trigger is active.
+ *
+ * @param text - The full plain text content
+ * @param cursorPos - The cursor position (character offset from start)
+ * @param triggers - Available trigger configurations
+ */
+declare function detectActiveTrigger(text: string, cursorPos: number, triggers: TriggerConfig[]): ActiveTrigger | null;
+/**
+ * Resolves an active trigger into a chip within the segments array.
+ * Replaces the trigger text (trigger char + query) with a chip segment.
+ *
+ * @param segments - Current document segments
+ * @param activeTrigger - The active trigger to resolve
+ * @param chip - The chip data (value, displayText, optional data)
+ * @returns New segments array with the chip inserted, and the new cursor position
+ */
+declare function resolveChip(segments: Segment[], activeTrigger: ActiveTrigger, chip: {
+    value: string;
+    displayText: string;
+    data?: unknown;
+    autoResolved?: boolean;
+}): {
+    segments: Segment[];
+    cursorOffset: number;
+};
+/**
+ * Scans text segments for trigger patterns and auto-resolves them into chips.
+ * Only resolves triggers that have `resolveOnSpace: true`.
+ *
+ * Trigger patterns must appear at word boundaries: start of text, after
+ * whitespace, or after a newline. This avoids false positives like email
+ * addresses (user@example.com).
+ */
+declare function resolveTriggersInSegments(segments: Segment[], triggers: TriggerConfig[]): Segment[];
+type MarkdownToken = {
+    type: 'plain';
+    text: string;
+} | {
+    type: 'bold';
+    text: string;
+} | {
+    type: 'italic';
+    text: string;
+} | {
+    type: 'bold-italic';
+    text: string;
+} | {
+    type: 'url';
+    text: string;
+};
+/**
+ * Parses text for simple inline markdown: bold, italic, bold-italic, and URLs.
+ * Does NOT handle block-level markdown (lists, headings, etc.).
+ */
+declare function parseInlineMarkdown(text: string): MarkdownToken[];
+/**
+ * Shallow equality check for two segment arrays.
+ * Compares type, text, trigger, value, displayText, and autoResolved fields.
+ * Avoids JSON.stringify overhead for the common case.
+ */
+declare function segmentsEqual(a: Segment[], b: Segment[]): boolean;
+/**
+ * Merges adjacent text segments into single text segments.
+ * Also removes empty text segments.
+ */
+declare function mergeAdjacentTextSegments(segments: Segment[]): Segment[];
+
+/**
+ * Convenience helpers for creating and inspecting Segments.
+ *
+ * These reduce boilerplate when building AI chat UIs that work with the
+ * PromptArea document model.
+ *
+ * @example
+ * ```ts
+ * import { text, chip, isSegmentsEmpty, segmentsToPlainText } from './segment-helpers'
+ *
+ * const greeting = [text('Hello '), chip({ trigger: '@', value: 'u1', displayText: 'Alice' })]
+ * isSegmentsEmpty(greeting) // false
+ * segmentsToPlainText(greeting) // "Hello @Alice"
+ * ```
+ */
+
+/** Create a text segment. */
+declare function text(value: string): TextSegment;
+/** Create a chip segment. */
+declare function chip(opts: Omit<ChipSegment, 'type'>): ChipSegment;
+/** Returns `true` when the segment array is empty or contains only whitespace text. */
+declare function isSegmentsEmpty(segments: Segment[]): boolean;
+/** Returns `true` when the segment array contains at least one chip. */
+declare function hasChips(segments: Segment[]): boolean;
+/** Extracts all chip segments from a segment array. */
+declare function getChips(segments: Segment[]): ChipSegment[];
+/** Extracts chips matching a specific trigger character. */
+declare function getChipsByTrigger(segments: Segment[], trigger: string): ChipSegment[];
+
+/**
+ * Pre-built trigger configuration factories for common AI chat patterns.
+ *
+ * Each factory returns a full `TriggerConfig` with sensible defaults.
+ * Pass only what you need to override.
+ *
+ * @example
+ * ```tsx
+ * <PromptArea
+ *   triggers={[
+ *     mentionTrigger({ onSearch: searchUsers }),
+ *     commandTrigger({ onSearch: searchCommands }),
+ *     hashtagTrigger(),
+ *   ]}
+ * />
+ * ```
+ */
+
+type TriggerPresetOptions = Omit<Partial<TriggerConfig>, 'char' | 'position' | 'mode'>;
+type MentionTriggerOptions = TriggerPresetOptions & {
+    /** Override the trigger character. Defaults to `'@'`. */
+    char?: string;
+};
+/**
+ * Creates a **mention** trigger (`@`).
+ *
+ * Defaults: `position: 'any'`, `mode: 'dropdown'`, `chipStyle: 'pill'`,
+ * accessible label `"mention"`.
+ */
+declare function mentionTrigger(opts?: MentionTriggerOptions): TriggerConfig;
+type CommandTriggerOptions = TriggerPresetOptions & {
+    /** Override the trigger character. Defaults to `'/'`. */
+    char?: string;
+};
+/**
+ * Creates a **command** trigger (`/`).
+ *
+ * Defaults: `position: 'start'`, `mode: 'dropdown'`, `chipStyle: 'inline'`,
+ * accessible label `"command"`.
+ */
+declare function commandTrigger(opts?: CommandTriggerOptions): TriggerConfig;
+type HashtagTriggerOptions = TriggerPresetOptions & {
+    /** Override the trigger character. Defaults to `'#'`. */
+    char?: string;
+};
+/**
+ * Creates a **hashtag / tag** trigger (`#`).
+ *
+ * Defaults: `position: 'any'`, `mode: 'dropdown'`, `chipStyle: 'pill'`,
+ * `resolveOnSpace: true`, accessible label `"tag"`.
+ */
+declare function hashtagTrigger(opts?: HashtagTriggerOptions): TriggerConfig;
+type CallbackTriggerOptions = Omit<Partial<TriggerConfig>, 'mode'> & {
+    /** The trigger character. Required. */
+    char: string;
+};
+/**
+ * Creates a **callback** trigger that fires `onActivate` instead of showing
+ * a dropdown. Useful for opening file pickers, model selectors, etc.
+ *
+ * Defaults: `position: 'start'`, `mode: 'callback'`.
+ */
+declare function callbackTrigger(opts: CallbackTriggerOptions): TriggerConfig;
+
+export { type ActiveTrigger, type CallbackTriggerOptions, type ChipSegment, type ChipStyle, type CommandTriggerOptions, type HashtagTriggerOptions, type MarkdownToken, type MentionTriggerOptions, type PromptAreaFile, type PromptAreaImage, type Segment, type TextSegment, type TriggerActivateContext, type TriggerConfig, type TriggerMode, type TriggerPosition, type TriggerSuggestion, callbackTrigger, chip, commandTrigger, detectActiveTrigger, getChips, getChipsByTrigger, hasChips, hashtagTrigger, isSegmentsEmpty, isValidTriggerPosition, mentionTrigger, mergeAdjacentTextSegments, parseInlineMarkdown, plainTextToSegments, resolveChip, resolveTriggersInSegments, segmentsEqual, segmentsToPlainText, text };

package/dist/helpers/index.js

@@ -0,0 +1,291 @@
+// src/prompt-area/prompt-area-engine.ts
+function segmentsToPlainText(segments) {
+  return segments.map((seg) => {
+    if (seg.type === "text") return seg.text;
+    return `${seg.trigger}${seg.displayText}`;
+  }).join("");
+}
+function plainTextToSegments(text2) {
+  if (!text2) return [];
+  return [{ type: "text", text: text2 }];
+}
+function isValidTriggerPosition(text2, charIndex, position) {
+  if (charIndex === 0) return true;
+  const prevChar = text2[charIndex - 1];
+  if (position === "start") {
+    return prevChar === "\n";
+  }
+  return prevChar === " " || prevChar === "\n" || prevChar === "	";
+}
+function detectActiveTrigger(text2, cursorPos, triggers) {
+  if (!text2 || cursorPos === 0 || triggers.length === 0) return null;
+  for (let i = cursorPos - 1; i >= 0; i--) {
+    const char = text2[i];
+    if (char === " " || char === "\n" || char === "	") {
+      if (i + 1 < cursorPos) {
+        const nextChar = text2[i + 1];
+        const matchingTrigger2 = triggers.find((t) => t.char === nextChar);
+        if (matchingTrigger2 && isValidTriggerPosition(text2, i + 1, matchingTrigger2.position)) {
+          return {
+            config: matchingTrigger2,
+            startOffset: i + 1,
+            query: text2.slice(i + 2, cursorPos)
+          };
+        }
+      }
+      return null;
+    }
+    const matchingTrigger = triggers.find((t) => t.char === char);
+    if (matchingTrigger && isValidTriggerPosition(text2, i, matchingTrigger.position)) {
+      return {
+        config: matchingTrigger,
+        startOffset: i,
+        query: text2.slice(i + 1, cursorPos)
+      };
+    }
+  }
+  return null;
+}
+function resolveChip(segments, activeTrigger, chip2) {
+  const triggerStart = activeTrigger.startOffset;
+  const triggerEnd = triggerStart + 1 + activeTrigger.query.length;
+  const newSegments = [];
+  let offset = 0;
+  for (const seg of segments) {
+    if (seg.type === "chip") {
+      const chipText = `${seg.trigger}${seg.displayText}`;
+      const chipStart = offset;
+      const chipEnd = offset + chipText.length;
+      if (chipEnd <= triggerStart || chipStart >= triggerEnd) {
+        newSegments.push(seg);
+      }
+      offset = chipEnd;
+    } else {
+      const textStart = offset;
+      const textEnd = offset + seg.text.length;
+      if (textEnd <= triggerStart) {
+        newSegments.push(seg);
+      } else if (textStart >= triggerEnd) {
+        newSegments.push(seg);
+      } else {
+        const beforeText = seg.text.slice(0, Math.max(0, triggerStart - textStart));
+        const afterText = seg.text.slice(Math.min(seg.text.length, triggerEnd - textStart));
+        if (beforeText) {
+          newSegments.push({ type: "text", text: beforeText });
+        }
+        const newChip = {
+          type: "chip",
+          trigger: activeTrigger.config.char,
+          value: chip2.value,
+          displayText: chip2.displayText,
+          ...chip2.data !== void 0 ? { data: chip2.data } : {},
+          ...chip2.autoResolved ? { autoResolved: true } : {}
+        };
+        newSegments.push(newChip);
+        if (afterText) {
+          newSegments.push({ type: "text", text: " " + afterText.replace(/^\s/, "") });
+        } else {
+          newSegments.push({ type: "text", text: " " });
+        }
+      }
+      offset = textEnd;
+    }
+  }
+  const merged = mergeAdjacentTextSegments(newSegments);
+  let lastChipEndOffset = -1;
+  let runningOffset = 0;
+  for (const seg of merged) {
+    if (seg.type === "text") {
+      runningOffset += seg.text.length;
+    } else {
+      runningOffset += seg.trigger.length + seg.displayText.length;
+      if (seg.value === chip2.value && seg.displayText === chip2.displayText && seg.trigger === activeTrigger.config.char) {
+        lastChipEndOffset = runningOffset;
+      }
+    }
+  }
+  const cursorOffset = lastChipEndOffset === -1 ? runningOffset : lastChipEndOffset + 1;
+  return { segments: merged, cursorOffset };
+}
+function resolveTriggersInSegments(segments, triggers) {
+  const autoResolveTriggers = triggers.filter((t) => t.resolveOnSpace);
+  if (autoResolveTriggers.length === 0) return segments;
+  const triggerChars = new Set(autoResolveTriggers.map((t) => t.char));
+  const result = [];
+  for (const seg of segments) {
+    if (seg.type === "chip") {
+      result.push(seg);
+      continue;
+    }
+    const parts = splitTextByTriggerPatterns(seg.text, autoResolveTriggers, triggerChars);
+    result.push(...parts);
+  }
+  return mergeAdjacentTextSegments(result);
+}
+function splitTextByTriggerPatterns(text2, triggers, triggerChars) {
+  if (!text2) return [];
+  const segments = [];
+  let i = 0;
+  while (i < text2.length) {
+    const char = text2[i];
+    if (triggerChars.has(char)) {
+      const isAtBoundary = i === 0 || text2[i - 1] === " " || text2[i - 1] === "\n" || text2[i - 1] === "	";
+      if (isAtBoundary) {
+        const trigger = triggers.find((t) => t.char === char);
+        if (trigger && isValidTriggerPosition(text2, i, trigger.position)) {
+          let end = i + 1;
+          while (end < text2.length && text2[end] !== " " && text2[end] !== "\n" && text2[end] !== "	") {
+            end++;
+          }
+          const query = text2.slice(i + 1, end);
+          if (query.length > 0) {
+            const displayText = trigger.onSelect?.({ value: query, label: query }) || query;
+            segments.push({
+              type: "chip",
+              trigger: char,
+              value: query,
+              displayText,
+              autoResolved: true
+            });
+            i = end;
+            continue;
+          }
+        }
+      }
+    }
+    const start = i;
+    i++;
+    while (i < text2.length && !(triggerChars.has(text2[i]) && (text2[i - 1] === " " || text2[i - 1] === "\n" || text2[i - 1] === "	"))) {
+      i++;
+    }
+    segments.push({ type: "text", text: text2.slice(start, i) });
+  }
+  return segments;
+}
+function parseInlineMarkdown(text2) {
+  if (!text2) return [];
+  const tokens = [];
+  const pattern = /(\*{3}(.+?)\*{3})|(\*{2}(.+?)\*{2})|(\*(.+?)\*)|(https?:\/\/[^\s),]+)/g;
+  let lastIndex = 0;
+  let match;
+  while ((match = pattern.exec(text2)) !== null) {
+    if (match.index > lastIndex) {
+      tokens.push({ type: "plain", text: text2.slice(lastIndex, match.index) });
+    }
+    if (match[1] && match[2]) {
+      tokens.push({ type: "bold-italic", text: match[2] });
+    } else if (match[3] && match[4]) {
+      tokens.push({ type: "bold", text: match[4] });
+    } else if (match[5] && match[6]) {
+      tokens.push({ type: "italic", text: match[6] });
+    } else if (match[7]) {
+      tokens.push({ type: "url", text: match[7] });
+    }
+    lastIndex = match.index + match[0].length;
+  }
+  if (lastIndex < text2.length) {
+    tokens.push({ type: "plain", text: text2.slice(lastIndex) });
+  }
+  return tokens;
+}
+function segmentsEqual(a, b) {
+  if (a === b) return true;
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    const sa = a[i];
+    const sb = b[i];
+    if (sa.type !== sb.type) return false;
+    if (sa.type === "text") {
+      if (sb.type !== "text" || sa.text !== sb.text) return false;
+    } else {
+      if (sb.type !== "chip" || sa.trigger !== sb.trigger || sa.value !== sb.value || sa.displayText !== sb.displayText || sa.autoResolved !== sb.autoResolved)
+        return false;
+    }
+  }
+  return true;
+}
+function mergeAdjacentTextSegments(segments) {
+  const result = [];
+  for (const seg of segments) {
+    if (seg.type === "text" && seg.text === "") continue;
+    const last = result[result.length - 1];
+    if (seg.type === "text" && last?.type === "text") {
+      result[result.length - 1] = { type: "text", text: last.text + seg.text };
+    } else {
+      result.push(seg);
+    }
+  }
+  return result;
+}
+
+// src/prompt-area/segment-helpers.ts
+function text(value) {
+  return { type: "text", text: value };
+}
+function chip(opts) {
+  return { type: "chip", ...opts };
+}
+function isSegmentsEmpty(segments) {
+  if (segments.length === 0) return true;
+  return segments.every((seg) => seg.type === "text" && seg.text.trim() === "");
+}
+function hasChips(segments) {
+  return segments.some((seg) => seg.type === "chip");
+}
+function getChips(segments) {
+  return segments.filter((seg) => seg.type === "chip");
+}
+function getChipsByTrigger(segments, trigger) {
+  return segments.filter(
+    (seg) => seg.type === "chip" && seg.trigger === trigger
+  );
+}
+
+// src/prompt-area/trigger-presets.ts
+function mentionTrigger(opts = {}) {
+  const { char = "@", ...rest } = opts;
+  return {
+    char,
+    position: "any",
+    mode: "dropdown",
+    chipStyle: "pill",
+    accessibilityLabel: "mention",
+    ...rest
+  };
+}
+function commandTrigger(opts = {}) {
+  const { char = "/", ...rest } = opts;
+  return {
+    char,
+    position: "start",
+    mode: "dropdown",
+    chipStyle: "inline",
+    accessibilityLabel: "command",
+    ...rest
+  };
+}
+function hashtagTrigger(opts = {}) {
+  const { char = "#", ...rest } = opts;
+  return {
+    char,
+    position: "any",
+    mode: "dropdown",
+    chipStyle: "pill",
+    resolveOnSpace: true,
+    accessibilityLabel: "tag",
+    ...rest
+  };
+}
+function callbackTrigger(opts) {
+  const { char, ...rest } = opts;
+  return {
+    char,
+    position: "start",
+    mode: "callback",
+    ...rest
+  };
+}
+
+export { callbackTrigger, chip, commandTrigger, detectActiveTrigger, getChips, getChipsByTrigger, hasChips, hashtagTrigger, isSegmentsEmpty, isValidTriggerPosition, mentionTrigger, mergeAdjacentTextSegments, parseInlineMarkdown, plainTextToSegments, resolveChip, resolveTriggersInSegments, segmentsEqual, segmentsToPlainText, text };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map