@miliastry/quasar 1.0.6 → 1.1.0

package/dist/types/Incremental/__tests__/IncrementalParser.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,4 @@
+export { IncrementalParser } from './IncrementalParser';
+export type { EditOperation, ReparseResult } from './IncrementalParser';
+export { ChangeTracker } from './ChangeTracker';
+export type { TextChange, TextChangeStats } from './ChangeTracker';

package/dist/types/Lexer/BBCodeLexer.d.ts

@@ -0,0 +1,74 @@
+/**
+ * DocumentEngine — BBCodeLexer
+ *
+ * A purpose-built lexer for BBCode that produces explicit newline tokens.
+ * This replaces the old BBCode parser's Tokenizer by producing a cleaner
+ * token stream that allows the parser to make semantic decisions about
+ * spacing (single vs double newlines → empty_line nodes).
+ *
+ * Unlike the generic Lexer base class, this is tuned specifically for BBCode
+ * syntax: [tag], [/tag], [tag=value], text content, and newlines.
+ *
+ * Token types:
+ * - open:     [tag] or [tag=attrs]
+ * - close:    [/tag]
+ * - text:     Any content between tags (never includes newlines or brackets)
+ * - newline:  \n or \r\n (explicit — not mixed into text tokens)
+ *
+ * Architecture: Pure function, no state, no class. Input → Output.
+ * Can be used in workers, SSR, or client-side without initialization.
+ */
+export interface BBCodeOpenToken {
+    kind: 'open';
+    tag: string;
+    attrs: string;
+    start: number;
+    end: number;
+}
+export interface BBCodeCloseToken {
+    kind: 'close';
+    tag: string;
+    start: number;
+    end: number;
+}
+export interface BBCodeTextToken {
+    kind: 'text';
+    value: string;
+    start: number;
+    end: number;
+}
+export interface BBCodeNewlineToken {
+    kind: 'newline';
+    value: string;
+    start: number;
+    end: number;
+}
+export type BBCodeToken = BBCodeOpenToken | BBCodeCloseToken | BBCodeTextToken | BBCodeNewlineToken;
+/**
+ * Tags whose content is strictly literal: no inner tags, no newline tokens.
+ *
+ * Exported because the lexer is the ONLY authority on this. Consumers that
+ * have to reproduce the rule — a syntax highlighter deciding where to stop
+ * tokenising, an editor deciding whether to indent an inserted body — used to
+ * carry their own copy of `['code', 'c']`, which is a second lexer waiting to
+ * disagree with this one. Adding a raw tag here now reaches them.
+ */
+export declare const BBCODE_RAW_TAGS: readonly string[];
+/**
+ * Scan BBCode source text into a flat array of tokens.
+ *
+ * The lexer distinguishes between:
+ * - Valid BBCode tags: [b], [color=red], [/b], [*]
+ * - Invalid syntax:    [bogus stuff, [unclosed, lone [
+ *
+ * Invalid syntax is treated as plain text — the parser will never
+ * see malformed tokens.
+ *
+ * Newlines are always emitted as distinct tokens so the parser
+ * can precisely determine spacing semantics.
+ */
+export declare function scanBBCode(source: string): BBCodeToken[];
+/**
+ * Debug: format tokens for inspection.
+ */
+export declare function formatTokens(tokens: BBCodeToken[]): string;

package/dist/types/Lexer/Lexer.d.ts

@@ -0,0 +1,54 @@
+/**
+ * DocumentEngine — Lexer
+ *
+ * Tokenizes source text into a stream of Tokens with Trivia.
+ * Trivia includes whitespace, newlines, and formatting that is
+ * preserved in the token stream but not semantically significant.
+ *
+ * This is a LANGUAGE-INDEPENDENT lexer framework.
+ * Language-specific tokenization is provided via the LexerOptions.
+ *
+ * Inspired by Roslyn's lexer architecture.
+ */
+import type { Token, TokenStream } from '../Types/tokens';
+import type { TokenKind } from '../Types/tokens';
+export interface LexerRule {
+    /** Pattern to match at the current position */
+    pattern: RegExp;
+    /** Token kind to produce */
+    kind: TokenKind;
+    /** Optional: extract a name from the match (for tags) */
+    name?: (match: RegExpExecArray) => string;
+    /** Optional: extract attributes from the match */
+    attrs?: (match: RegExpExecArray) => string;
+}
+export interface LexerOptions {
+    /** Language-specific tokenization rules */
+    rules: LexerRule[];
+    /** Characters that count as whitespace trivia */
+    whitespaceChars?: RegExp;
+    /** Characters that start a newline trivia */
+    newlineChars?: RegExp;
+    /** Whether to collect trivia */
+    collectTrivia?: boolean;
+    /** Lexer hooks: called before each token */
+    onToken?: (token: Token) => void;
+}
+export declare class Lexer {
+    private options;
+    private source;
+    private pos;
+    private tokens;
+    constructor(options: LexerOptions);
+    /**
+     * Tokenize source text into a TokenStream.
+     */
+    tokenize(source: string): TokenStream;
+    /**
+     * Re-tokenize a portion of the source (for incremental parsing).
+     * Returns just the new tokens for the affected range.
+     */
+    retokenize(source: string, start: number, end: number): Token[];
+    private tryRules;
+    private scanTrivia;
+}

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

@@ -0,0 +1,4 @@
+export { Lexer } from './Lexer';
+export type { LexerOptions, LexerRule } from './Lexer';
+export { scanBBCode, formatTokens, BBCODE_RAW_TAGS } from './BBCodeLexer';
+export type { BBCodeToken, BBCodeOpenToken, BBCodeCloseToken, BBCodeTextToken, BBCodeNewlineToken, } from './BBCodeLexer';

package/dist/types/Linter/Linter.d.ts

@@ -0,0 +1,58 @@
+/**
+ * DocumentEngine — Linter
+ *
+ * Lints the document tree for issues.
+ * Similar to ESLint but for BBCode documents.
+ *
+ * Rules can be added via the Plugin API.
+ */
+import { RedNode } from '../Syntax/RedNode';
+export type LintSeverity = 'error' | 'warning' | 'info' | 'hint';
+export interface LintRule {
+    code: string;
+    severity: LintSeverity;
+    description: string;
+    validate(node: RedNode, context: LintContext): LintIssue | LintIssue[] | null;
+}
+export interface LintContext {
+    source: string;
+    allNodes: Map<string, RedNode>;
+}
+export interface LintIssue {
+    code: string;
+    message: string;
+    severity: LintSeverity;
+    nodeId: string;
+    range: {
+        start: number;
+        end: number;
+    } | null;
+    fix?: {
+        description: string;
+        apply: () => void;
+    };
+}
+export interface LintResult {
+    issues: LintIssue[];
+    errorCount: number;
+    warningCount: number;
+    infoCount: number;
+    hintCount: number;
+}
+export declare class Linter {
+    private rules;
+    constructor();
+    /**
+     * Register a lint rule.
+     */
+    register(rule: LintRule): void;
+    /**
+     * Unregister a lint rule.
+     */
+    unregister(code: string): void;
+    /**
+     * Lint a RedNode tree.
+     */
+    lint(root: RedNode, source: string): LintResult;
+    private registerBuiltinRules;
+}

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

@@ -0,0 +1,2 @@
+export { Linter } from './Linter';
+export type { LintRule, LintIssue, LintResult, LintContext, LintSeverity } from './Linter';

package/dist/types/Markdown/MarkdownAST.d.ts

@@ -0,0 +1,122 @@
+/**
+ * DocumentEngine — Markdown AST Nodes
+ */
+export type MarkdownNode = MarkdownDocument | MarkdownParagraph | MarkdownHeading | MarkdownText | MarkdownCodeBlock | MarkdownCodeInline | MarkdownStrong | MarkdownEmphasis | MarkdownStrikethrough | MarkdownUnderline | MarkdownColor | MarkdownFontSize | MarkdownFont | MarkdownAlign | MarkdownBox | MarkdownSeparator | MarkdownLink | MarkdownImage | MarkdownList | MarkdownListItem | MarkdownBlockquote | MarkdownSpoiler | MarkdownNotice | MarkdownSpacing | MarkdownEmptyLine | MarkdownGenericBBNode;
+export interface MarkdownGenericBBNode {
+    type: 'bbcode_tag';
+    tagName: string;
+    attrValue?: string;
+    children: MarkdownNode[];
+}
+export interface MarkdownDocument {
+    type: 'document';
+    children: MarkdownNode[];
+}
+export interface MarkdownParagraph {
+    type: 'paragraph';
+    children: MarkdownNode[];
+}
+export interface MarkdownHeading {
+    type: 'heading';
+    level: number;
+    children: MarkdownNode[];
+}
+export interface MarkdownText {
+    type: 'text';
+    value: string;
+}
+export interface MarkdownCodeBlock {
+    type: 'code_block';
+    lang: string;
+    value: string;
+}
+export interface MarkdownCodeInline {
+    type: 'code_inline';
+    value: string;
+}
+export interface MarkdownStrong {
+    type: 'strong';
+    children: MarkdownNode[];
+}
+export interface MarkdownEmphasis {
+    type: 'emphasis';
+    children: MarkdownNode[];
+}
+export interface MarkdownLink {
+    type: 'link';
+    url: string;
+    children: MarkdownNode[];
+}
+export interface MarkdownImage {
+    type: 'image';
+    url: string;
+    alt: string;
+}
+export interface MarkdownList {
+    type: 'list';
+    ordered: boolean;
+    children: MarkdownListItem[];
+}
+export interface MarkdownListItem {
+    type: 'list_item';
+    children: MarkdownNode[];
+}
+export interface MarkdownBlockquote {
+    type: 'blockquote';
+    source?: string;
+    children: MarkdownNode[];
+}
+/** `>!` spoiler block — produced by MarkdownParser, maps to BBCode [spoiler]. */
+export interface MarkdownSpoiler {
+    type: 'spoiler';
+    children: MarkdownNode[];
+}
+/** `> [!NOTE]` callout — produced by MarkdownParser, maps to BBCode [notice]. */
+export interface MarkdownNotice {
+    type: 'notice' | 'wnotice';
+    color?: string;
+    children: MarkdownNode[];
+}
+export interface MarkdownSpacing {
+    type: 'spacing';
+}
+export interface MarkdownEmptyLine {
+    type: 'empty_line';
+}
+export interface MarkdownStrikethrough {
+    type: 'strikethrough';
+    children: MarkdownNode[];
+}
+export interface MarkdownUnderline {
+    type: 'underline';
+    children: MarkdownNode[];
+}
+export interface MarkdownColor {
+    type: 'color';
+    color: string;
+    children: MarkdownNode[];
+}
+export interface MarkdownFontSize {
+    type: 'font_size';
+    size: string;
+    children: MarkdownNode[];
+}
+export interface MarkdownFont {
+    type: 'font';
+    font: string;
+    children: MarkdownNode[];
+}
+export interface MarkdownAlign {
+    type: 'align' | 'center' | 'right' | 'left';
+    children: MarkdownNode[];
+}
+export interface MarkdownBox {
+    type: 'box' | 'spoilerbox';
+    title?: string;
+    rawTitle?: string;
+    color?: string;
+    children: MarkdownNode[];
+}
+export interface MarkdownSeparator {
+    type: 'separator';
+}

package/dist/types/Markdown/MarkdownDocumentModel.d.ts

@@ -0,0 +1,15 @@
+import { DocumentModel, type DocumentModelOptions } from '../Model/DocumentModel';
+import { GreenNode } from '../Syntax/GreenNode';
+import { RedNode } from '../Syntax/RedNode';
+export interface MarkdownDocumentModelOptions extends DocumentModelOptions {
+    source?: string;
+    language?: string;
+}
+export declare class MarkdownDocumentModel extends DocumentModel {
+    constructor(options?: MarkdownDocumentModelOptions);
+    static fromMarkdown(source: string): MarkdownDocumentModel;
+    protected parseToGreen(source: string): GreenNode;
+    protected buildRedFromGreen(green: GreenNode): RedNode;
+    applyTextUpdate(newSource: string): void;
+    applyChange(change: any): void;
+}

package/dist/types/Markdown/MarkdownLexer.d.ts

@@ -0,0 +1,155 @@
+/**
+ * DocumentEngine — MarkdownLexer
+ *
+ * Tokenizes standard Markdown into a flat token stream.
+ * Produces explicit newline tokens for the parser to make semantic
+ * decisions about paragraph breaks.
+ */
+export interface MarkdownHashToken {
+    kind: 'hash';
+    value: string;
+    start: number;
+    end: number;
+}
+export interface MarkdownGtToken {
+    kind: 'gt';
+    start: number;
+    end: number;
+}
+export interface MarkdownStarToken {
+    kind: 'star';
+    value: string;
+    start: number;
+    end: number;
+}
+export interface MarkdownUnderscoreToken {
+    kind: 'underscore';
+    value: string;
+    start: number;
+    end: number;
+}
+export interface MarkdownTildeToken {
+    kind: 'tilde';
+    value: string;
+    start: number;
+    end: number;
+}
+export interface MarkdownBacktickToken {
+    kind: 'backtick';
+    value: string;
+    start: number;
+    end: number;
+}
+export interface MarkdownBracketOpenToken {
+    kind: 'bracket_open';
+    start: number;
+    end: number;
+}
+export interface MarkdownBracketCloseToken {
+    kind: 'bracket_close';
+    start: number;
+    end: number;
+}
+export interface MarkdownBraceOpenToken {
+    kind: 'brace_open';
+    start: number;
+    end: number;
+}
+export interface MarkdownBraceCloseToken {
+    kind: 'brace_close';
+    start: number;
+    end: number;
+}
+export interface MarkdownParenOpenToken {
+    kind: 'paren_open';
+    start: number;
+    end: number;
+}
+export interface MarkdownParenCloseToken {
+    kind: 'paren_close';
+    start: number;
+    end: number;
+}
+export interface MarkdownBangToken {
+    kind: 'bang';
+    start: number;
+    end: number;
+}
+export interface MarkdownDashToken {
+    kind: 'dash';
+    value: string;
+    start: number;
+    end: number;
+}
+export interface MarkdownPlusToken {
+    kind: 'plus';
+    value: string;
+    start: number;
+    end: number;
+}
+export interface MarkdownDotToken {
+    kind: 'dot';
+    start: number;
+    end: number;
+}
+export interface MarkdownColonToken {
+    kind: 'colon';
+    value: string;
+    start: number;
+    end: number;
+}
+export interface MarkdownContainerToken {
+    kind: 'container';
+    value: string;
+    info: string;
+    start: number;
+    end: number;
+}
+export interface MarkdownArrowToken {
+    kind: 'arrow_right' | 'arrow_left';
+    value: string;
+    start: number;
+    end: number;
+}
+export interface MarkdownTextToken {
+    kind: 'text';
+    value: string;
+    start: number;
+    end: number;
+}
+export interface MarkdownNewlineToken {
+    kind: 'newline';
+    value: string;
+    start: number;
+    end: number;
+}
+export interface MarkdownFenceToken {
+    kind: 'fence';
+    value: string;
+    lang: string;
+    start: number;
+    end: number;
+}
+export interface MarkdownHrToken {
+    kind: 'hr';
+    start: number;
+    end: number;
+}
+export interface MarkdownEscapeToken {
+    kind: 'escape';
+    value: string;
+    start: number;
+    end: number;
+}
+export interface MarkdownAngleToken {
+    kind: 'angle';
+    value: string;
+    start: number;
+    end: number;
+}
+export type MarkdownToken = MarkdownHashToken | MarkdownGtToken | MarkdownStarToken | MarkdownUnderscoreToken | MarkdownTildeToken | MarkdownBacktickToken | MarkdownBracketOpenToken | MarkdownBracketCloseToken | MarkdownBraceOpenToken | MarkdownBraceCloseToken | MarkdownParenOpenToken | MarkdownParenCloseToken | MarkdownBangToken | MarkdownDashToken | MarkdownPlusToken | MarkdownDotToken | MarkdownColonToken | MarkdownContainerToken | MarkdownArrowToken | MarkdownTextToken | MarkdownNewlineToken | MarkdownFenceToken | MarkdownHrToken | MarkdownEscapeToken | MarkdownAngleToken;
+/**
+ * Scan Markdown source text into tokens.
+ * Pure function: input → output, no state.
+ */
+export declare function scanMarkdown(source: string): MarkdownToken[];

package/dist/types/Markdown/MarkdownParser.d.ts

@@ -0,0 +1,42 @@
+import { MarkdownToken } from './MarkdownLexer';
+import { MarkdownNode, MarkdownDocument } from './MarkdownAST';
+/**
+ * DocumentEngine — MarkdownParser
+ *
+ * Parses Markdown tokens with hybrid BBCode embedding support into a typed AST.
+ */
+export declare class MarkdownParser {
+    private tokens;
+    private current;
+    constructor(tokens: MarkdownToken[]);
+    parse(): MarkdownDocument;
+    private parseBlock;
+    private parseHeading;
+    private parseBlockquote;
+    private parseNotice;
+    private parseContainer;
+    private tokenValue;
+    private parseFence;
+    private isListStart;
+    private isOrderedListStart;
+    private parseList;
+    private parseParagraph;
+    parseInline(terminator?: {
+        kind: string;
+        value?: string;
+    }): MarkdownNode | null;
+    private createAttributeSpanNode;
+    private peekBBCodeOpenTag;
+    private peekBBCodeCloseTag;
+    private isMatchingCloseTag;
+    private parseBBCodeBlock;
+    private parseBBCodeInline;
+    private createBBCodeNode;
+    private peek;
+    private previous;
+    private isAtEnd;
+    private advance;
+    private check;
+    private match;
+}
+export declare function parseMarkdown(tokens: MarkdownToken[]): MarkdownDocument;

package/dist/types/Markdown/MarkdownToGreenNode.d.ts

@@ -0,0 +1,6 @@
+import { GreenNode } from '../Syntax/GreenNode';
+import { RedNode } from '../Syntax/RedNode';
+import type { MarkdownNode } from './MarkdownAST';
+export declare function markdownAstToGreenTree(root: MarkdownNode): GreenNode;
+export declare function greenToRedNode(green: GreenNode, parent?: RedNode | null): RedNode;
+export declare function markdownAstToRedTree(root: MarkdownNode): RedNode;

package/dist/types/MilHibri/MilHibriDocumentModel.d.ts

@@ -0,0 +1,21 @@
+import { DocumentModel, type DocumentModelOptions } from '../Model/DocumentModel';
+import { GreenNode } from '../Syntax/GreenNode';
+import { RedNode } from '../Syntax/RedNode';
+export interface MilHibriDocumentModelOptions extends DocumentModelOptions {
+    source?: string;
+}
+/**
+ * DocumentEngine — MilHibriDocumentModel
+ *
+ * First-class DocumentModel for the MilHibri language:
+ * Unifies 100% of osu! BBCode and 100% of Markdown + Modern Industry Extensions
+ * into a single unified, collision-free AST.
+ */
+export declare class MilHibriDocumentModel extends DocumentModel {
+    constructor(options?: MilHibriDocumentModelOptions);
+    static fromSource(source: string): MilHibriDocumentModel;
+    protected parseToGreen(source: string): GreenNode;
+    protected buildRedFromGreen(green: GreenNode): RedNode;
+    applyTextUpdate(newSource: string): void;
+    applyChange(change: any): void;
+}