@nks-hub/texy-editor 0.1.1 → 0.1.2

package/dist/types/core/DialogManager.d.ts

@@ -0,0 +1,22 @@
+import type { TexyEditorStrings } from '../types';
+export interface DialogConfig {
+    title: string;
+    width?: number;
+    content: HTMLElement;
+    onSubmit: () => void;
+    onCancel?: () => void;
+}
+/**
+ * Native <dialog> based modal window manager.
+ * Replaces jQuery UI Dialog with zero dependencies.
+ */
+export declare class DialogManager {
+    private container;
+    private strings;
+    private openDialogs;
+    constructor(container: HTMLElement, strings: TexyEditorStrings);
+    open(name: string, config: DialogConfig): HTMLDialogElement;
+    close(name: string): void;
+    closeAll(): void;
+    isOpen(name: string): boolean;
+}

package/dist/types/core/EventBus.d.ts

@@ -0,0 +1,10 @@
+import type { TexyEditorEvents, TexyEventHandler } from '../types';
+type EventMap = TexyEditorEvents;
+export declare class EventBus {
+    private listeners;
+    on<K extends keyof EventMap>(event: K, handler: TexyEventHandler<EventMap[K]>): void;
+    off<K extends keyof EventMap>(event: K, handler: TexyEventHandler<EventMap[K]>): void;
+    emit<K extends keyof EventMap>(event: K, data: EventMap[K]): void;
+    removeAll(): void;
+}
+export {};

package/dist/types/core/KeyboardManager.d.ts

@@ -0,0 +1,13 @@
+export type ShortcutHandler = () => void;
+export declare class KeyboardManager {
+    private textarea;
+    private customShortcuts?;
+    private bindings;
+    private boundHandler;
+    constructor(textarea: HTMLTextAreaElement, customShortcuts?: Record<string, string> | undefined);
+    register(actionName: string, handler: ShortcutHandler): void;
+    attach(): void;
+    detach(): void;
+    private handleKeydown;
+    private parseShortcut;
+}

package/dist/types/core/Selection.d.ts

@@ -0,0 +1,59 @@
+import type { SelectionState } from '../types';
+/**
+ * Textarea selection manager.
+ * Provides methods to read, manipulate, and replace selected text
+ * in a standard HTMLTextAreaElement without any external dependencies.
+ */
+export declare class Selection {
+    private textarea;
+    constructor(textarea: HTMLTextAreaElement);
+    /** Detect the line-feed character used in the textarea value */
+    get lf(): string;
+    /** Get current selection state snapshot */
+    getState(): SelectionState;
+    /** Get selected text */
+    text(): string;
+    /** Length of current selection */
+    length(): number;
+    /** Whether selection is collapsed (cursor without selection) */
+    isCursor(): boolean;
+    /** Set selection range programmatically */
+    select(start: number, length: number): void;
+    /** Place cursor at a specific position */
+    setCursor(position: number): void;
+    /**
+     * Replace currently selected text with new content.
+     * After replacement, the new text is selected.
+     */
+    replace(replacement: string): void;
+    /**
+     * Wrap selection with prefix and suffix.
+     * If nothing is selected (cursor), places cursor between prefix and suffix.
+     */
+    tag(prefix: string, suffix: string): void;
+    /**
+     * Wrap selection as an inline phrase.
+     * Trims trailing whitespace from selection before wrapping.
+     */
+    phrase(prefix: string, suffix?: string): void;
+    /**
+     * Remove trailing whitespace from the selection boundary.
+     * Useful when double-clicking selects a trailing space.
+     */
+    trimSelect(): void;
+    /**
+     * Expand selection to cover complete lines.
+     * Useful for block-level operations (lists, headings).
+     */
+    selectBlock(): void;
+    /** Get the full value of the textarea */
+    getValue(): string;
+    /** Set the full value of the textarea */
+    setValue(value: string): void;
+    /** Focus the textarea */
+    focus(): void;
+    /** Get the underlying textarea element */
+    getElement(): HTMLTextAreaElement;
+    private isCursorAt;
+    private dispatchInput;
+}

package/dist/types/core/TexyEditor.d.ts

@@ -0,0 +1,71 @@
+import type { TexyEditorOptions, TexyEditorAPI, TexyEditorEvents, TexyEditorStrings, TexyEventHandler, ViewMode } from '../types';
+import { Selection } from './Selection';
+import { TexyFormatter } from './TexyFormatter';
+import { DialogManager } from './DialogManager';
+export declare class TexyEditor implements TexyEditorAPI {
+    private container;
+    private textarea;
+    private editDiv;
+    private previewDiv;
+    private previewContent;
+    private selection;
+    private formatter;
+    private events;
+    private undoManager;
+    private keyboard;
+    private toolbarBuilder;
+    private dialogManager;
+    private strings;
+    private options;
+    private currentView;
+    private isFullscreen;
+    private parser;
+    private plugins;
+    private previewDebounceTimer;
+    private lastPreviewedValue;
+    private destroyed;
+    private actions;
+    constructor(textareaOrSelector: HTMLTextAreaElement | string, options?: TexyEditorOptions);
+    getValue(): string;
+    setValue(value: string): void;
+    getSelection(): string;
+    replaceSelection(text: string): void;
+    wrapSelection(prefix: string, suffix: string): void;
+    insertAtCursor(text: string): void;
+    focus(): void;
+    setView(mode: ViewMode): void;
+    getView(): ViewMode;
+    execAction(name: string): void;
+    on<K extends keyof TexyEditorEvents>(event: K, handler: TexyEventHandler<TexyEditorEvents[K]>): void;
+    off<K extends keyof TexyEditorEvents>(event: K, handler: TexyEventHandler<TexyEditorEvents[K]>): void;
+    undo(): void;
+    redo(): void;
+    openWindow(_name: string): void;
+    closeWindow(name: string): void;
+    toggleFullscreen(): void;
+    getTextarea(): HTMLTextAreaElement;
+    getContainer(): HTMLElement;
+    getStrings(): TexyEditorStrings;
+    getDialogManager(): DialogManager;
+    getFormatter(): TexyFormatter;
+    getSelectionManager(): Selection;
+    destroy(): void;
+    private buildDOM;
+    private applyTheme;
+    private updateView;
+    private renderPreview;
+    private fetchServerPreview;
+    private registerActions;
+    private handleHeading;
+    private handleLink;
+    private handleImage;
+    private handleTable;
+    private handleColor;
+    private handleSymbol;
+    private handleAcronym;
+    private setupKeyboard;
+    private setupUndoTracking;
+    private setupAutoResize;
+    private loadPlugin;
+    private createFormField;
+}

package/dist/types/core/TexyFormatter.d.ts

@@ -0,0 +1,53 @@
+import { Selection } from './Selection';
+/**
+ * Texy markup insertion and toggle operations.
+ * Each method manipulates the textarea selection to insert or toggle
+ * Texy-formatted markup.
+ */
+export declare class TexyFormatter {
+    private selection;
+    constructor(selection: Selection);
+    bold(): void;
+    italic(): void;
+    deleted(): void;
+    inserted(): void;
+    superscript(): void;
+    subscript(): void;
+    inlineCode(): void;
+    noTexy(): void;
+    quoted(): void;
+    link(url: string, text?: string): void;
+    acronym(title: string): void;
+    image(src: string, alt?: string, align?: '<' | '>' | '<>' | '*', caption?: string): void;
+    heading(level: 1 | 2 | 3 | 4): void;
+    headingWithPrompt(level: 1 | 2 | 3 | 4, text: string): void;
+    unorderedList(): void;
+    orderedList(): void;
+    orderedListRoman(): void;
+    orderedListRomanSmall(): void;
+    orderedListAlpha(): void;
+    orderedListAlphaSmall(): void;
+    blockquote(): void;
+    indent(): void;
+    unindent(): void;
+    alignLeft(): void;
+    alignRight(): void;
+    alignCenter(): void;
+    alignJustify(): void;
+    codeBlock(language?: string): void;
+    htmlBlock(): void;
+    divBlock(modifier?: string): void;
+    textBlock(): void;
+    commentBlock(): void;
+    horizontalRule(): void;
+    table(cols: number, rows: number, header?: 'none' | 'top' | 'left'): void;
+    colorModifier(color: string): void;
+    classModifier(className: string): void;
+    insertSymbol(symbol: string): void;
+    private toggleInline;
+    private applyList;
+    private getBullet;
+    private toRoman;
+    private toLetter;
+    private insertAlignment;
+}

package/dist/types/core/ToolbarBuilder.d.ts

@@ -0,0 +1,17 @@
+import type { ToolbarConfig, TexyEditorStrings } from '../types';
+export declare class ToolbarBuilder {
+    private strings;
+    private actionHandler;
+    private toolbar;
+    private bottomBar;
+    constructor(strings: TexyEditorStrings, actionHandler: (name: string) => void);
+    build(config: ToolbarConfig): HTMLElement;
+    buildBottomBar(left: string[], rightEdit: string[], rightPreview: string[]): HTMLElement;
+    private renderItem;
+    private createButton;
+    private createCustomButton;
+    private createSeparator;
+    private createDropdown;
+    private isGroup;
+    private isCustomButton;
+}

package/dist/types/core/UndoManager.d.ts

@@ -0,0 +1,17 @@
+export interface UndoState {
+    value: string;
+    cursorStart: number;
+    cursorEnd: number;
+}
+export declare class UndoManager {
+    private stack;
+    private pointer;
+    private maxSteps;
+    constructor(maxSteps?: number);
+    push(state: UndoState): void;
+    undo(): UndoState | null;
+    redo(): UndoState | null;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    clear(): void;
+}

package/dist/types/i18n/cs.d.ts

@@ -0,0 +1,2 @@
+import type { TexyEditorStrings } from '../types';
+export declare const cs: TexyEditorStrings;

package/dist/types/i18n/en.d.ts

@@ -0,0 +1,2 @@
+import type { TexyEditorStrings } from '../types';
+export declare const en: TexyEditorStrings;

package/dist/types/i18n/index.d.ts

@@ -0,0 +1,6 @@
+import type { TexyEditorStrings } from '../types';
+import { cs } from './cs';
+import { en } from './en';
+export declare function getStrings(lang: string): TexyEditorStrings;
+export declare function registerLanguage(lang: string, strings: TexyEditorStrings): void;
+export { cs, en };

package/dist/types/index.d.ts

@@ -0,0 +1,13 @@
+export { TexyEditor } from './core/TexyEditor';
+export { Selection } from './core/Selection';
+export { TexyFormatter } from './core/TexyFormatter';
+export { EventBus } from './core/EventBus';
+export { UndoManager } from './core/UndoManager';
+export { KeyboardManager } from './core/KeyboardManager';
+export { ToolbarBuilder } from './core/ToolbarBuilder';
+export { DialogManager } from './core/DialogManager';
+export { TexyParser } from './parser';
+export { youtubePlugin, smileyPlugin, linkRedirectPlugin, bbcodePlugin, imageEmbedPlugin, } from './parser';
+export { getStrings, registerLanguage, cs, en } from './i18n';
+export type { TexyEditorOptions, TexyEditorAPI, TexyEditorEvents, TexyEditorStrings, TexyEventHandler, TexyPlugin, TexyPluginWindowConfig, ToolbarConfig, ToolbarItem, ToolbarGroup, ToolbarCustomButton, ViewMode, SelectionState, UploadHandler, UploadResult, MentionSource, MentionItem, TexyParseRule, TexyParserOptions, TexyParserPlugin, } from './types';
+import './themes/base.css';

package/dist/types/parser/TexyParser.d.ts

@@ -0,0 +1,44 @@
+import type { TexyParserOptions, TexyParserPlugin } from '../types';
+/**
+ * Client-side Texy markup parser.
+ * Converts Texy source text to HTML for live preview.
+ * Supports plugin system for custom syntax extensions.
+ */
+export declare class TexyParser {
+    private options;
+    private plugins;
+    constructor(options?: TexyParserOptions);
+    /** Add a plugin at runtime */
+    addPlugin(plugin: TexyParserPlugin): void;
+    /** Remove a plugin by name */
+    removePlugin(name: string): void;
+    /** Get registered plugins */
+    getPlugins(): readonly TexyParserPlugin[];
+    parse(input: string): string;
+    private parseBlocks;
+    /**
+     * Split text into block segments.
+     * Respects /--...\-- block boundaries.
+     */
+    private splitBlockSegments;
+    private splitParagraphs;
+    private tryCommentBlock;
+    private tryCodeBlock;
+    private tryHtmlBlock;
+    private tryDivBlock;
+    private tryTextBlock;
+    private tryTable;
+    private parseTableRow;
+    private tryHeading;
+    private tryHorizontalRule;
+    private tryBlockquote;
+    private tryList;
+    private parseListItems;
+    private tryParagraph;
+    private parseAlignModifier;
+    parseInline(text: string): string;
+    private escapeHtmlPreservingPlaceholders;
+    private applyTypography;
+    private parseModifierAttrs;
+    private escapeHtml;
+}

package/dist/types/parser/index.d.ts

@@ -0,0 +1,2 @@
+export { TexyParser } from './TexyParser';
+export { youtubePlugin, smileyPlugin, linkRedirectPlugin, bbcodePlugin, imageEmbedPlugin, } from './plugins';

package/dist/types/parser/plugins/bbcode.d.ts

@@ -0,0 +1,15 @@
+import type { TexyParserPlugin } from '../../types';
+/**
+ * BBCode plugin for TexyParser.
+ *
+ * Converts common BBCode tags to HTML:
+ *   [b]text[/b] → <strong>text</strong>
+ *   [i]text[/i] → <em>text</em>
+ *   [u]text[/u] → <u>text</u>
+ *   [s]text[/s] → <del>text</del>
+ *   [url=...]text[/url] → <a href="...">text</a>
+ *   [color=...]text[/color] → <span style="color:...">text</span>
+ *
+ * Useful for forums and chat applications that support BBCode alongside Texy.
+ */
+export declare function bbcodePlugin(): TexyParserPlugin;

package/dist/types/parser/plugins/image-embed.d.ts

@@ -0,0 +1,20 @@
+import type { TexyParserPlugin } from '../../types';
+export interface ImageEmbedPluginOptions {
+    /** Max width for embedded images (default: '300px') */
+    maxWidth?: string;
+    /** CSS class for embedded images */
+    className?: string;
+    /** Enable linked images: "[* img *]":URL syntax (default: true) */
+    enableLinkedImages?: boolean;
+}
+/**
+ * Enhanced image embed plugin for TexyParser.
+ *
+ * Handles external image URLs in Texy image syntax:
+ *   [* https://example.com/photo.jpg *]
+ *   [* https://example.com/photo.jpg .(alt text) *]
+ *
+ * Also supports linked images:
+ *   "[* https://example.com/photo.jpg *]":https://example.com
+ */
+export declare function imageEmbedPlugin(options?: ImageEmbedPluginOptions): TexyParserPlugin;

package/dist/types/parser/plugins/index.d.ts

@@ -0,0 +1,9 @@
+export { youtubePlugin } from './youtube';
+export type { YouTubePluginOptions } from './youtube';
+export { smileyPlugin } from './smiley';
+export type { SmileyPluginOptions } from './smiley';
+export { linkRedirectPlugin } from './link-redirect';
+export type { LinkRedirectPluginOptions } from './link-redirect';
+export { bbcodePlugin } from './bbcode';
+export { imageEmbedPlugin } from './image-embed';
+export type { ImageEmbedPluginOptions } from './image-embed';

package/dist/types/parser/plugins/link-redirect.d.ts

@@ -0,0 +1,18 @@
+import type { TexyParserPlugin } from '../../types';
+export interface LinkRedirectPluginOptions {
+    /** Redirect service base URL (required) */
+    redirectUrl: string;
+    /** Domains to exclude from redirect (e.g., own domain) */
+    excludeDomains?: string[];
+    /** Add target="_blank" to external links (default: true) */
+    targetBlank?: boolean;
+    /** Add rel="noopener noreferrer" (default: true) */
+    noopener?: boolean;
+}
+/**
+ * Link redirect plugin for TexyParser.
+ *
+ * Rewrites external links to go through a redirect service,
+ * useful for tracking and safety. Adds target="_blank" to external links.
+ */
+export declare function linkRedirectPlugin(options: LinkRedirectPluginOptions): TexyParserPlugin;

package/dist/types/parser/plugins/smiley.d.ts

@@ -0,0 +1,18 @@
+import type { TexyParserPlugin } from '../../types';
+export interface SmileyPluginOptions {
+    /** Base URL for smiley images (required) */
+    baseUrl: string;
+    /** Image format extension (default: 'gif') */
+    format?: string;
+    /** Optional ARIA labels map: smiley ID → label text */
+    ariaLabels?: Record<string, string>;
+    /** CSS class for smiley images */
+    className?: string;
+}
+/**
+ * Smiley/emoticon plugin for TexyParser.
+ *
+ * Converts *ID* syntax to smiley images:
+ *   *123* → <img src="baseUrl/123.gif" alt="smiley" class="smiley">
+ */
+export declare function smileyPlugin(options: SmileyPluginOptions): TexyParserPlugin;

package/dist/types/parser/plugins/youtube.d.ts

@@ -0,0 +1,23 @@
+import type { TexyParserPlugin } from '../../types';
+export interface YouTubePluginOptions {
+    /** Iframe width (default: 560) */
+    width?: number;
+    /** Iframe height (default: 315) */
+    height?: number;
+    /** Allow fullscreen (default: true) */
+    allowFullscreen?: boolean;
+    /** Responsive wrapper CSS class */
+    wrapperClass?: string;
+}
+/**
+ * YouTube embed plugin for TexyParser.
+ *
+ * Supports Texy image syntax with youtube: prefix:
+ *   [* youtube:VIDEO_ID *]
+ *
+ * Also converts YouTube URLs in image syntax:
+ *   [* https://www.youtube.com/watch?v=ID *]
+ *   [* https://youtu.be/ID *]
+ *   [* https://www.youtube.com/shorts/ID *]
+ */
+export declare function youtubePlugin(options?: YouTubePluginOptions): TexyParserPlugin;

package/dist/types/types.d.ts

@@ -0,0 +1,279 @@
+/**
+ * Public API type definitions for @nks-hub/texy-editor
+ */
+export interface TexyEditorOptions {
+    /** Language code for i18n strings */
+    language?: string;
+    /** Toolbar button configuration */
+    toolbar?: ToolbarConfig;
+    /** Bottom-left toolbar buttons */
+    bottomLeftToolbar?: string[];
+    /** Bottom-right toolbar buttons (edit mode) */
+    bottomRightEditToolbar?: string[];
+    /** Bottom-right toolbar buttons (preview mode) */
+    bottomRightPreviewToolbar?: string[];
+    /** Editor width (CSS value) */
+    width?: string;
+    /** Initial view mode */
+    defaultView?: ViewMode;
+    /** Server-side preview endpoint URL */
+    previewPath?: string | null;
+    /** Texy config string sent with preview AJAX */
+    texyCfg?: string;
+    /** Enable client-side live preview */
+    livePreview?: boolean;
+    /** Live preview debounce delay in ms */
+    livePreviewDelay?: number;
+    /** Theme preset name or custom CSS class */
+    theme?: 'light' | 'dark' | string;
+    /** Enable split view (editor + preview side by side) */
+    splitView?: boolean;
+    /** Enable fullscreen toggle */
+    fullscreen?: boolean;
+    /** Enable auto-resize textarea */
+    autoResize?: boolean;
+    /** Max undo history steps */
+    maxUndoSteps?: number;
+    /** Keyboard shortcuts map override */
+    shortcuts?: Record<string, string>;
+    /** File upload handler */
+    uploadHandler?: UploadHandler | null;
+    /** Mention autocomplete data source */
+    mentionSource?: MentionSource | null;
+    /** Custom CSS variables override */
+    cssVars?: Record<string, string>;
+    /** Plugins to load */
+    plugins?: TexyPlugin[];
+    /** ARIA label for the editor */
+    ariaLabel?: string;
+}
+export type ToolbarItem = string | null | ToolbarGroup | ToolbarCustomButton;
+export type ToolbarConfig = ToolbarItem[];
+export interface ToolbarGroup {
+    type: 'group';
+    label?: string;
+    items: string[];
+}
+export interface ToolbarCustomButton {
+    type: 'button';
+    name: string;
+    icon?: string;
+    label: string;
+    action: (editor: TexyEditorAPI) => void;
+}
+export type ViewMode = 'edit' | 'preview' | 'split';
+export interface TexyEditorEvents {
+    'change': {
+        value: string;
+    };
+    'view:change': {
+        mode: ViewMode;
+    };
+    'toolbar:action': {
+        button: string;
+    };
+    'preview:render': {
+        html: string;
+    };
+    'upload:start': {
+        file: File;
+    };
+    'upload:complete': {
+        url: string;
+        file: File;
+    };
+    'upload:error': {
+        error: Error;
+        file: File;
+    };
+    'fullscreen:toggle': {
+        active: boolean;
+    };
+    'undo': void;
+    'redo': void;
+    'focus': void;
+    'blur': void;
+    'mention:query': {
+        query: string;
+    };
+    'plugin:init': {
+        name: string;
+    };
+    'destroy': void;
+}
+export type TexyEventHandler<T> = (data: T) => void;
+export interface TexyPlugin {
+    name: string;
+    init(editor: TexyEditorAPI): void;
+    destroy?(): void;
+}
+export interface TexyPluginWindowConfig {
+    name: string;
+    title: string;
+    width?: number;
+    height?: number;
+    createContent(editor: TexyEditorAPI): HTMLElement;
+    onSubmit(editor: TexyEditorAPI, content: HTMLElement): void;
+}
+export interface UploadHandler {
+    upload(file: File): Promise<UploadResult>;
+    accept?: string;
+    maxSize?: number;
+}
+export interface UploadResult {
+    url: string;
+    alt?: string;
+    width?: number;
+    height?: number;
+}
+export interface MentionSource {
+    search(query: string): Promise<MentionItem[]>;
+    template?: (item: MentionItem) => string;
+}
+export interface MentionItem {
+    id: string;
+    label: string;
+    avatar?: string;
+    description?: string;
+}
+export interface TexyEditorStrings {
+    bold: string;
+    italic: string;
+    deleted: string;
+    inserted: string;
+    superscript: string;
+    subscript: string;
+    code: string;
+    codeBlock: string;
+    heading1: string;
+    heading2: string;
+    heading3: string;
+    heading4: string;
+    link: string;
+    linkUrl: string;
+    linkText: string;
+    image: string;
+    imageUrl: string;
+    imageAlt: string;
+    imageAlign: string;
+    unorderedList: string;
+    orderedList: string;
+    blockquote: string;
+    horizontalRule: string;
+    table: string;
+    tableRows: string;
+    tableCols: string;
+    color: string;
+    symbol: string;
+    acronym: string;
+    acronymTitle: string;
+    alignLeft: string;
+    alignRight: string;
+    alignCenter: string;
+    alignJustify: string;
+    indent: string;
+    unindent: string;
+    fullscreen: string;
+    preview: string;
+    edit: string;
+    splitView: string;
+    undo: string;
+    redo: string;
+    upload: string;
+    uploadDragDrop: string;
+    previewEmpty: string;
+    previewLoading: string;
+    headingPrompt: string;
+    ok: string;
+    cancel: string;
+    close: string;
+}
+export interface TexyEditorAPI {
+    /** Get current textarea value */
+    getValue(): string;
+    /** Set textarea value */
+    setValue(value: string): void;
+    /** Get selected text */
+    getSelection(): string;
+    /** Replace selection with text */
+    replaceSelection(text: string): void;
+    /** Wrap selection with prefix/suffix */
+    wrapSelection(prefix: string, suffix: string): void;
+    /** Insert text at cursor */
+    insertAtCursor(text: string): void;
+    /** Focus the textarea */
+    focus(): void;
+    /** Switch view mode */
+    setView(mode: ViewMode): void;
+    /** Get current view mode */
+    getView(): ViewMode;
+    /** Execute a toolbar button action by name */
+    execAction(name: string): void;
+    /** Subscribe to editor event */
+    on<K extends keyof TexyEditorEvents>(event: K, handler: TexyEventHandler<TexyEditorEvents[K]>): void;
+    /** Unsubscribe from editor event */
+    off<K extends keyof TexyEditorEvents>(event: K, handler: TexyEventHandler<TexyEditorEvents[K]>): void;
+    /** Undo last change */
+    undo(): void;
+    /** Redo last undone change */
+    redo(): void;
+    /** Open a plugin dialog window */
+    openWindow(name: string): void;
+    /** Close a plugin dialog window */
+    closeWindow(name: string): void;
+    /** Toggle fullscreen */
+    toggleFullscreen(): void;
+    /** Get the underlying textarea element */
+    getTextarea(): HTMLTextAreaElement;
+    /** Get the editor container element */
+    getContainer(): HTMLElement;
+    /** Get the i18n strings */
+    getStrings(): TexyEditorStrings;
+    /** Destroy the editor and restore original textarea */
+    destroy(): void;
+}
+export interface SelectionState {
+    start: number;
+    end: number;
+    text: string;
+    before: string;
+    after: string;
+}
+export interface TexyParseRule {
+    name: string;
+    /** Priority (lower = runs first) */
+    priority: number;
+    /** Process block-level content */
+    block?: (text: string) => string;
+    /** Process inline content */
+    inline?: (text: string) => string;
+}
+export interface TexyParserOptions {
+    rules?: TexyParseRule[];
+    plugins?: TexyParserPlugin[];
+    enableTypography?: boolean;
+    enableAutolinks?: boolean;
+}
+/**
+ * Parser plugin interface for extending Texy syntax.
+ * Plugins can hook into multiple stages of the parsing pipeline.
+ */
+export interface TexyParserPlugin {
+    name: string;
+    /**
+     * Preprocess source text before any parsing (raw Texy input).
+     * Useful for converting custom syntax to standard Texy or placeholders.
+     */
+    preprocess?: (text: string) => string;
+    /**
+     * Process inline content during inline parsing phase.
+     * Receives text with placeholders already extracted (noTexy, code, images, links).
+     * Use the provided placeholder function to protect generated HTML.
+     */
+    processInline?: (text: string, placeholder: (html: string) => string) => string;
+    /**
+     * Postprocess final HTML output.
+     * Useful for expanding placeholders, adding wrappers, or final transformations.
+     */
+    postprocess?: (html: string) => string;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nks-hub/texy-editor",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Modern TypeScript Texy markup editor with configurable toolbar, live preview, theming, and plugin system",
   "type": "module",
   "main": "./dist/texy-editor.cjs",