@fuzdev/mdz 0.1.0

package/dist/mdz_stream_parser_text.js

@@ -0,0 +1,67 @@
+/**
+ * Plain-text run consumption for the streaming mdz parser.
+ *
+ * @module
+ */
+import { ASTERISK, BACKTICK, HTTPS_PREFIX_LENGTH, H_LOWER, H_UPPER, LEFT_ANGLE, LEFT_BRACKET, NEWLINE, PERIOD, RIGHT_BRACKET, SLASH, SPACE, TAB, TILDE, UNDERSCORE, is_word_char, match_url_prefix_case_insensitive, } from './mdz_helpers.js';
+import { accumulate_text, ensure_paragraph, offset, } from './mdz_stream_parser_state.js';
+/**
+ * Consume a delimiter at the current position as literal text — the shared
+ * tail of every "this delimiter doesn't open/close anything here" decision
+ * (failed boundary, EOF degrade, greedy-rejected closer, lone `*`/`]`).
+ *
+ * @mutates `state`
+ * @nodocs
+ */
+export const consume_delimiter_as_text = (state, delimiter) => {
+    ensure_paragraph(state);
+    accumulate_text(state, delimiter, offset(state));
+    state.prev_char = delimiter.charCodeAt(delimiter.length - 1);
+    state.column += delimiter.length;
+    state.pos += delimiter.length;
+};
+/**
+ * Consume a run of plain text characters. Scans ahead to the next
+ * structurally interesting character and accumulates the whole run
+ * as a single slice, avoiding per-character string concatenation
+ * and dispatch overhead.
+ *
+ * @nodocs
+ */
+export const consume_text_run = (state) => {
+    ensure_paragraph(state);
+    const start = state.pos;
+    state.pos++;
+    while (state.pos < state.buffer.length) {
+        const c = state.buffer.charCodeAt(state.pos);
+        if (c === BACKTICK ||
+            c === ASTERISK ||
+            c === UNDERSCORE ||
+            c === TILDE ||
+            c === LEFT_BRACKET ||
+            c === RIGHT_BRACKET ||
+            c === LEFT_ANGLE ||
+            c === NEWLINE ||
+            // URL/path: only break when actually at a URL or path start.
+            // Most h/H/./slash in prose are not URLs/paths — continuing the scan
+            // avoids the full dispatch cycle through process_loop → process_inline.
+            // For `h`/`H` at a word boundary, also break when there isn't enough
+            // buffer left to confirm `https://` / `http://` — process_inline's
+            // speculator then carries the prefix match across chunk boundaries.
+            // Scheme matching is case-insensitive (RFC 3986).
+            ((c === H_LOWER || c === H_UPPER) &&
+                (match_url_prefix_case_insensitive(state.buffer, state.pos) > 0 ||
+                    (state.buffer.length - state.pos < HTTPS_PREFIX_LENGTH &&
+                        !is_word_char(state.buffer.charCodeAt(state.pos - 1))))) ||
+            ((c === SLASH || c === PERIOD) &&
+                (state.buffer.charCodeAt(state.pos - 1) === SPACE ||
+                    state.buffer.charCodeAt(state.pos - 1) === NEWLINE ||
+                    state.buffer.charCodeAt(state.pos - 1) === TAB))) {
+            break;
+        }
+        state.pos++;
+    }
+    accumulate_text(state, state.buffer.slice(start, state.pos), offset(state, start));
+    state.prev_char = state.buffer.charCodeAt(state.pos - 1);
+    state.column += state.pos - start;
+};

package/dist/mdz_stream_parser_url.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Auto-URL and auto-path handlers (text-first scanning) for the streaming
+ * mdz parser. Operates in two phases:
+ *
+ *  1. Speculative prefix matching: chars stream as visible text while we
+ *     verify a `https://` / `http://` prefix.
+ *  2. Confirmed mode: chars stream as text and on terminator a `wrap`
+ *     opcode retroactively wraps the text node in a Link.
+ *
+ * Paths (`/...`, `./...`, `../...`) skip phase 1 — their prefix is validated
+ * by hold (require enough lookahead).
+ *
+ * @module
+ */
+import { type MdzStreamParserState, type TryResult } from './mdz_stream_parser_state.js';
+/**
+ * Forced-mode URL detection: the full prefix must be in the buffer.
+ * Used at EOF when speculative prefix matching isn't needed.
+ * Scheme match is case-insensitive (RFC 3986).
+ *
+ * @nodocs
+ */
+export declare const try_auto_url_forced: (state: MdzStreamParserState) => TryResult;
+/** @nodocs */
+export declare const try_auto_path_absolute: (state: MdzStreamParserState, forced?: boolean) => TryResult;
+/** @nodocs */
+export declare const try_auto_path_relative: (state: MdzStreamParserState, forced?: boolean) => TryResult;
+/**
+ * Start confirmed text-first mode for paths. Prefix already validated by hold.
+ * Flushes prior text, resets active_text_id, sets pending_url with confirmed=true.
+ *
+ * @nodocs
+ */
+export declare const start_pending_url: (state: MdzStreamParserState, link_type: "external" | "internal") => void;
+/**
+ * Start speculative text-first mode for URL prefixes.
+ * Chars stream as visible text while we verify `https://` or `http://`.
+ * Cancels if prefix doesn't match (text stays as plain text).
+ *
+ * @nodocs
+ */
+export declare const start_speculative_url: (state: MdzStreamParserState) => void;
+/**
+ * Speculative URL prefix matching. Checks each char against viable prefixes,
+ * streaming as text. Confirms on full match, cancels on mismatch.
+ *
+ * Scheme letters (`h`, `t`, `p`, `s`) are matched case-insensitively (RFC 3986);
+ * the `:` and `//` portion remains literal. Original casing is preserved in
+ * the emitted reference.
+ *
+ * @nodocs
+ */
+export declare const process_url_prefix: (state: MdzStreamParserState) => void;
+/**
+ * Process URL/path chars in text-first mode. Scans path chars,
+ * accumulates as visible text. Terminates on space/newline/non-path-char
+ * and emits a `wrap` opcode.
+ *
+ * @nodocs
+ */
+export declare const process_url_content: (state: MdzStreamParserState, forced: boolean) => void;
+/**
+ * Complete a pending URL: compute reference with trimmed punctuation,
+ * emit a `wrap` opcode to retroactively wrap the text node in a Link.
+ *
+ * @nodocs
+ */
+export declare const complete_pending_url: (state: MdzStreamParserState) => void;
+/**
+ * Forced-mode auto-link: scan the full URL/path inline (no streaming needed
+ * at EOF). Used when forced=true — the entire URL must be in the buffer.
+ *
+ * @nodocs
+ */
+export declare const scan_auto_link_forced: (state: MdzStreamParserState, link_type: "external" | "internal") => TryResult;
+//# sourceMappingURL=mdz_stream_parser_url.d.ts.map

package/dist/mdz_stream_parser_url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mdz_stream_parser_url.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_stream_parser_url.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAcH,OAAO,EACN,KAAK,oBAAoB,EACzB,KAAK,SAAS,EAOd,MAAM,8BAA8B,CAAC;AAKtC;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,GAAI,OAAO,oBAAoB,KAAG,SAYjE,CAAC;AAEF,cAAc;AACd,eAAO,MAAM,sBAAsB,GAAI,OAAO,oBAAoB,EAAE,gBAAc,KAAG,SAqBpF,CAAC;AAEF,cAAc;AACd,eAAO,MAAM,sBAAsB,GAAI,OAAO,oBAAoB,EAAE,gBAAc,KAAG,SAyCpF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,GAC7B,OAAO,oBAAoB,EAC3B,WAAW,UAAU,GAAG,UAAU,KAChC,IAaF,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,GAAI,OAAO,oBAAoB,KAAG,IAYnE,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB,GAAI,OAAO,oBAAoB,KAAG,IAwChE,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,GAAI,OAAO,oBAAoB,EAAE,QAAQ,OAAO,KAAG,IAoClF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,GAAI,OAAO,oBAAoB,KAAG,IAqDlE,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,GACjC,OAAO,oBAAoB,EAC3B,WAAW,UAAU,GAAG,UAAU,KAChC,SA2CF,CAAC"}

package/dist/mdz_stream_parser_url.js

@@ -0,0 +1,328 @@
+/**
+ * Auto-URL and auto-path handlers (text-first scanning) for the streaming
+ * mdz parser. Operates in two phases:
+ *
+ *  1. Speculative prefix matching: chars stream as visible text while we
+ *     verify a `https://` / `http://` prefix.
+ *  2. Confirmed mode: chars stream as text and on terminator a `wrap`
+ *     opcode retroactively wraps the text node in a Link.
+ *
+ * Paths (`/...`, `./...`, `../...`) skip phase 1 — their prefix is validated
+ * by hold (require enough lookahead).
+ *
+ * @module
+ */
+import { NEWLINE, SPACE, TAB, PERIOD, SLASH, ascii_to_lower, is_valid_path_char, is_word_char, match_url_prefix_case_insensitive, mdz_trim_url_punctuation, } from './mdz_helpers.js';
+import { accumulate_text, alloc_id, emit, ensure_paragraph, flush_text, offset, } from './mdz_stream_parser_state.js';
+const HTTPS_PREFIX = 'https://';
+const HTTP_PREFIX = 'http://';
+/**
+ * Forced-mode URL detection: the full prefix must be in the buffer.
+ * Used at EOF when speculative prefix matching isn't needed.
+ * Scheme match is case-insensitive (RFC 3986).
+ *
+ * @nodocs
+ */
+export const try_auto_url_forced = (state) => {
+    if (state.prev_char !== -1 && is_word_char(state.prev_char))
+        return 'not_match';
+    const prefix_len = match_url_prefix_case_insensitive(state.buffer, state.pos);
+    if (prefix_len === 0)
+        return 'not_match';
+    // must have content after protocol
+    if (state.pos + prefix_len >= state.buffer.length)
+        return 'not_match';
+    const after = state.buffer.charCodeAt(state.pos + prefix_len);
+    if (after === SPACE || after === NEWLINE)
+        return 'not_match';
+    return scan_auto_link_forced(state, 'external');
+};
+/** @nodocs */
+export const try_auto_path_absolute = (state, forced = false) => {
+    // must be at word boundary (preceded by space/newline/start)
+    if (state.prev_char !== -1 &&
+        state.prev_char !== SPACE &&
+        state.prev_char !== NEWLINE &&
+        state.prev_char !== TAB) {
+        return 'not_match';
+    }
+    // reject // and /space
+    if (state.pos + 1 >= state.buffer.length)
+        return forced ? 'not_match' : 'need_more';
+    const next = state.buffer.charCodeAt(state.pos + 1);
+    if (next === SLASH || next === SPACE || next === NEWLINE || next === TAB) {
+        return 'not_match';
+    }
+    if (forced)
+        return scan_auto_link_forced(state, 'internal');
+    start_pending_url(state, 'internal');
+    return 'consumed';
+};
+/** @nodocs */
+export const try_auto_path_relative = (state, forced = false) => {
+    if (state.prev_char !== -1 &&
+        state.prev_char !== SPACE &&
+        state.prev_char !== NEWLINE &&
+        state.prev_char !== TAB) {
+        return 'not_match';
+    }
+    // check for ./ or ../
+    const remaining = state.buffer.length - state.pos;
+    if (remaining < 3)
+        return forced ? 'not_match' : 'need_more';
+    if (state.buffer.charCodeAt(state.pos + 1) === PERIOD &&
+        state.buffer.charCodeAt(state.pos + 2) === SLASH) {
+        // ../
+        if (remaining < 4)
+            return forced ? 'not_match' : 'need_more';
+        const after = state.buffer.charCodeAt(state.pos + 3);
+        if (after === SPACE || after === NEWLINE || after === TAB || after === SLASH) {
+            return 'not_match';
+        }
+        if (forced)
+            return scan_auto_link_forced(state, 'internal');
+        start_pending_url(state, 'internal');
+        return 'consumed';
+    }
+    if (state.buffer.charCodeAt(state.pos + 1) === SLASH) {
+        // ./
+        const after = state.buffer.charCodeAt(state.pos + 2);
+        if (after === SPACE || after === NEWLINE || after === TAB || after === SLASH) {
+            return 'not_match';
+        }
+        if (forced)
+            return scan_auto_link_forced(state, 'internal');
+        start_pending_url(state, 'internal');
+        return 'consumed';
+    }
+    return 'not_match';
+};
+/**
+ * Start confirmed text-first mode for paths. Prefix already validated by hold.
+ * Flushes prior text, resets active_text_id, sets pending_url with confirmed=true.
+ *
+ * @nodocs
+ */
+export const start_pending_url = (state, link_type) => {
+    flush_text(state);
+    ensure_paragraph(state);
+    state.active_text_id = null;
+    state.pending_url = {
+        url_text: '',
+        start: offset(state),
+        link_type,
+        confirmed: true,
+        viable_https: false,
+        viable_http: false,
+    };
+    // don't advance pos — URL chars start at current position, handled by process_url_content
+};
+/**
+ * Start speculative text-first mode for URL prefixes.
+ * Chars stream as visible text while we verify `https://` or `http://`.
+ * Cancels if prefix doesn't match (text stays as plain text).
+ *
+ * @nodocs
+ */
+export const start_speculative_url = (state) => {
+    flush_text(state);
+    ensure_paragraph(state);
+    state.active_text_id = null;
+    state.pending_url = {
+        url_text: '',
+        start: offset(state),
+        link_type: 'external',
+        confirmed: false,
+        viable_https: true,
+        viable_http: true,
+    };
+};
+/**
+ * Speculative URL prefix matching. Checks each char against viable prefixes,
+ * streaming as text. Confirms on full match, cancels on mismatch.
+ *
+ * Scheme letters (`h`, `t`, `p`, `s`) are matched case-insensitively (RFC 3986);
+ * the `:` and `//` portion remains literal. Original casing is preserved in
+ * the emitted reference.
+ *
+ * @nodocs
+ */
+export const process_url_prefix = (state) => {
+    const pu = state.pending_url;
+    const char_code = state.buffer.charCodeAt(state.pos);
+    const pos = pu.url_text.length;
+    // scheme letters (positions 0-4) match case-insensitively;
+    // `:` and `/` (positions 5-7 for https, 4-6 for http) are literal.
+    const cmp_code = pos < 5 ? ascii_to_lower(char_code) : char_code;
+    // narrow viable prefixes
+    if (pu.viable_https &&
+        (pos >= HTTPS_PREFIX.length || cmp_code !== HTTPS_PREFIX.charCodeAt(pos))) {
+        pu.viable_https = false;
+    }
+    if (pu.viable_http && (pos >= HTTP_PREFIX.length || cmp_code !== HTTP_PREFIX.charCodeAt(pos))) {
+        pu.viable_http = false;
+    }
+    if (!pu.viable_https && !pu.viable_http) {
+        // no viable prefix — cancel speculation, don't consume char
+        state.pending_url = null;
+        return;
+    }
+    // char matches — accumulate as text
+    accumulate_text(state, state.buffer[state.pos], offset(state));
+    pu.url_text += state.buffer[state.pos];
+    state.pos++;
+    state.column++;
+    state.prev_char = char_code;
+    // check if a prefix is fully confirmed
+    if ((pu.viable_https && pos + 1 === HTTPS_PREFIX.length) ||
+        (pu.viable_http && pos + 1 === HTTP_PREFIX.length)) {
+        pu.confirmed = true;
+    }
+};
+/**
+ * Process URL/path chars in text-first mode. Scans path chars,
+ * accumulates as visible text. Terminates on space/newline/non-path-char
+ * and emits a `wrap` opcode.
+ *
+ * @nodocs
+ */
+export const process_url_content = (state, forced) => {
+    // speculative prefix matching phase
+    if (!state.pending_url.confirmed) {
+        process_url_prefix(state);
+        return;
+    }
+    const char_code = state.buffer.charCodeAt(state.pos);
+    // URL terminator
+    if (char_code === SPACE || char_code === NEWLINE || !is_valid_path_char(char_code)) {
+        flush_text(state);
+        complete_pending_url(state);
+        // don't consume terminator — outer loop handles it
+        return;
+    }
+    // scan URL chars
+    const start = state.pos;
+    state.pos++;
+    while (state.pos < state.buffer.length) {
+        const c = state.buffer.charCodeAt(state.pos);
+        if (c === SPACE || c === NEWLINE || !is_valid_path_char(c))
+            break;
+        state.pos++;
+    }
+    const text = state.buffer.slice(start, state.pos);
+    accumulate_text(state, text, offset(state, start));
+    state.pending_url.url_text += text;
+    state.prev_char = state.buffer.charCodeAt(state.pos - 1);
+    state.column += state.pos - start;
+    // at EOF in forced mode, finalize the URL
+    if (state.pos >= state.buffer.length && forced) {
+        flush_text(state);
+        complete_pending_url(state);
+    }
+};
+/**
+ * Complete a pending URL: compute reference with trimmed punctuation,
+ * emit a `wrap` opcode to retroactively wrap the text node in a Link.
+ *
+ * @nodocs
+ */
+export const complete_pending_url = (state) => {
+    const pu = state.pending_url;
+    state.pending_url = null;
+    // unconfirmed speculative prefix (e.g. a trailing `ht` at EOF) can never
+    // become a URL — paths start confirmed, URLs confirm only on a full
+    // `https://`/`http://` match; text stays as plain text
+    if (!pu.confirmed)
+        return;
+    const reference = mdz_trim_url_punctuation(pu.url_text);
+    if (reference.length === 0)
+        return; // empty after trimming — text stays as plain text
+    // for external URLs, must have content after protocol prefix
+    if (pu.link_type === 'external') {
+        const prefix_len = match_url_prefix_case_insensitive(reference, 0);
+        if (reference.length < prefix_len + 1)
+            return; // just protocol, no content
+    }
+    const text_id = state.active_text_id;
+    if (text_id === null)
+        return; // no text node to wrap (shouldn't happen)
+    const trim_end = pu.url_text.length - reference.length;
+    const wrap_id = alloc_id(state);
+    const url_end = pu.start + reference.length;
+    if (trim_end > 0) {
+        const trim_id = alloc_id(state);
+        emit(state, {
+            type: 'wrap',
+            id: wrap_id,
+            node_type: 'Link',
+            target_id: text_id,
+            reference,
+            link_type: pu.link_type,
+            start: pu.start,
+            end: url_end,
+            trim_end,
+            trim_id,
+        });
+        state.active_text_id = trim_id;
+    }
+    else {
+        emit(state, {
+            type: 'wrap',
+            id: wrap_id,
+            node_type: 'Link',
+            target_id: text_id,
+            reference,
+            link_type: pu.link_type,
+            start: pu.start,
+            end: url_end,
+        });
+        state.active_text_id = null;
+    }
+};
+/**
+ * Forced-mode auto-link: scan the full URL/path inline (no streaming needed
+ * at EOF). Used when forced=true — the entire URL must be in the buffer.
+ *
+ * @nodocs
+ */
+export const scan_auto_link_forced = (state, link_type) => {
+    let i = state.pos;
+    while (i < state.buffer.length) {
+        const c = state.buffer.charCodeAt(i);
+        if (c === SPACE || c === NEWLINE || !is_valid_path_char(c))
+            break;
+        i++;
+    }
+    let reference = state.buffer.slice(state.pos, i);
+    reference = mdz_trim_url_punctuation(reference);
+    if (reference.length === 0)
+        return 'not_match';
+    // for external URLs, must have content after protocol prefix
+    if (link_type === 'external') {
+        const prefix_len = match_url_prefix_case_insensitive(reference, 0);
+        if (reference.length < prefix_len + 1)
+            return 'not_match';
+    }
+    const end_pos = state.pos + reference.length;
+    const link_start = offset(state);
+    const link_end = offset(state, end_pos);
+    flush_text(state);
+    ensure_paragraph(state);
+    const link_id = alloc_id(state);
+    emit(state, { type: 'open', id: link_id, node_type: 'Link', start: link_start });
+    const text_id = alloc_id(state);
+    emit(state, {
+        type: 'text',
+        id: text_id,
+        content: reference,
+        text_type: 'Text',
+        start: link_start,
+        end: link_end,
+    });
+    emit(state, { type: 'close', id: link_id, end: link_end, reference, link_type });
+    state.active_text_id = null;
+    state.column += end_pos - state.pos;
+    state.prev_char = reference.charCodeAt(reference.length - 1);
+    state.pos = end_pos;
+    return 'consumed';
+};

package/dist/mdz_stream_state.svelte.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Reactive state for the mdz streaming renderer.
+ *
+ * Maintains a reactive tree of `MdzStreamNode` objects that Svelte 5 can
+ * efficiently update. Opcodes from `MdzStreamParser` are applied via
+ * `apply()` or `apply_batch()`, mutating the tree in place.
+ *
+ * @module
+ */
+import type { MdzNodeId, MdzNodeType, MdzOpcode } from './mdz_opcodes.js';
+/**
+ * A reactive node in the stream renderer tree.
+ * Fields are `$state` so Svelte re-renders only what changes.
+ */
+export declare class MdzStreamNode {
+    id: MdzNodeId;
+    type: MdzNodeType;
+    content: string;
+    children: Array<MdzStreamNode>;
+    level?: 1 | 2 | 3 | 4 | 5 | 6;
+    reference?: string;
+    link_type?: 'external' | 'internal';
+    name?: string;
+    lang?: string | null;
+    heading_id?: string;
+    ordered?: boolean;
+    start_number?: number;
+    number?: number;
+    constructor(id: MdzNodeId, type: MdzNodeType);
+}
+/**
+ * Reactive state manager for streaming mdz content.
+ * Apply opcodes to incrementally build and update the render tree.
+ *
+ * Lifecycle: one state instance per stream, paired with one `MdzStreamParser`.
+ * Opcodes must be applied exactly once, in emission order — `take_opcodes()`
+ * batches can be split or concatenated freely, but never reordered, skipped,
+ * or replayed. There is no `reset()`; to restart a stream, construct a new
+ * parser and a new state.
+ */
+export declare class MdzStreamState {
+    #private;
+    root: Array<MdzStreamNode>;
+    /**
+     * Apply a single opcode.
+     */
+    apply(opcode: MdzOpcode): void;
+    /**
+     * Apply a batch of opcodes.
+     */
+    apply_batch(opcodes: Array<MdzOpcode>): void;
+}
+//# sourceMappingURL=mdz_stream_state.svelte.d.ts.map

package/dist/mdz_stream_state.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mdz_stream_state.svelte.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_stream_state.svelte.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,KAAK,EAAC,SAAS,EAAE,WAAW,EAAE,SAAS,EAAC,MAAM,kBAAkB,CAAC;AAExE;;;GAGG;AACH,qBAAa,aAAa;IACzB,EAAE,EAAE,SAAS,CAAC;IACd,IAAI,EAAE,WAAW,CAAC;IAClB,OAAO,EAAE,MAAM,CAAc;IAC7B,QAAQ,EAAE,KAAK,CAAC,aAAa,CAAC,CAAc;IAE5C,KAAK,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAY;IAC9B,SAAS,CAAC,EAAE,UAAU,GAAG,UAAU,CAAY;IAC/C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAY;IAC/B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;gBAEJ,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,WAAW;CAI5C;AAED;;;;;;;;;GASG;AACH,qBAAa,cAAc;;IAC1B,IAAI,EAAE,KAAK,CAAC,aAAa,CAAC,CAAc;IAqCxC;;OAEG;IACH,KAAK,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI;IA2R9B;;OAEG;IACH,WAAW,CAAC,OAAO,EAAE,KAAK,CAAC,SAAS,CAAC,GAAG,IAAI;CAK5C"}