@c2-markdown-ui/mdui-lang 0.0.0-stage → 0.4.3

package/dist/parser.js

@@ -0,0 +1,2566 @@
+// Known widget types for early detection
+const WIDGET_TYPES = [
+    'text', 'text-input', 'button-group', 'select', 'select-multi', 'radio-group', 'cascade', 'tree-select', 'slider', 'switch', 'date-picker', 'number-input',
+    'form', 'row', 'chart-line', 'chart-bar', 'chart-pie', 'chart-scatter',
+    'multiple-choice-question', 'short-answer-question', 'quiz'
+];
+export class DSLParser {
+    parse(input) {
+        try {
+            const tokens = this.tokenize(input.trim());
+            if (tokens.length === 0) {
+                return { success: false, error: "Empty input" };
+            }
+            const widgetType = tokens[0];
+            switch (widgetType) {
+                case 'text':
+                    return this.parseText(tokens);
+                case 'text-input':
+                    return this.parseTextInput(tokens);
+                case 'button-group':
+                    return this.parseButtonGroup(tokens);
+                case 'button':
+                    return this.parseButton(tokens);
+                case 'select':
+                    return this.parseSelect(tokens);
+                case 'select-multi':
+                    return this.parseSelectMulti(tokens);
+                case 'radio-group':
+                    return this.parseRadioGroup(tokens);
+                case 'cascade':
+                    return this.parseCascade(tokens);
+                case 'tree-select':
+                    return this.parseTreeSelect(tokens);
+                case 'slider':
+                    return this.parseSlider(tokens);
+                case 'switch':
+                    return this.parseSwitch(tokens);
+                case 'date-picker':
+                    return this.parseDatePicker(tokens);
+                case 'number-input':
+                    return this.parseNumberInput(tokens);
+                case 'form':
+                    return this.parseForm(tokens, input);
+                case 'row':
+                    return this.parseRow(tokens, input);
+                case 'chart-line':
+                case 'chart-bar':
+                case 'chart-pie':
+                case 'chart-scatter':
+                    return this.parseChart(tokens, input, widgetType);
+                case 'multiple-choice-question':
+                    return this.parseMultipleChoiceQuestion(tokens);
+                case 'short-answer-question':
+                    return this.parseShortAnswerQuestion(tokens);
+                case 'quiz':
+                    return this.parseQuiz(tokens, input);
+                default:
+                    return { success: false, error: `Unknown widget type: ${widgetType}` };
+            }
+        }
+        catch (error) {
+            return { success: false, error: error instanceof Error ? error.message : String(error) };
+        }
+    }
+    tokenize(input) {
+        const tokens = [];
+        let current = '';
+        let inQuotes = false;
+        let inArray = false;
+        // 数组内容中的引号字符（" 或 '）：引号内的 ] / 空格不截断数组（JSON 字符串值可含 ]）
+        let arrayQuote = '';
+        // 数组内容中的嵌套括号深度（JSON 对象数组 [{...} {...}] 等）
+        let arrayDepth = 0;
+        let i = 0;
+        while (i < input.length) {
+            const char = input[i];
+            if (char === '"' && !inArray) {
+                inQuotes = !inQuotes;
+                i++;
+                continue;
+            }
+            // data[...]/data{...}：紧随 data: 前缀的对象数组/对象作为完整单 token 处理，
+            // 引号内空白/嵌套括号不拆散；外层 ] 或 } 闭合才结束
+            if (!inQuotes && !inArray && current === '' && input.startsWith('data:', i)) {
+                i += 5; // 消费 data:
+                while (i < input.length && (input[i] === ' ' || input[i] === '\t'))
+                    i++;
+                if (i < input.length && (input[i] === '[' || input[i] === '{')) {
+                    const arr = this.scanDataArray(input, i);
+                    tokens.push('data:' + arr);
+                    i += arr.length;
+                    continue;
+                }
+                // 没有 [，回退到普通 token 处理（data 标量，当前无此场景）
+                current = 'data:';
+                // 不 continue，下面的普通分支接着处理
+            }
+            // 仅 token 起始位置的 [ 进入数组模式：数组总是独立 token；
+            // pattern:^1[0-9]{10}$ 这类 key:value 值中的 [ 保持字面字符，避免被拆散
+            if (char === '[' && !inQuotes && !current) {
+                inArray = true;
+                arrayQuote = '';
+                arrayDepth = 0;
+                i++;
+                continue;
+            }
+            if (inArray) {
+                // 引号感知：引号内的 ] / 空格 / 括号都是字面字符（AI 常写单引号，一并支持）
+                if (!arrayQuote && (char === '"' || char === "'")) {
+                    arrayQuote = char;
+                }
+                else if (arrayQuote && char === arrayQuote) {
+                    arrayQuote = '';
+                }
+                else if (!arrayQuote) {
+                    if (char === '[' || char === '{')
+                        arrayDepth++;
+                    else if (char === ']' || char === '}') {
+                        // 嵌套括号未配平时，外层 ] 只是内容字符
+                        if (arrayDepth > 0)
+                            arrayDepth--;
+                    }
+                }
+                // 外层 ] 闭合才结束数组 token
+                if (char === ']' && !arrayQuote && arrayDepth === 0) {
+                    inArray = false;
+                    tokens.push(`[${current.trim()}]`);
+                    current = '';
+                    i++;
+                    continue;
+                }
+                current += char;
+                i++;
+                continue;
+            }
+            if ((char === ' ' || char === '\n') && !inQuotes && !inArray) {
+                if (current.trim()) {
+                    tokens.push(current.trim());
+                    current = '';
+                }
+                i++;
+                continue;
+            }
+            current += char;
+            i++;
+        }
+        if (current.trim()) {
+            tokens.push(current.trim());
+        }
+        return tokens;
+    }
+    /** 从位置 i（指向 [ 或 {）开始，按引号感知 + 深度追踪，返回完整 data:[...]/data:{...} token 串。
+     *  起始是 { 时按对象深度配平；输入被截断（流式未写完）时取到末尾，由 parseCascadeNodes 报错兜底 */
+    scanDataArray(input, i) {
+        const open = input[i];
+        const close = open === '{' ? '}' : ']';
+        let depth = 0;
+        let quote = '';
+        let j = i;
+        for (; j < input.length; j++) {
+            const c = input[j];
+            if (quote) {
+                if (c === quote)
+                    quote = '';
+                continue;
+            }
+            if (c === '"' || c === "'") {
+                quote = c;
+                continue;
+            }
+            if (c === '[' || c === '{')
+                depth++;
+            else if (c === ']' || c === '}') {
+                depth--;
+                if (depth === 0 && c === close) {
+                    j++;
+                    break;
+                }
+            }
+        }
+        return input.slice(i, j);
+    }
+    /**
+     * Normalize array syntax to handle common AI output variations.
+     * Converts formats like ["a","b","c"] or ["a", "b", "c"] to ["a" "b" "c"]
+     */
+    normalizeArraySyntax(arrayToken) {
+        if (!arrayToken.startsWith('[') || !arrayToken.endsWith(']')) {
+            return arrayToken;
+        }
+        const content = arrayToken.slice(1, -1).trim();
+        if (!content)
+            return '[]';
+        // Strategy: Parse the content handling both comma and space separators,
+        // with or without quotes, then reconstruct in canonical format
+        const items = [];
+        let current = '';
+        let inQuotes = false;
+        let quoteChar = '';
+        let i = 0;
+        while (i < content.length) {
+            const char = content[i];
+            // Handle both single and double quotes
+            if ((char === '"' || char === "'") && !inQuotes) {
+                inQuotes = true;
+                quoteChar = char;
+                i++;
+                continue;
+            }
+            if (char === quoteChar && inQuotes) {
+                inQuotes = false;
+                quoteChar = '';
+                i++;
+                continue;
+            }
+            // Comma or space outside quotes = separator
+            if ((char === ',' || char === ' ') && !inQuotes) {
+                if (current.trim()) {
+                    items.push(current.trim());
+                    current = '';
+                }
+                i++;
+                continue;
+            }
+            current += char;
+            i++;
+        }
+        if (current.trim()) {
+            items.push(current.trim());
+        }
+        // Reconstruct in canonical format: [item1 item2 item3]
+        // Quote items that contain spaces
+        const normalized = items.map(item => {
+            if (item.includes(' ')) {
+                return `"${item}"`;
+            }
+            return item;
+        }).join(' ');
+        return `[${normalized}]`;
+    }
+    parseArray(arrayToken) {
+        if (!arrayToken.startsWith('[') || !arrayToken.endsWith(']')) {
+            throw new Error('Invalid array format');
+        }
+        // First normalize the array syntax to handle AI variations
+        const normalizedToken = this.normalizeArraySyntax(arrayToken);
+        const content = normalizedToken.slice(1, -1).trim();
+        if (!content)
+            return [];
+        // Parse array content with support for quoted strings
+        const items = [];
+        let current = '';
+        let inQuotes = false;
+        let i = 0;
+        while (i < content.length) {
+            const char = content[i];
+            if (char === '"') {
+                inQuotes = !inQuotes;
+                i++;
+                continue;
+            }
+            if (char === ' ' && !inQuotes) {
+                if (current.trim()) {
+                    items.push(current.trim());
+                    current = '';
+                }
+                i++;
+                continue;
+            }
+            current += char;
+            i++;
+        }
+        if (current.trim()) {
+            items.push(current.trim());
+        }
+        return items;
+    }
+    /** 从字段 token 中提取 label:/hint:/pattern:/message: 修饰符（key:value 形式，与位置参数顺序无关）
+     *  及 required 布尔标记，返回剩余位置参数（不含类型名）与各修饰值。
+     *  含空格的值写作 key:"含 空格"，tokenize 剥引号后仍是单 token */
+    extractFieldMods(tokens) {
+        const mods = { plain: [] };
+        for (let i = 1; i < tokens.length; i++) {
+            const t = tokens[i];
+            if (t === 'required') {
+                mods.required = true;
+            }
+            else if (t === 'disabled') {
+                mods.disabled = true;
+            }
+            else if (t === 'lazy') {
+                // 级联懒加载标记（url 模式下点击父级后逐级请求子级）
+                mods.lazy = true;
+            }
+            else if (t === 'multiple') {
+                // tree-select 多选模式（antd multiple，默认单选）
+                mods.multiple = true;
+            }
+            else if (t === 'checkStrictly') {
+                // tree-select 父子节点选中不关联（antd checkStrictly）
+                mods.checkStrictly = true;
+            }
+            else if (t === 'treeLine') {
+                // tree-select 树连接线（antd treeLine）
+                mods.treeLine = true;
+            }
+            else if (t.startsWith('maxTagCount:')) {
+                // tree-select 触发器最多显示的标签数（antd maxTagCount）
+                const n = parseInt(t.split(':')[1]);
+                if (!isNaN(n) && n >= 0)
+                    mods.maxTagCount = n;
+            }
+            else if (t.startsWith('strategy:')) {
+                // tree-select 选中值回显策略（antd showCheckedStrategy）
+                const s = t.split(':')[1];
+                if (s === 'all' || s === 'parent' || s === 'child')
+                    mods.checkedStrategy = s;
+            }
+            else if (t === 'searchable') {
+                // select / tree-select 可搜索标记（下拉面板内置搜索框）
+                mods.searchable = true;
+            }
+            else if (t === 'button') {
+                // radio-group 按钮样式标记（渲染为按钮组而非圆点单选）
+                mods.button = true;
+            }
+            else if (t === 'horizontal') {
+                // select-multi 选项横向排列
+                mods.direction = 'horizontal';
+            }
+            else if (t === 'vertical') {
+                // select-multi 选项纵向排列（默认，显式写也支持）
+                mods.direction = 'vertical';
+            }
+            else if (t.startsWith('direction:')) {
+                const d = t.split(':')[1]?.toLowerCase();
+                if (d === 'horizontal' || d === 'vertical')
+                    mods.direction = d;
+            }
+            else if (t.startsWith('columns:')) {
+                // select-multi 自定义布局：每行列数（≥1）
+                const n = parseInt(t.split(':')[1]);
+                if (!isNaN(n) && n >= 1)
+                    mods.columns = n;
+            }
+            else if (t.startsWith('label:')) {
+                mods.label = t.slice('label:'.length);
+            }
+            else if (t.startsWith('hint:')) {
+                mods.hint = t.slice('hint:'.length);
+            }
+            else if (t.startsWith('pattern:')) {
+                mods.pattern = t.slice('pattern:'.length);
+            }
+            else if (t.startsWith('message:')) {
+                mods.message = t.slice('message:'.length);
+            }
+            else if (t.startsWith('url:')) {
+                // url:"" 表示远端模式但路径待填（空串是合法值，不能被当作"未设置"）
+                mods.url = t.slice('url:'.length);
+            }
+            else if (t.startsWith('data:[') || t.startsWith('data:{')) {
+                // 级联嵌套对象树数据源：data:[{"value":...} ...] 或 data:{...}（保留原样交给 parseCascadeNodes 解析）
+                mods.data = t.slice('data:'.length);
+            }
+            else if (t.startsWith('placeholder:')) {
+                mods.placeholder = t.slice('placeholder:'.length);
+            }
+            else if (t.startsWith('checkedText:')) {
+                // switch 选中时文案（antd checkedChildren）
+                mods.checkedText = t.slice('checkedText:'.length);
+            }
+            else if (t.startsWith('unCheckedText:')) {
+                // switch 未选中时文案（antd unCheckedChildren）
+                mods.unCheckedText = t.slice('unCheckedText:'.length);
+            }
+            else {
+                mods.plain.push(t);
+            }
+        }
+        return mods;
+    }
+    parseTextInput(tokens) {
+        const mods = this.extractFieldMods(tokens);
+        const plain = mods.plain;
+        if (plain.length < 1) {
+            return { success: false, error: "text-input requires at least an id" };
+        }
+        const widget = {
+            type: "text-input",
+            id: plain[0]
+        };
+        if (plain.length > 1)
+            widget.label = plain[1];
+        if (plain.length > 2)
+            widget.placeholder = plain[2];
+        if (plain.length > 3)
+            widget.default = plain[3];
+        if (mods.label)
+            widget.label = mods.label;
+        if (mods.hint)
+            widget.hint = mods.hint;
+        if (mods.required)
+            widget.required = true;
+        if (mods.pattern)
+            widget.pattern = mods.pattern;
+        if (mods.message)
+            widget.message = mods.message;
+        if (mods.disabled)
+            widget.disabled = true;
+        return { success: true, widget };
+    }
+    /** 解析单个按钮：button id "文字" color:#3b82f6 size:large */
+    /** 纯文字组件：text [id] "内容" [size:N] [color:xx] [bold] [align:xx]
+     *  非参数 token：1 个=纯内容（id 自动生成）；≥2 个=第一个是 id，第二个是内容 */
+    parseText(tokens) {
+        const widget = { type: "text", text: "" };
+        const plainTokens = [];
+        for (let i = 1; i < tokens.length; i++) {
+            const t = tokens[i];
+            if (t.startsWith('size:')) {
+                const s = parseFloat(t.split(':')[1]);
+                if (!isNaN(s) && s >= 12 && s <= 48)
+                    widget.size = s;
+            }
+            else if (t.startsWith('color:')) {
+                widget.color = t.slice('color:'.length);
+            }
+            else if (t === 'bold') {
+                widget.bold = true;
+            }
+            else if (t.startsWith('align:')) {
+                const a = t.split(':')[1]?.toLowerCase();
+                if (a === 'left' || a === 'center' || a === 'right')
+                    widget.align = a;
+            }
+            else if (t === 'alert') {
+                widget.alert = true;
+            }
+            else if (t.startsWith('alertStyle:')) {
+                const s = t.split(':')[1]?.toLowerCase();
+                if (s === 'info' || s === 'warning' || s === 'error') {
+                    widget.alert = true;
+                    widget.alertStyle = s;
+                }
+            }
+            else {
+                plainTokens.push(t);
+            }
+        }
+        if (plainTokens.length === 0) {
+            return { success: false, error: "text requires content" };
+        }
+        if (plainTokens.length >= 2) {
+            widget.id = plainTokens[0];
+            widget.text = plainTokens[1];
+        }
+        else {
+            widget.text = plainTokens[0];
+        }
+        // id 缺省时用内容生成（col/编辑器定位需要唯一 id）
+        if (!widget.id)
+            widget.id = `text-${widget.text.slice(0, 8).replace(/\s+/g, '-')}`;
+        return { success: true, widget };
+    }
+    parseButton(tokens) {
+        if (tokens.length < 2) {
+            return { success: false, error: "button requires id" };
+        }
+        const widget = {
+            type: "button",
+            id: tokens[1]
+        };
+        // 第 3 个 token 若非 key:value 形式则为文字内容
+        for (let i = 2; i < tokens.length; i++) {
+            const t = tokens[i];
+            if (t.startsWith('color:')) {
+                widget.color = t.slice('color:'.length);
+            }
+            else if (t.startsWith('textColor:')) {
+                widget.textColor = t.slice('textColor:'.length);
+            }
+            else if (t.startsWith('size:')) {
+                const s = t.split(':')[1]?.toLowerCase();
+                if (s === 'small' || s === 'medium' || s === 'large')
+                    widget.size = s;
+            }
+            else if (widget.label === undefined) {
+                widget.label = t;
+            }
+            else if (t === 'disabled') {
+                widget.disabled = true;
+            }
+        }
+        return { success: true, widget };
+    }
+    parseButtonGroup(tokens) {
+        const mods = this.extractFieldMods(tokens);
+        const plain = mods.plain;
+        if (plain.length < 2) {
+            return { success: false, error: "button-group requires id and choices array" };
+        }
+        try {
+            const choices = this.parseArray(plain[1]);
+            const widget = {
+                type: "button-group",
+                id: plain[0],
+                choices
+            };
+            if (plain.length > 2)
+                widget.default = plain[2];
+            if (mods.label)
+                widget.label = mods.label;
+            if (mods.hint)
+                widget.hint = mods.hint;
+            if (mods.required)
+                widget.required = true;
+            if (mods.disabled)
+                widget.disabled = true;
+            return { success: true, widget };
+        }
+        catch (error) {
+            return { success: false, error: `Invalid choices array: ${error}` };
+        }
+    }
+    parseSelect(tokens) {
+        const mods = this.extractFieldMods(tokens);
+        const plain = mods.plain;
+        if (plain.length < 2) {
+            return { success: false, error: "select requires id and choices array" };
+        }
+        try {
+            const choices = this.parseArray(plain[1]);
+            const widget = {
+                type: "select",
+                id: plain[0],
+                choices
+            };
+            if (mods.label)
+                widget.label = mods.label;
+            if (plain.length > 2)
+                widget.default = plain[2];
+            if (mods.hint)
+                widget.hint = mods.hint;
+            if (mods.required)
+                widget.required = true;
+            if (mods.url !== undefined)
+                widget.url = mods.url;
+            if (mods.searchable)
+                widget.searchable = true;
+            if (mods.disabled)
+                widget.disabled = true;
+            return { success: true, widget };
+        }
+        catch (error) {
+            return { success: false, error: `Invalid choices array: ${error}` };
+        }
+    }
+    parseSelectMulti(tokens) {
+        const mods = this.extractFieldMods(tokens);
+        const plain = mods.plain;
+        if (plain.length < 2) {
+            return { success: false, error: "select-multi requires id and choices array" };
+        }
+        try {
+            // 对象数组格式 [{key|value,label} ...]：绕过 parseArray（其逗号/空格拆分会拆碎 JSON），
+            // 走容错 JSON 解析；普通字符串数组仍走 parseArray
+            const choices = this.parseObjectChoices(plain[1]);
+            const widget = {
+                type: "select-multi",
+                id: plain[0],
+                choices
+            };
+            if (mods.label)
+                widget.label = mods.label;
+            if (plain.length > 2) {
+                if (plain[2].startsWith('[')) {
+                    widget.default = this.parseArray(plain[2]);
+                }
+                else {
+                    widget.default = plain[2];
+                }
+            }
+            if (mods.hint)
+                widget.hint = mods.hint;
+            if (mods.required)
+                widget.required = true;
+            if (mods.message)
+                widget.message = mods.message;
+            if (mods.url !== undefined)
+                widget.url = mods.url;
+            if (mods.disabled)
+                widget.disabled = true;
+            if (mods.direction)
+                widget.direction = mods.direction;
+            if (mods.columns !== undefined)
+                widget.columns = mods.columns;
+            return { success: true, widget };
+        }
+        catch (error) {
+            return { success: false, error: `Invalid format: ${error}` };
+        }
+    }
+    /** 解析单选组件：radio-group id [choices] [default] [button] [label:xx] [hint:xx] [required]
+     *  [message:xx] [url:xx] [direction:horizontal|vertical] [columns:N] [disabled]
+     *  choices 兼容字符串数组（key:label）与对象数组（{key|value,label}）；default 为单值；
+     *  button 标记切换为按钮组样式（参考 antd Radio optionType:button） */
+    parseRadioGroup(tokens) {
+        const mods = this.extractFieldMods(tokens);
+        const plain = mods.plain;
+        if (plain.length < 2) {
+            return { success: false, error: "radio-group requires id and choices array" };
+        }
+        try {
+            // 对象数组格式与 select-multi 一致：走容错 JSON 解析
+            const choices = this.parseObjectChoices(plain[1]);
+            const widget = {
+                type: "radio-group",
+                id: plain[0],
+                choices
+            };
+            if (mods.label)
+                widget.label = mods.label;
+            // default 为单值（数组写法取第一项，容错）
+            if (plain.length > 2) {
+                if (plain[2].startsWith('[')) {
+                    const arr = this.parseArray(plain[2]);
+                    if (arr.length > 0)
+                        widget.default = arr[0];
+                }
+                else {
+                    widget.default = plain[2];
+                }
+            }
+            if (mods.button)
+                widget.button = true;
+            if (mods.hint)
+                widget.hint = mods.hint;
+            if (mods.required)
+                widget.required = true;
+            if (mods.message)
+                widget.message = mods.message;
+            if (mods.url !== undefined)
+                widget.url = mods.url;
+            if (mods.disabled)
+                widget.disabled = true;
+            if (mods.direction)
+                widget.direction = mods.direction;
+            if (mods.columns !== undefined)
+                widget.columns = mods.columns;
+            return { success: true, widget };
+        }
+        catch (error) {
+            return { success: false, error: `Invalid format: ${error}` };
+        }
+    }
+    /** 解析 select-multi choices：token 以 [{ 开头视为对象数组（[{key|value,label} ...]），
+     *  容错 JSON 解析（单引号、未引号 key/值、尾逗号、元素间空格分隔、截断补齐）并归一化为
+     *  {value,label} 数组（key 作为 value 别名，value > key）；否则按普通字符串数组解析 */
+    parseObjectChoices(token) {
+        const trimmed = token.trim();
+        // [{ 开头（含 [ { 间空白）视为对象数组
+        if (!/^\[\s*\{/.test(trimmed)) {
+            return this.parseArray(token);
+        }
+        if (trimmed.length <= 4)
+            return [];
+        let parsed;
+        try {
+            parsed = JSON.parse(trimmed);
+        }
+        catch {
+            parsed = this.repairObjectChoices(trimmed);
+        }
+        if (!Array.isArray(parsed)) {
+            throw new Error('对象数组 choices 必须是 [{...} ...] 形式');
+        }
+        // 归一化：value > key 取值，label 缺省回落到 value；字符串条目 value=label
+        const items = [];
+        for (const item of parsed) {
+            if (item === null || item === undefined)
+                continue;
+            if (typeof item === 'string' || typeof item === 'number') {
+                const s = String(item);
+                if (s)
+                    items.push({ value: s, label: s });
+                continue;
+            }
+            if (typeof item !== 'object')
+                continue;
+            const value = item.value ?? item.key;
+            if (value === undefined || value === null || value === '')
+                continue;
+            const valueStr = String(value);
+            const label = item.label !== undefined && item.label !== null && item.label !== ''
+                ? String(item.label)
+                : valueStr;
+            items.push({ value: valueStr, label });
+        }
+        return items;
+    }
+    /** 容错修复对象数组 choices 文本（整体含外层 []），返回解析结果（失败抛错）。
+     *  支持的 AI 风格写法：单引号、\xxx\ 反斜杠引号、未引号 key、未引号字符串值、
+     *  尾逗号、元素间空格分隔（} { → },{）、输入截断自动补齐 */
+    repairObjectChoices(raw) {
+        let s = raw;
+        // 单引号 → 双引号；\xxx\ 反斜杠引号 → "xxx"（成对包裹字符串时）
+        s = s.replace(/'([^']*)'/g, '"$1"');
+        s = s.replace(/\\([^\\]*)\\/g, '"$1"');
+        // 未加引号的 key：{key: / ,key: → 补双引号
+        s = s.replace(/([{,]\s*)([A-Za-z_$][\w$-]*)\s*:/g, '$1"$2":');
+        // 未加引号的字符串值：:a, / :A} / :中文, → 补双引号（true/false/null 保持字面量；中文开头的裸值同样支持）
+        s = s.replace(/(:\s*)([A-Za-z_$\u4e00-\u9fa5][\w$\u4e00-\u9fa5-]*)(\s*[,}\]])/g, (m, p1, p2, p3) => p2 === 'true' || p2 === 'false' || p2 === 'null' ? m : `${p1}"${p2}"${p3}`);
+        // 去掉最后一个元素后的多余逗号（逗号后直接 ] 或 }）
+        s = s.replace(/,(\s*[}\]])/g, '$1');
+        // 数组元素间缺失的逗号：DSL 风格用空格分隔（} { / } " → },{ / },"）
+        s = s.replace(/\}\s*([{"])/g, '},$1');
+        // 字符串中途截断（末尾缺右引号）：补上
+        let inQuote = false;
+        for (const c of s) {
+            if (inQuote) {
+                if (c === '"')
+                    inQuote = false;
+                continue;
+            }
+            if (c === '"')
+                inQuote = true;
+        }
+        if (inQuote)
+            s += '"';
+        // 末尾悬挂逗号/冒号/左括号清除（截断残尾）
+        s = s.replace(/,\s*$/, '').replace(/:\s*$/, '').replace(/([{[]\s*)$/, '');
+        // 栈式配平补齐缺失的闭合符（正确处理 {/[ 交错，流式输入中途状态）
+        const stack = [];
+        let inQ = false;
+        for (const c of s) {
+            if (inQ) {
+                if (c === '"')
+                    inQ = false;
+                continue;
+            }
+            if (c === '"')
+                inQ = true;
+            else if (c === '{' || c === '[')
+                stack.push(c);
+            else if (c === '}' || c === ']')
+                stack.pop();
+        }
+        while (stack.length)
+            s += stack.pop() === '{' ? '}' : ']';
+        try {
+            return JSON.parse(s);
+        }
+        catch (e) {
+            throw new Error(`对象数组 choices 不是合法 JSON：${e instanceof Error ? e.message : e}`);
+        }
+    }
+    /** 解析级联选择器：cascade id [路径数组] [default路径] [label:xx] [hint:xx] [required] [disabled] [placeholder:xx]
+     *  [url:xx] [data:[{...}]]
+     *  静态数据源兼容共存：
+     *  - choices 扁平路径数组：每项用 / 分隔层级，每段支持 key:label（如 zj:浙江/hz:杭州）
+     *  - data 嵌套对象树：CascadeNode[]，如 [{"value":"zj","label":"浙江","children":[...]}]（优先于 choices）
+     *  - data/url 单独出现时（无 choices）也合法：choices 退化为 [] */
+    parseCascade(tokens) {
+        const mods = this.extractFieldMods(tokens);
+        const plain = mods.plain;
+        if (plain.length < 2 && mods.data === undefined && mods.url === undefined) {
+            return { success: false, error: "cascade requires id and choices array" };
+        }
+        try {
+            const choices = plain.length > 1 ? this.parseArray(plain[1]) : [];
+            const widget = {
+                type: "cascade",
+                id: plain[0],
+                choices
+            };
+            // 嵌套对象树数据源（可选，兼容共存：存在时优先于 choices 扁平路径）
+            if (mods.data !== undefined) {
+                widget.data = this.parseCascadeNodes(mods.data);
+            }
+            // 远端数据源 url（可选）
+            if (mods.url !== undefined)
+                widget.url = mods.url;
+            // 懒加载模式（url 存在时生效）：首次只拉根级，点击父级后 url?parent=<value> 逐级请求
+            if (mods.lazy)
+                widget.lazy = true;
+            if (mods.label)
+                widget.label = mods.label;
+            if (plain.length > 2)
+                widget.default = plain[2];
+            if (mods.hint)
+                widget.hint = mods.hint;
+            if (mods.required)
+                widget.required = true;
+            if (mods.message)
+                widget.message = mods.message;
+            if (mods.placeholder)
+                widget.placeholder = mods.placeholder;
+            if (mods.disabled)
+                widget.disabled = true;
+            return { success: true, widget };
+        }
+        catch (error) {
+            return { success: false, error: `Invalid choices array: ${error}` };
+        }
+    }
+    /** 解析树形选择器：tree-select id [路径数组] [default值] [label:xx] [hint:xx] [required] [disabled]
+     *  [placeholder:xx] [url:xx] [data:[{...}]]
+     *  [multiple] [checkStrictly] [strategy:all|parent|child] [maxTagCount:N] [treeLine] [searchable]
+     *  静态数据源兼容共存（与 cascade 一致）；多选/单选对齐 antd（multiple 开启多选，默认单选）；
+     *  searchable 显式开启搜索（默认关闭，对齐 antd showSearch 默认 false） */
+    parseTreeSelect(tokens) {
+        const mods = this.extractFieldMods(tokens);
+        const plain = mods.plain;
+        if (plain.length < 2 && mods.data === undefined && mods.url === undefined) {
+            return { success: false, error: "tree-select requires id and choices array" };
+        }
+        try {
+            const choices = plain.length > 1 ? this.parseArray(plain[1]) : [];
+            const widget = {
+                type: "tree-select",
+                id: plain[0],
+                choices
+            };
+            // 嵌套对象树数据源（可选，优先于 choices）
+            if (mods.data !== undefined) {
+                widget.data = this.parseCascadeNodes(mods.data);
+            }
+            // 远端数据源
+            if (mods.url !== undefined)
+                widget.url = mods.url;
+            // 懒加载模式
+            if (mods.lazy)
+                widget.lazy = true;
+            // 多选模式（antd multiple，默认单选）
+            if (mods.multiple)
+                widget.multiple = true;
+            // 父子节点选中关联（antd checkStrictly：true 为不关联）
+            if (mods.checkStrictly)
+                widget.checkStrictly = true;
+            // 选中值回显策略（antd showCheckedStrategy）
+            if (mods.checkedStrategy)
+                widget.showCheckedStrategy = mods.checkedStrategy;
+            // 触发器最多显示的标签数（antd maxTagCount）
+            if (mods.maxTagCount !== undefined)
+                widget.maxTagCount = mods.maxTagCount;
+            // 树连接线（antd treeLine）
+            if (mods.treeLine)
+                widget.treeLine = true;
+            // 可搜索（antd showSearch，默认关闭）
+            if (mods.searchable)
+                widget.searchable = true;
+            if (mods.label)
+                widget.label = mods.label;
+            if (plain.length > 2) {
+                const rawDefault = plain[2];
+                // 多选模式支持数组 default: ["v1" "v2"]；单选支持单值
+                if (rawDefault.startsWith('[')) {
+                    try {
+                        widget.default = this.parseArray(rawDefault);
+                    }
+                    catch { /* 忽略 */ }
+                }
+                else {
+                    widget.default = rawDefault;
+                }
+            }
+            if (mods.hint)
+                widget.hint = mods.hint;
+            if (mods.required)
+                widget.required = true;
+            if (mods.message)
+                widget.message = mods.message;
+            if (mods.placeholder)
+                widget.placeholder = mods.placeholder;
+            if (mods.disabled)
+                widget.disabled = true;
+            return { success: true, widget };
+        }
+        catch (error) {
+            return { success: false, error: `Invalid tree-select: ${error}` };
+        }
+    }
+    /** 把 data:[...] token 解析为嵌套对象树（CascadeNode[]）。token 形如 [{...}] / {...}（data: 前缀已被 extractFieldMods 剥除）。
+     *  先按严格 JSON 解析；失败再容错修复 AI 风格写法：
+     *  - 单引号 → 双引号；反斜杠引号 \xxx\ → "xxx"（键值两侧成对出现时）
+     *  - 未加引号的 key（{value: / ,value: / ,children: → 补双引号）
+     *  - 行尾/值后多余逗号；输入被截断（末尾缺引号/]/}）自动补齐
+     *  - value/label 支持数字字面量；字段名兼容 key（key 作为 value 别名，由渲染端 nodesToTree 处理）
+     *  - 顶层是单个对象（{...} 或 {data:[...]} 包裹）时提取其内部数组 */
+    parseCascadeNodes(token) {
+        const trimmed = token.trim();
+        if (!trimmed.startsWith('[') && !trimmed.startsWith('{')) {
+            throw new Error('data 树必须是数组或对象');
+        }
+        if (trimmed.length <= 2)
+            return [];
+        // 先按严格 JSON 解析（合法输入不经过任何容错改写，含 \\ 转义的字符串不受影响）
+        let parsed;
+        try {
+            parsed = JSON.parse(trimmed);
+        }
+        catch {
+            parsed = this.repairCascadeData(trimmed);
+        }
+        if (parsed === undefined || parsed === null) {
+            throw new Error('data 树不是合法 JSON');
+        }
+        // 归一化：数组直接用；单对象 → {data|options|...} 包裹取数组或自身入数组
+        if (!Array.isArray(parsed)) {
+            const list = parsed?.data ?? parsed?.options ?? parsed?.choices ?? parsed?.items ?? parsed?.tree ?? parsed?.treeData;
+            if (Array.isArray(list))
+                return list;
+            if (typeof parsed === 'object')
+                return [parsed];
+            throw new Error('data 树必须是数组');
+        }
+        return parsed;
+    }
+    /** 容错修复 AI 风格/截断的 data 树文本，返回解析结果（失败抛错） */
+    repairCascadeData(raw) {
+        let s = raw;
+        // 单引号 → 双引号；\xxx\ 反斜杠引号 → "xxx"（成对包裹字符串时）
+        s = s.replace(/'([^']*)'/g, '"$1"');
+        s = s.replace(/\\([^\\]*)\\/g, '"$1"');
+        // 未加引号的 key：{value: / ,value: / ,children: → 补双引号
+        s = s.replace(/([{,]\s*)([A-Za-z_$][\w$-]*)\s*:/g, '$1"$2":');
+        // 去掉最后一个元素后的多余逗号（逗号后直接 ] 或 }）
+        s = s.replace(/,(\s*[}\]])/g, '$1');
+        // 字符串中途截断（末尾缺右引号）：补上
+        let inQuote = false;
+        for (const c of s) {
+            if (inQuote) {
+                if (c === '"')
+                    inQuote = false;
+                continue;
+            }
+            if (c === '"')
+                inQuote = true;
+        }
+        if (inQuote)
+            s += '"';
+        // 末尾悬挂逗号/冒号/左括号清除（截断的 "label:\test\," / "children:[" 残尾）
+        s = s.replace(/,\s*$/, '').replace(/:\s*$/, '').replace(/([{[]\s*)$/, '');
+        // 栈式配平补齐缺失的闭合符（正确处理 {/[ 交错，流式输入中途状态）
+        const stack = [];
+        let inQ = false;
+        for (const c of s) {
+            if (inQ) {
+                if (c === '"')
+                    inQ = false;
+                continue;
+            }
+            if (c === '"')
+                inQ = true;
+            else if (c === '{' || c === '[')
+                stack.push(c);
+            else if (c === '}' || c === ']')
+                stack.pop();
+        }
+        while (stack.length)
+            s += stack.pop() === '{' ? '}' : ']';
+        try {
+            return JSON.parse(s);
+        }
+        catch (e) {
+            throw new Error(`data 树不是合法 JSON：${e instanceof Error ? e.message : e}`);
+        }
+    }
+    parseSlider(tokens) {
+        const mods = this.extractFieldMods(tokens);
+        const plain = mods.plain;
+        if (plain.length < 4) {
+            return { success: false, error: "slider requires id, min, max, step" };
+        }
+        const min = parseFloat(plain[1]);
+        const max = parseFloat(plain[2]);
+        const step = parseFloat(plain[3]);
+        if (isNaN(min) || isNaN(max) || isNaN(step)) {
+            return { success: false, error: "min, max, and step must be numbers" };
+        }
+        const widget = {
+            type: "slider",
+            id: plain[0],
+            min,
+            max,
+            step
+        };
+        if (mods.label)
+            widget.label = mods.label;
+        if (plain.length > 4) {
+            const defaultVal = parseFloat(plain[4]);
+            if (!isNaN(defaultVal)) {
+                widget.default = defaultVal;
+            }
+        }
+        if (mods.hint)
+            widget.hint = mods.hint;
+        if (mods.required)
+            widget.required = true;
+        if (mods.disabled)
+            widget.disabled = true;
+        return { success: true, widget };
+    }
+    /** 解析开关：switch id [true|false] [label:xx] [checkedText:xx] [unCheckedText:xx]
+     *  [hint:xx] [required] [disabled]（default 位置参数接受 true/false 字面量） */
+    parseSwitch(tokens) {
+        const mods = this.extractFieldMods(tokens);
+        const plain = mods.plain;
+        if (plain.length < 1) {
+            return { success: false, error: "switch requires id" };
+        }
+        const widget = {
+            type: "switch",
+            id: plain[0]
+        };
+        // default 位置参数：true/false 字面量（大小写不敏感），其他值忽略
+        if (plain.length > 1) {
+            const d = plain[1].toLowerCase();
+            if (d === 'true')
+                widget.default = true;
+            else if (d === 'false')
+                widget.default = false;
+        }
+        if (mods.label)
+            widget.label = mods.label;
+        if (mods.checkedText)
+            widget.checkedText = mods.checkedText;
+        if (mods.unCheckedText)
+            widget.unCheckedText = mods.unCheckedText;
+        if (mods.hint)
+            widget.hint = mods.hint;
+        if (mods.required)
+            widget.required = true;
+        if (mods.disabled)
+            widget.disabled = true;
+        return { success: true, widget };
+    }
+    /** 解析日期选择框：date-picker id [default] [picker:datetime] [range] [format:YYYY-MM-DD]
+     *  [disableBeforeNow] [disableAfterNow] [placeholder:xx] [label:xx] [hint:xx] [required]
+     *  default 接受时间戳（毫秒数字）或格式化时间字符串；range 模式为 [start end] 数组 */
+    parseDatePicker(tokens) {
+        // 先剔除 date-picker 专属修饰符，剩余 token 交给 extractFieldMods（id/default/label/hint/placeholder 等）
+        const ownPrefixes = ['picker:', 'format:'];
+        const ownFlags = new Set(['range', 'disableBeforeNow', 'disableAfterNow']);
+        const rest = [tokens[0]];
+        for (let i = 1; i < tokens.length; i++) {
+            const t = tokens[i];
+            if (ownPrefixes.some(p => t.startsWith(p)) || ownFlags.has(t))
+                continue;
+            rest.push(t);
+        }
+        const mods = this.extractFieldMods(rest);
+        if (mods.plain.length < 1) {
+            return { success: false, error: "date-picker requires at least an id" };
+        }
+        const widget = {
+            type: "date-picker",
+            id: mods.plain[0]
+        };
+        // 剩余位置参数：像日期（时间戳/日期字符串/范围数组）则当 default，否则当 label（与 text-input 等字段约定一致）
+        // date-picker id "标签" 或 date-picker id 1755640800000 均可；label 之后的位置参数为 default
+        const dateLike = (t) => t.startsWith('[') || /^-?\d+$/.test(t) || /^(\d{4})[-/](\d{1,2})[-/](\d{1,2})/.test(t);
+        const restPlain = mods.plain.slice(1);
+        // token（时间戳/日期串/范围数组）→ default 值；时间戳转 Number，数组走 parseArray
+        const toDefault = (d) => {
+            if (d.startsWith('[')) {
+                try {
+                    return this.parseArray(d).map((v) => (/^-?\d+$/.test(v) ? Number(v) : v));
+                }
+                catch {
+                    return undefined;
+                }
+            }
+            return /^-?\d+$/.test(d) ? Number(d) : d;
+        };
+        const defaultIdx = restPlain.findIndex(dateLike);
+        if (defaultIdx === 0) {
+            const v = toDefault(restPlain[0]);
+            if (v !== undefined)
+                widget.default = v;
+        }
+        else if (defaultIdx === 1) {
+            // date-picker id "标签" "2026-08-20"（或 range 数组 ["a", "b"]）
+            widget.label = restPlain[0];
+            const v = toDefault(restPlain[1]);
+            if (v !== undefined)
+                widget.default = v;
+        }
+        else if (defaultIdx === 2) {
+            // date-picker id "标签" "默认值" "2026-08-20"：中间 token 当 label 前缀文案
+            widget.label = restPlain[0] + restPlain[1];
+            const v = toDefault(restPlain[2]);
+            if (v !== undefined)
+                widget.default = v;
+        }
+        else if (defaultIdx === -1 && restPlain.length > 0) {
+            // 无 default：唯一的位置参数是 label
+            widget.label = restPlain[0];
+        }
+        // date-picker 专属 key:value / 布尔修饰符
+        for (let i = 1; i < tokens.length; i++) {
+            const t = tokens[i];
+            if (t === 'range') {
+                widget.range = true;
+            }
+            else if (t === 'disableBeforeNow') {
+                widget.disableBeforeNow = true;
+            }
+            else if (t === 'disableAfterNow') {
+                widget.disableAfterNow = true;
+            }
+            else if (t.startsWith('picker:')) {
+                const p = t.split(':')[1]?.toLowerCase();
+                if (p === 'date' || p === 'datetime')
+                    widget.picker = p;
+            }
+            else if (t.startsWith('format:')) {
+                widget.format = t.slice('format:'.length);
+            }
+        }
+        if (mods.label)
+            widget.label = mods.label;
+        if (mods.hint)
+            widget.hint = mods.hint;
+        if (mods.required)
+            widget.required = true;
+        if (mods.message)
+            widget.message = mods.message;
+        if (mods.placeholder)
+            widget.placeholder = mods.placeholder;
+        if (mods.disabled)
+            widget.disabled = true;
+        return { success: true, widget };
+    }
+    /** 解析数字输入框：number-input id [label] [default] [min:N] [max:N] [step:N] [precision:N]
+     *  [placeholder:xx] [label:xx] [hint:xx] [required] [message:xx]
+     *  label/default 均为位置参数：像数字（整数/小数/负数）的当 default，其余当 label（与 date-picker 约定一致） */
+    parseNumberInput(tokens) {
+        // 先剔除 number-input 专属修饰符（min:/max:/step:/precision: 前缀），剩余交给 extractFieldMods
+        const ownPrefixes = ['min:', 'max:', 'step:', 'precision:'];
+        const rest = [tokens[0]];
+        for (let i = 1; i < tokens.length; i++) {
+            const t = tokens[i];
+            if (ownPrefixes.some(p => t.startsWith(p)))
+                continue;
+            rest.push(t);
+        }
+        const mods = this.extractFieldMods(rest);
+        if (mods.plain.length < 1) {
+            return { success: false, error: "number-input requires at least an id" };
+        }
+        const widget = {
+            type: "number-input",
+            id: mods.plain[0]
+        };
+        // 剩余位置参数：纯数字（含负数/小数）当 default，其余当 label；label 之后的数字为 default
+        const numLike = (t) => /^-?\d+(\.\d+)?$/.test(t);
+        const restPlain = mods.plain.slice(1);
+        const defaultIdx = restPlain.findIndex(numLike);
+        if (defaultIdx === 0) {
+            widget.default = Number(restPlain[0]);
+        }
+        else if (defaultIdx === 1) {
+            // number-input id "标签" 5
+            widget.label = restPlain[0];
+            widget.default = Number(restPlain[1]);
+        }
+        else if (defaultIdx === -1 && restPlain.length > 0) {
+            // 无 default：唯一的位置参数是 label
+            widget.label = restPlain[0];
+        }
+        // number-input 专属 key:value 修饰符
+        for (let i = 1; i < tokens.length; i++) {
+            const t = tokens[i];
+            if (t.startsWith('min:')) {
+                const n = parseFloat(t.slice('min:'.length));
+                if (!isNaN(n))
+                    widget.min = n;
+            }
+            else if (t.startsWith('max:')) {
+                const n = parseFloat(t.slice('max:'.length));
+                if (!isNaN(n))
+                    widget.max = n;
+            }
+            else if (t.startsWith('step:')) {
+                const n = parseFloat(t.slice('step:'.length));
+                if (!isNaN(n) && n > 0)
+                    widget.step = n;
+            }
+            else if (t.startsWith('precision:')) {
+                const n = parseInt(t.slice('precision:'.length), 10);
+                if (!isNaN(n) && n >= 0 && n <= 100)
+                    widget.precision = n;
+            }
+        }
+        // default 钳制到 [min, max]
+        if (widget.default !== undefined) {
+            if (widget.min !== undefined && widget.default < widget.min)
+                widget.default = widget.min;
+            if (widget.max !== undefined && widget.default > widget.max)
+                widget.default = widget.max;
+        }
+        if (mods.label)
+            widget.label = mods.label;
+        if (mods.hint)
+            widget.hint = mods.hint;
+        if (mods.required)
+            widget.required = true;
+        if (mods.message)
+            widget.message = mods.message;
+        if (mods.placeholder)
+            widget.placeholder = mods.placeholder;
+        if (mods.disabled)
+            widget.disabled = true;
+        return { success: true, widget };
+    }
+    /** 从字段行提取尾部 span:N 修饰符（类似 antd Col 的 span），返回 [剩余行, span] */
+    extractFieldSpan(line) {
+        const m = line.match(/(?:^|\s)span:(\d+)\s*$/);
+        if (!m)
+            return [line, undefined];
+        const span = parseInt(m[1], 10);
+        if (isNaN(span) || span < 1 || span > 24)
+            return [line, undefined];
+        return [line.slice(0, m.index).trimEnd(), span];
+    }
+    /** 从字段行提取尾部 when:字段id:值1,值2 修饰符（form 内联动显隐），返回 [剩余行, when] */
+    extractFieldWhen(line) {
+        const m = line.match(/(?:^|\s)when:([^\s:]+):([^\s]+)\s*$/);
+        if (!m)
+            return [line, undefined];
+        const field = m[1];
+        const values = m[2].split(',').map(v => v.trim()).filter(Boolean);
+        if (!field || values.length === 0)
+            return [line, undefined];
+        return [line.slice(0, m.index).trimEnd(), { field, values }];
+    }
+    /** 解析 when 值段的比较运算符前缀（> >= < <= !=）：返回 [op, 值列表]。
+     *  无前缀或前缀后无有效值时返回 ['eq', 原值列表]（向后兼容） */
+    parseWhenOp(raw) {
+        const m = raw.match(/^(>=|<=|!=|>|<)(.+)$/);
+        if (!m)
+            return ['eq', raw.split(',').map(v => v.trim()).filter(Boolean)];
+        const values = m[2].split(',').map(v => v.trim()).filter(Boolean);
+        if (values.length === 0)
+            return ['eq', raw.split(',').map(v => v.trim()).filter(Boolean)];
+        const opMap = { '>': 'gt', '>=': 'gte', '<': 'lt', '<=': 'lte', '!=': 'ne' };
+        return [opMap[m[1]], values];
+    }
+    /** 循环提取字段行尾部的 when/when-any/span 修饰符（支持任意书写顺序），
+     *  返回 [剩余行, span, when]。多个 when: 为 AND 组合；多个 when-any: 为 OR 组合；
+     *  两组同时存在时取交集（all 且 any）。仅且组时保持对象/数组形态（向后兼容）；
+     *  含或组时输出 FieldWhenGroup { all, any } */
+    extractFieldModifiers(line) {
+        let rest = line;
+        let span;
+        // 先按行尾提取序（逆序）收集原始条件
+        const rawAll = [];
+        const rawAny = [];
+        for (;;) {
+            const before = rest;
+            // when-any:field:v1,v2（或组，需先于 when: 匹配避免前缀截断）；值段可带比较运算符前缀（when-any:field:>=18）
+            const mAny = rest.match(/(?:^|\s)when-any:([^\s:]+):([^\s]+)\s*$/);
+            if (mAny) {
+                const field = mAny[1];
+                const [op, values] = this.parseWhenOp(mAny[2]);
+                if (field && values.length > 0) {
+                    rawAny.push(op === 'eq' ? { field, values } : { field, values, op });
+                    rest = rest.slice(0, mAny.index).trimEnd();
+                }
+            }
+            const mWhen = rest.match(/(?:^|\s)when:([^\s:]+):([^\s]+)\s*$/);
+            if (mWhen) {
+                const field = mWhen[1];
+                const [op, values] = this.parseWhenOp(mWhen[2]);
+                if (field && values.length > 0) {
+                    rawAll.push(op === 'eq' ? { field, values } : { field, values, op });
+                    rest = rest.slice(0, mWhen.index).trimEnd();
+                }
+            }
+            const mSpan = rest.match(/(?:^|\s)span:(\d+)\s*$/);
+            if (mSpan) {
+                const s = parseInt(mSpan[1], 10);
+                if (!isNaN(s) && s >= 1 && s <= 24) {
+                    span = s;
+                    rest = rest.slice(0, mSpan.index).trimEnd();
+                }
+            }
+            if (rest === before)
+                break; // 无更多可提取的尾部修饰符
+        }
+        if (rawAll.length === 0 && rawAny.length === 0)
+            return [rest, span, undefined];
+        // 反转恢复书写顺序，再合并同字段 values（when:a:1 when:a:2 ≡ when:a:1,2）
+        const mergeUnique = (raw) => {
+            const merged = [];
+            for (const { field, values, op } of raw) {
+                const exist = merged.find(w => w.field === field);
+                if (exist) {
+                    for (const v of values)
+                        if (!exist.values.includes(v))
+                            exist.values.push(v);
+                }
+                else {
+                    merged.push(op ? { field, values, op } : { field, values });
+                }
+            }
+            return merged;
+        };
+        const whens = mergeUnique(rawAll.reverse());
+        const anys = mergeUnique(rawAny.reverse());
+        // 仅且组：保持对象/数组形态（向后兼容）
+        if (anys.length === 0)
+            return [rest, span, whens.length === 1 ? whens[0] : whens];
+        // 含或组：输出分组形态
+        const group = {};
+        if (whens.length > 0)
+            group.all = whens;
+        group.any = anys;
+        return [rest, span, group];
+    }
+    /** 判断字段首行是否为多行块组件（chart 系列）的起始行 */
+    isMultiLineFieldStart(trimmedLine) {
+        const first = trimmedLine.split(/\s+/)[0];
+        return first === 'chart-line' || first === 'chart-bar' || first === 'chart-pie' || first === 'chart-scatter';
+    }
+    /** 从 "row" 行提取 gutter:N 参数（类似 antd Row 的 gutter），返回 [gutter] */
+    parseRowGutter(rest) {
+        const m = rest.match(/(?:^|\s)gutter:(\d+)(?:\.\d+)?\s*$/);
+        if (!m)
+            return undefined;
+        const gutter = parseFloat(m[1]);
+        return isNaN(gutter) || gutter < 0 ? undefined : gutter;
+    }
+    parseForm(tokens, fullInput) {
+        if (tokens.length < 2) {
+            return { success: false, error: "form requires at least an id" };
+        }
+        const lines = fullInput.split('\n');
+        const firstLine = lines[0];
+        const firstTokens = this.tokenize(firstLine);
+        const widget = {
+            type: "form",
+            id: firstTokens[1],
+            fields: []
+        };
+        // 首行参数解析：form id "submitLabel" [inline] [columns:N] [cancel:"取消"] [reset:"清空"] [align:right]
+        // [layout:horizontal] [labelWidth:100] [contentWidth:400]
+        for (let ti = 2; ti < firstTokens.length; ti++) {
+            const t = firstTokens[ti];
+            if (t === 'inline') {
+                widget.inline = true;
+            }
+            else if (t.startsWith('inline:')) {
+                widget.inline = t.split(':')[1]?.toLowerCase() === 'true';
+            }
+            else if (t.startsWith('columns:')) {
+                widget.columns = parseInt(t.split(':')[1]);
+            }
+            else if (t.startsWith('cancel:')) {
+                widget.cancelLabel = t.slice('cancel:'.length).replace(/^["']|["']$/g, '');
+            }
+            else if (t.startsWith('reset:')) {
+                widget.resetLabel = t.slice('reset:'.length).replace(/^["']|["']$/g, '');
+            }
+            else if (t.startsWith('align:')) {
+                const a = t.split(':')[1]?.toLowerCase();
+                if (a === 'left' || a === 'center' || a === 'right')
+                    widget.buttonsAlign = a;
+            }
+            else if (t.startsWith('layout:')) {
+                const l = t.split(':')[1]?.toLowerCase();
+                if (l === 'horizontal' || l === 'vertical')
+                    widget.layout = l;
+            }
+            else if (t.startsWith('labelWidth:')) {
+                const n = parseFloat(t.split(':')[1]);
+                if (!isNaN(n) && n > 0)
+                    widget.labelWidth = n;
+            }
+            else if (t.startsWith('contentWidth:')) {
+                const n = parseFloat(t.split(':')[1]);
+                if (!isNaN(n) && n > 0)
+                    widget.contentWidth = n;
+            }
+            else if (t === 'disabled') {
+                widget.disabled = true;
+            }
+            else if (!widget.submitLabel) {
+                widget.submitLabel = t;
+            }
+        }
+        // 扫描后续行：先找配置行（key:value），再处理 row 分组和普通 field
+        let i = 1;
+        let configDone = false;
+        let currentRow = null;
+        let currentRowGutter = undefined;
+        let hasRows = false;
+        for (; i < lines.length; i++) {
+            const rawLine = lines[i];
+            if (!rawLine.trim())
+                continue;
+            // 配置行：inline: true / columns: 3 / layout: horizontal / labelWidth: 100 / contentWidth: 400（必须在任何 row/field 之前）
+            if (!configDone && rawLine.startsWith('  ') && !rawLine.startsWith('    ')) {
+                const trimmed = rawLine.trim();
+                if (trimmed.includes(':')) {
+                    const colonIdx = trimmed.indexOf(':');
+                    const key = trimmed.slice(0, colonIdx).trim().toLowerCase();
+                    const val = trimmed.slice(colonIdx + 1).trim();
+                    // key 已 toLowerCase()：labelWidth/contentWidth 的小写形式也纳入白名单，避免驼峰 key 永远不匹配
+                    if (['inline', 'columns', 'cancel', 'reset', 'align', 'layout', 'labelwidth', 'contentwidth', 'disabled'].includes(key)) {
+                        if (key === 'inline')
+                            widget.inline = val.toLowerCase() === 'true';
+                        if (key === 'columns')
+                            widget.columns = parseInt(val);
+                        if (key === 'cancel')
+                            widget.cancelLabel = val.replace(/^["']|["']$/g, '');
+                        if (key === 'reset')
+                            widget.resetLabel = val.replace(/^["']|["']$/g, '');
+                        if (key === 'align') {
+                            const a = val.toLowerCase();
+                            if (a === 'left' || a === 'center' || a === 'right')
+                                widget.buttonsAlign = a;
+                        }
+                        if (key === 'layout') {
+                            const l = val.toLowerCase();
+                            if (l === 'horizontal' || l === 'vertical')
+                                widget.layout = l;
+                        }
+                        if (key === 'labelwidth') {
+                            const n = parseFloat(val);
+                            if (!isNaN(n) && n > 0)
+                                widget.labelWidth = n;
+                        }
+                        if (key === 'contentwidth') {
+                            const n = parseFloat(val);
+                            if (!isNaN(n) && n > 0)
+                                widget.contentWidth = n;
+                        }
+                        if (key === 'disabled')
+                            widget.disabled = val.toLowerCase() === 'true';
+                        continue;
+                    }
+                }
+                configDone = true;
+            }
+            // row 分组（2 空格缩进，关键字 "row"，可选 gutter:N）
+            if (rawLine.startsWith('  ') && !rawLine.startsWith('    ')) {
+                const rest = rawLine.slice(2).trim();
+                if (rest === 'row' || rest.startsWith('row ') || rest.startsWith('row\t')) {
+                    // 保存上一个 row
+                    if (currentRow && currentRow.length > 0) {
+                        widget.rows = widget.rows || [];
+                        widget.rows.push({ ...(currentRowGutter !== undefined ? { gutter: currentRowGutter } : {}), fields: currentRow });
+                    }
+                    currentRow = [];
+                    currentRowGutter = this.parseRowGutter(rest);
+                    hasRows = true;
+                    configDone = true;
+                    continue;
+                }
+            }
+            // row 内的字段（4 空格缩进）
+            if (rawLine.startsWith('    ') && currentRow !== null) {
+                let fieldLine = rawLine.slice(4).trim();
+                // chart 等多行块组件：收集本字段块的所有行（更深的缩进 >= 6 空格或空行），块整体递归 parse
+                if (this.isMultiLineFieldStart(fieldLine)) {
+                    const blockLines = [fieldLine];
+                    let j = i + 1;
+                    for (; j < lines.length; j++) {
+                        const next = lines[j];
+                        if (!next.trim()) {
+                            blockLines.push('');
+                            continue;
+                        }
+                        const nextIndent = next.length - next.trimStart().length;
+                        if (nextIndent >= 6) {
+                            blockLines.push(next.slice(6));
+                        }
+                        else {
+                            break;
+                        }
+                    }
+                    i = j - 1;
+                    // 从块首行提取尾部 when/span 修饰符（必须先于 parse，避免误触 chart 旧格式判定）
+                    let fieldSpan;
+                    let fieldWhen;
+                    [blockLines[0], fieldSpan, fieldWhen] = this.extractFieldModifiers(blockLines[0]);
+                    const fieldResult = this.parse(blockLines.join('\n').trim());
+                    if (fieldResult.success && fieldResult.widget) {
+                        if (fieldSpan !== undefined) {
+                            fieldResult.widget.span = fieldSpan;
+                        }
+                        if (fieldWhen !== undefined) {
+                            fieldResult.widget.when = fieldWhen;
+                        }
+                        currentRow.push(fieldResult.widget);
+                    }
+                    continue;
+                }
+                // 单行字段：提取尾部 when/span 修饰符（任意顺序）
+                let fieldSpan;
+                let fieldWhen;
+                [fieldLine, fieldSpan, fieldWhen] = this.extractFieldModifiers(fieldLine);
+                const fieldResult = this.parse(fieldLine);
+                if (fieldResult.success && fieldResult.widget) {
+                    if (fieldSpan !== undefined) {
+                        fieldResult.widget.span = fieldSpan;
+                    }
+                    if (fieldWhen !== undefined) {
+                        fieldResult.widget.when = fieldWhen;
+                    }
+                    currentRow.push(fieldResult.widget);
+                }
+                continue;
+            }
+            // 普通字段（2 空格缩进，不在任何 row 内，支持尾部 when:field:values / span:N 修饰符）
+            if (rawLine.startsWith('  ') && !rawLine.startsWith('    ') && !hasRows) {
+                let fieldLine = rawLine.slice(2);
+                // chart 等多行块组件：收集块的所有行（4 空格缩进或空行），块整体递归 parse
+                if (this.isMultiLineFieldStart(fieldLine.trim())) {
+                    const blockLines = [fieldLine.trim()];
+                    let j = i + 1;
+                    for (; j < lines.length; j++) {
+                        const next = lines[j];
+                        if (!next.trim()) {
+                            blockLines.push('');
+                            continue;
+                        }
+                        const nextIndent = next.length - next.trimStart().length;
+                        if (nextIndent >= 4) {
+                            blockLines.push(next.slice(4));
+                        }
+                        else {
+                            break;
+                        }
+                    }
+                    i = j - 1;
+                    // 从块首行提取尾部 when/span 修饰符（必须先于 parse，避免误触 chart 旧格式判定）
+                    let fieldSpan;
+                    let fieldWhen;
+                    [blockLines[0], fieldSpan, fieldWhen] = this.extractFieldModifiers(blockLines[0]);
+                    const fieldResult = this.parse(blockLines.join('\n').trim());
+                    if (fieldResult.success && fieldResult.widget) {
+                        if (fieldSpan !== undefined) {
+                            fieldResult.widget.span = fieldSpan;
+                        }
+                        if (fieldWhen !== undefined) {
+                            fieldResult.widget.when = fieldWhen;
+                        }
+                        widget.fields.push(fieldResult.widget);
+                    }
+                    continue;
+                }
+                let fieldSpan;
+                let fieldWhen;
+                [fieldLine, fieldSpan, fieldWhen] = this.extractFieldModifiers(fieldLine);
+                const fieldResult = this.parse(fieldLine);
+                if (fieldResult.success && fieldResult.widget) {
+                    if (fieldSpan !== undefined) {
+                        fieldResult.widget.span = fieldSpan;
+                    }
+                    if (fieldWhen !== undefined) {
+                        fieldResult.widget.when = fieldWhen;
+                    }
+                    widget.fields.push(fieldResult.widget);
+                }
+            }
+        }
+        // 收尾：保存最后一个 row
+        if (currentRow && currentRow.length > 0) {
+            widget.rows = widget.rows || [];
+            widget.rows.push({ ...(currentRowGutter !== undefined ? { gutter: currentRowGutter } : {}), fields: currentRow });
+        }
+        // 如果有 rows，也把所有 row 的 fields 合并到 fields（向后兼容）
+        if (widget.rows && widget.rows.length > 0) {
+            widget.fields = widget.rows.map((r) => Array.isArray(r) ? r : (r.fields || [])).flat();
+        }
+        return { success: true, widget };
+    }
+    /** 解析独立栅格组件：
+     *  row [id] [gutter:N] [justify:left|center|right|between] [align:top|middle|bottom]
+     *    col [span:N] [offset:N] [align:top|middle|bottom]
+     *      <任意 widget DSL>
+     */
+    parseRow(tokens, fullInput) {
+        const lines = fullInput.split('\n');
+        const firstTokens = this.tokenize(lines[0]);
+        const widget = {
+            type: "row",
+            cols: []
+        };
+        // 首行参数：row [id] gutter:N justify:xx align:xx
+        for (let ti = 1; ti < firstTokens.length; ti++) {
+            const t = firstTokens[ti];
+            if (t.startsWith('gutter:')) {
+                const g = parseFloat(t.split(':')[1]);
+                if (!isNaN(g) && g >= 0)
+                    widget.gutter = g;
+            }
+            else if (t.startsWith('justify:')) {
+                const j = t.split(':')[1]?.toLowerCase();
+                if (j === 'left' || j === 'center' || j === 'right' || j === 'between')
+                    widget.justify = j;
+            }
+            else if (t.startsWith('align:')) {
+                const a = t.split(':')[1]?.toLowerCase();
+                if (a === 'top' || a === 'middle' || a === 'bottom')
+                    widget.align = a;
+            }
+            else if (!t.includes(':') && !widget.id) {
+                widget.id = t;
+            }
+        }
+        // 扫描后续行：col 行（2 空格缩进）开新列，col 内（4 空格缩进）为子组件
+        let currentCol = null;
+        let colLine = 0;
+        for (let i = 1; i < lines.length; i++) {
+            const rawLine = lines[i];
+            if (!rawLine.trim())
+                continue;
+            // col 行：2 空格缩进，"col" 开头
+            if (rawLine.startsWith('  ') && !rawLine.startsWith('    ') && !rawLine.startsWith('\t')) {
+                const rest = rawLine.slice(2).trim();
+                if (rest === 'col' || rest.startsWith('col ') || rest.startsWith('col\t')) {
+                    currentCol = {};
+                    colLine = i;
+                    // col 参数：span:N offset:N align:xx
+                    for (const m of rest.slice(3).trim().split(/\s+/).filter(Boolean)) {
+                        if (m.startsWith('span:')) {
+                            const s = parseInt(m.split(':')[1], 10);
+                            if (!isNaN(s) && s >= 1 && s <= 24)
+                                currentCol.span = s;
+                        }
+                        else if (m.startsWith('offset:')) {
+                            const o = parseInt(m.split(':')[1], 10);
+                            if (!isNaN(o) && o >= 0 && o <= 23)
+                                currentCol.offset = o;
+                        }
+                        else if (m.startsWith('align:')) {
+                            const a = m.split(':')[1]?.toLowerCase();
+                            if (a === 'top' || a === 'middle' || a === 'bottom')
+                                currentCol.align = a;
+                        }
+                    }
+                    widget.cols.push(currentCol);
+                    continue;
+                }
+            }
+            // col 内的子组件行（4 空格缩进）：按缩进收集完整 DSL 块（chart/quiz/form 等多行组件）
+            if (rawLine.startsWith('    ') && currentCol !== null && !currentCol.widget) {
+                const subLines = [rawLine.slice(4)];
+                let j = i + 1;
+                // 收集当前子组件块：≥4 空格缩进的行（含更深层的嵌套内容）与块内空行，
+                // 直到出现下一个 col 行（2 空格）或顶层内容（serializeRow 会把子组件所有行统一加 4 空格前缀）
+                while (j < lines.length) {
+                    const nl = lines[j];
+                    if (nl.trim() === '') {
+                        // 空行：后续仍是 ≥4 空格内容则归属当前块（多行组件内部空行），否则结束
+                        let k = j + 1;
+                        while (k < lines.length && lines[k].trim() === '')
+                            k++;
+                        if (k < lines.length && lines[k].startsWith('    ') && lines[k].trim() !== '') {
+                            subLines.push('');
+                            j++;
+                            continue;
+                        }
+                        break;
+                    }
+                    if (nl.startsWith('    ')) {
+                        subLines.push(nl.slice(4));
+                        j++;
+                        continue;
+                    }
+                    break;
+                }
+                const subResult = this.parse(subLines.join('\n').trim());
+                if (subResult.success && subResult.widget) {
+                    currentCol.widget = subResult.widget;
+                    i = j - 1;
+                }
+            }
+        }
+        if (widget.cols.length === 0) {
+            return { success: false, error: "row requires at least one col" };
+        }
+        return { success: true, widget };
+    }
+    parseChart(tokens, fullInput, chartType) {
+        const lines = fullInput.split('\n');
+        if (lines.length < 2) {
+            return { success: false, error: "chart requires CSV data" };
+        }
+        const widget = {
+            type: chartType,
+            labels: [],
+            datasets: []
+        };
+        // Check if using old token-based format or new key-value format
+        // Old format has multiple tokens on the first line: "chart-line id title"
+        // New format has only widget type on first line: "chart-line" (key:value params go on their own lines;
+        // inline key:value params like "chart-bar id: x span:24" may remain after when/span extraction and are NOT old format)
+        const firstLineTokens = this.tokenize(lines[0]);
+        // 旧格式 token 是裸值；新格式内联参数均形如 key:value（限定参数白名单，避免带冒号的旧格式标题被误判）
+        const hasKeyValueToken = firstLineTokens.slice(1).some((t) => /^(id|title|height|url|legend|span|when):/.test(t));
+        const isOldFormat = firstLineTokens.length > 1 && !hasKeyValueToken; // Old format: chart-line id title
+        let csvStartIndex = 1;
+        if (isOldFormat) {
+            // Old format: chart-line chart_id "Chart Title"
+            widget.id = firstLineTokens[1];
+            if (firstLineTokens.length > 2) {
+                widget.title = firstLineTokens[2];
+            }
+            // CSV starts at line 1
+            csvStartIndex = 1;
+        }
+        else {
+            // 新格式首行的内联 key:value 参数（如 "chart-bar id: revenue span:24" 提取修饰符后残留），先解析掉
+            // 注意首行可能残留 span:N / when:... 修饰符，不在参数白名单内，忽略即可
+            const applyParam = (key, value) => {
+                switch (key) {
+                    case 'id':
+                        widget.id = value;
+                        break;
+                    case 'title':
+                        widget.title = value;
+                        break;
+                    case 'height': {
+                        const height = parseInt(value);
+                        if (!isNaN(height)) {
+                            widget.height = height;
+                        }
+                        break;
+                    }
+                    case 'url':
+                        widget.url = value;
+                        break;
+                    case 'legend':
+                        widget.legend = value === 'true';
+                        break;
+                }
+            };
+            // 配对收集：tokenize 按空格拆分，"id: revenue" 会拆成 "id:" 和 "revenue" 两个 token，
+            // 遇到 key: token 后，将后续裸 token（可含空格的 title/url 等）并入该参数值，直到下一个已知 key
+            let currentKey = null;
+            let currentParts = [];
+            const flushInlineParam = () => {
+                if (currentKey) {
+                    applyParam(currentKey, currentParts.join(' '));
+                }
+                currentKey = null;
+                currentParts = [];
+            };
+            for (let t = 1; t < firstLineTokens.length; t++) {
+                const tok = firstLineTokens[t];
+                const cm = tok.match(/^(id|title|height|url|legend|span|when):(.*)$/);
+                if (cm) {
+                    flushInlineParam();
+                    if (['id', 'title', 'height', 'url', 'legend'].includes(cm[1])) {
+                        currentKey = cm[1];
+                        if (cm[2]) {
+                            currentParts.push(cm[2]); // 形如 key:value 紧凑写法
+                        }
+                    }
+                    // span/when 修饰符已被上游提取（或本就忽略），跳过
+                }
+                else if (currentKey) {
+                    currentParts.push(tok);
+                }
+                // 无当前 key 的裸 token：忽略
+            }
+            flushInlineParam();
+            // New format: key-value parameters before CSV
+            for (let i = 1; i < lines.length; i++) {
+                const line = lines[i].trim();
+                if (!line)
+                    continue;
+                // Check if this line contains a key:value parameter
+                if (line.includes(':')) {
+                    const colonIndex = line.indexOf(':');
+                    const key = line.substring(0, colonIndex).trim().toLowerCase();
+                    if (['id', 'title', 'height', 'url', 'legend'].includes(key)) {
+                        const value = line.substring(colonIndex + 1).trim();
+                        applyParam(key, value);
+                        csvStartIndex = i + 1;
+                    }
+                    else {
+                        // This line has a colon but isn't a known parameter, treat as CSV data
+                        csvStartIndex = i;
+                        break;
+                    }
+                }
+                else {
+                    // This line doesn't contain a colon, start CSV parsing here
+                    csvStartIndex = i;
+                    break;
+                }
+            }
+        }
+        // Parse CSV data starting from csvStartIndex
+        const csvLines = lines.slice(csvStartIndex).map(l => l.trim()).filter(l => l.length > 0);
+        if (csvLines.length === 0 && !widget.url) {
+            // 无本地 CSV 数据且未设置远端 url 时报错；设置 url 时允许为空（远端拉取）
+            return { success: false, error: "No CSV data provided" };
+        }
+        if (csvLines.length === 0) {
+            // 仅使用远端数据源，跳过本地 CSV 解析
+            return { success: true, widget };
+        }
+        // Parse header row
+        const headerLine = csvLines[0];
+        if (!headerLine) {
+            return { success: false, error: "Empty CSV header" };
+        }
+        const headers = headerLine.split(',').map(h => h.trim());
+        if (headers.length < 2) {
+            return { success: false, error: "CSV must have at least 2 columns" };
+        }
+        // Initialize datasets for each data column (skip first column which is labels)
+        for (let i = 1; i < headers.length; i++) {
+            widget.datasets.push({
+                label: headers[i],
+                data: []
+            });
+        }
+        // Parse data rows
+        for (let i = 1; i < csvLines.length; i++) {
+            const dataLine = csvLines[i].trim();
+            if (!dataLine)
+                continue; // Skip empty lines
+            const values = dataLine.split(',').map(v => v.trim());
+            if (values.length !== headers.length) {
+                return { success: false, error: `Row ${i + 1} has ${values.length} columns, expected ${headers.length}` };
+            }
+            // First column is the label
+            widget.labels.push(values[0]);
+            // Remaining columns are data points
+            for (let j = 1; j < values.length; j++) {
+                const numValue = parseFloat(values[j]);
+                if (isNaN(numValue)) {
+                    return { success: false, error: `Invalid number "${values[j]}" in row ${i + 1}, column ${j + 1}` };
+                }
+                widget.datasets[j - 1].data.push(numValue);
+            }
+        }
+        return { success: true, widget };
+    }
+    parseMultipleChoiceQuestion(tokens) {
+        if (tokens.length < 4) {
+            return { success: false, error: "multiple-choice-question requires id, question, and choices array" };
+        }
+        try {
+            const choices = this.parseArray(tokens[3]);
+            const widget = {
+                type: "multiple-choice-question",
+                id: tokens[1],
+                question: tokens[2],
+                choices
+            };
+            if (tokens.length > 4)
+                widget.correctAnswer = tokens[4];
+            // 兼容 showFeedback 位置参数（true/false）与 showFeedback 无值修饰符两种写法
+            const fbToken = tokens.slice(5).find(t => t === 'showFeedback' || t.toLowerCase() === 'true' || t.toLowerCase() === 'false');
+            if (fbToken)
+                widget.showFeedback = fbToken === 'showFeedback' || fbToken.toLowerCase() === 'true';
+            if (tokens.slice(5).includes('disabled'))
+                widget.disabled = true;
+            return { success: true, widget };
+        }
+        catch (error) {
+            return { success: false, error: `Invalid choices array: ${error}` };
+        }
+    }
+    parseShortAnswerQuestion(tokens) {
+        if (tokens.length < 3) {
+            return { success: false, error: "short-answer-question requires id and question" };
+        }
+        const widget = {
+            type: "short-answer-question",
+            id: tokens[1],
+            question: tokens[2]
+        };
+        if (tokens.length > 3)
+            widget.placeholder = tokens[3];
+        if (tokens.length > 4) {
+            try {
+                if (tokens[4].startsWith('[')) {
+                    widget.correctAnswers = this.parseArray(tokens[4]);
+                }
+                else {
+                    widget.correctAnswer = tokens[4];
+                }
+            }
+            catch (error) {
+                return { success: false, error: `Invalid answers value: ${error}` };
+            }
+        }
+        // 兼容 showFeedback 位置参数（true/false）与 showFeedback 无值修饰符两种写法
+        const fbToken = tokens.slice(5).find(t => t === 'showFeedback' || t.toLowerCase() === 'true' || t.toLowerCase() === 'false');
+        if (fbToken)
+            widget.showFeedback = fbToken === 'showFeedback' || fbToken.toLowerCase() === 'true';
+        if (tokens.slice(5).includes('disabled'))
+            widget.disabled = true;
+        return { success: true, widget };
+    }
+    parseQuiz(tokens, fullInput) {
+        if (tokens.length < 3) {
+            return { success: false, error: "quiz requires id and title" };
+        }
+        const lines = fullInput.split('\n');
+        const firstLine = lines[0];
+        const firstTokens = this.tokenize(firstLine);
+        const widget = {
+            type: "quiz",
+            id: firstTokens[1],
+            title: firstTokens[2],
+            questions: [],
+            showScore: true,
+            showProgress: true
+        };
+        // 首行尾部的 disabled 无值修饰符
+        if (firstTokens.slice(3).includes('disabled'))
+            widget.disabled = true;
+        let i = 1;
+        // Parse configuration lines (key: value format)
+        const quizConfigKeys = new Set(['showscore', 'showprogress', 'passingscore', 'disabled']);
+        while (i < lines.length) {
+            const line = lines[i].trim();
+            if (!line) {
+                i++;
+                continue;
+            }
+            // Check if this is a configuration line (known key: value format)
+            // 避免把含冒号的题目行（如 key:label 选项）误判为配置行
+            let isConfigLine = false;
+            if (line.includes(':')) {
+                const colonIndex = line.indexOf(':');
+                const key = line.substring(0, colonIndex).trim().toLowerCase();
+                isConfigLine = quizConfigKeys.has(key);
+            }
+            if (isConfigLine) {
+                const colonIndex = line.indexOf(':');
+                const key = line.substring(0, colonIndex).trim().toLowerCase();
+                const value = line.substring(colonIndex + 1).trim();
+                switch (key) {
+                    case 'showscore':
+                        widget.showScore = value.toLowerCase() === 'true';
+                        break;
+                    case 'showprogress':
+                        widget.showProgress = value.toLowerCase() === 'true';
+                        break;
+                    case 'passingscore':
+                        const score = parseInt(value);
+                        if (!isNaN(score)) {
+                            widget.passingScore = score;
+                        }
+                        break;
+                    case 'disabled':
+                        widget.disabled = value.toLowerCase() === 'true';
+                        break;
+                    default:
+                        // Not a known config, might be start of questions
+                        break;
+                }
+                i++;
+            }
+            else {
+                // This line doesn't contain a colon, start parsing questions
+                break;
+            }
+        }
+        // Parse questions
+        while (i < lines.length) {
+            const line = lines[i].trim();
+            if (!line) {
+                i++;
+                continue;
+            }
+            const questionTokens = this.tokenize(line);
+            if (questionTokens.length === 0) {
+                i++;
+                continue;
+            }
+            const questionType = questionTokens[0];
+            let question = {};
+            if (questionType === 'mcq') {
+                // mcq questionId "Question text" points ["choice1" "choice2"] "correctAnswer"
+                if (questionTokens.length < 5) {
+                    return { success: false, error: `MCQ question on line ${i + 1} requires: id, question, points, and choices` };
+                }
+                const points = parseInt(questionTokens[3]);
+                if (isNaN(points)) {
+                    return { success: false, error: `Invalid points value "${questionTokens[3]}" on line ${i + 1}` };
+                }
+                try {
+                    const choices = this.parseArray(questionTokens[4]);
+                    question = {
+                        id: questionTokens[1],
+                        type: "mcq",
+                        question: questionTokens[2],
+                        points: points,
+                        choices: choices
+                    };
+                    if (questionTokens.length > 5) {
+                        question.correctAnswer = questionTokens[5];
+                    }
+                }
+                catch (error) {
+                    return { success: false, error: `Invalid choices array on line ${i + 1}: ${error}` };
+                }
+            }
+            else if (questionType === 'short-answer') {
+                // short-answer questionId "Question text" points "placeholder" ["answer1" "answer2"]
+                if (questionTokens.length < 4) {
+                    return { success: false, error: `Short answer question on line ${i + 1} requires: id, question, and points` };
+                }
+                const points = parseInt(questionTokens[3]);
+                if (isNaN(points)) {
+                    return { success: false, error: `Invalid points value "${questionTokens[3]}" on line ${i + 1}` };
+                }
+                question = {
+                    id: questionTokens[1],
+                    type: "short-answer",
+                    question: questionTokens[2],
+                    points: points
+                };
+                if (questionTokens.length > 4) {
+                    question.placeholder = questionTokens[4];
+                }
+                if (questionTokens.length > 5) {
+                    try {
+                        if (questionTokens[5].startsWith('[')) {
+                            question.correctAnswers = this.parseArray(questionTokens[5]);
+                        }
+                        else {
+                            question.correctAnswers = [questionTokens[5]];
+                        }
+                    }
+                    catch (error) {
+                        return { success: false, error: `Invalid answers value on line ${i + 1}: ${error}` };
+                    }
+                }
+            }
+            else {
+                return { success: false, error: `Unknown question type "${questionType}" on line ${i + 1}` };
+            }
+            widget.questions.push(question);
+            i++;
+        }
+        if (widget.questions.length === 0) {
+            return { success: false, error: "Quiz must contain at least one question" };
+        }
+        return { success: true, widget };
+    }
+    /**
+     * Streaming-aware parsing that returns partial results for incomplete input.
+     * This is designed for AI streaming scenarios where content arrives incrementally.
+     */
+    parseStreaming(input) {
+        const trimmedInput = input.trim();
+        if (!trimmedInput) {
+            return { complete: false, error: "Empty input" };
+        }
+        // Check for unclosed brackets or quotes
+        const pending = this.detectPendingState(trimmedInput);
+        // Try to detect widget type from first token
+        const firstSpaceOrNewline = trimmedInput.search(/[\s\n]/);
+        const firstToken = firstSpaceOrNewline > 0
+            ? trimmedInput.substring(0, firstSpaceOrNewline)
+            : trimmedInput;
+        const detectedType = WIDGET_TYPES.includes(firstToken) ? firstToken : undefined;
+        // If we can't even detect the type yet, return early
+        if (!detectedType) {
+            // Check if it might be a partial type name
+            const partialMatch = WIDGET_TYPES.find(t => t.startsWith(firstToken));
+            if (partialMatch && firstToken.length < partialMatch.length) {
+                return {
+                    complete: false,
+                    pending: { unclosedQuote: false, unclosedBracket: false }
+                };
+            }
+            return { complete: false, error: `Unknown widget type: ${firstToken}` };
+        }
+        // If there are pending unclosed brackets/quotes, try partial parsing
+        if (pending.unclosedBracket || pending.unclosedQuote) {
+            return this.parsePartialWidget(trimmedInput, detectedType, pending);
+        }
+        // Try full parsing
+        const result = this.parse(trimmedInput);
+        if (result.success && result.widget) {
+            return {
+                complete: true,
+                detectedType,
+                widget: result.widget
+            };
+        }
+        // Full parse failed, try partial parsing
+        return this.parsePartialWidget(trimmedInput, detectedType, pending);
+    }
+    /**
+     * Detect if input has unclosed brackets or quotes
+     */
+    detectPendingState(input) {
+        let inQuotes = false;
+        let quoteChar = '';
+        let bracketDepth = 0;
+        for (let i = 0; i < input.length; i++) {
+            const char = input[i];
+            if ((char === '"' || char === "'") && !inQuotes) {
+                inQuotes = true;
+                quoteChar = char;
+            }
+            else if (char === quoteChar && inQuotes) {
+                inQuotes = false;
+                quoteChar = '';
+            }
+            else if (char === '[' && !inQuotes) {
+                bracketDepth++;
+            }
+            else if (char === ']' && !inQuotes) {
+                bracketDepth--;
+            }
+        }
+        return {
+            unclosedBracket: bracketDepth > 0,
+            unclosedQuote: inQuotes
+        };
+    }
+    /**
+     * Parse widget with incomplete input, filling in defaults for missing parts
+     */
+    parsePartialWidget(input, detectedType, pending) {
+        // For quiz, try to extract what we can
+        if (detectedType === 'quiz') {
+            return this.parsePartialQuiz(input, pending);
+        }
+        // For form, try to extract what we can
+        if (detectedType === 'form') {
+            return this.parsePartialForm(input, pending);
+        }
+        // For charts, try to extract what we can
+        if (detectedType.startsWith('chart-')) {
+            return this.parsePartialChart(input, detectedType, pending);
+        }
+        // For simple widgets, try to complete arrays if needed
+        if (pending.unclosedBracket) {
+            const completedInput = this.autoCompleteArrays(input);
+            const result = this.parse(completedInput);
+            if (result.success && result.widget) {
+                return {
+                    complete: false,
+                    detectedType,
+                    widget: result.widget,
+                    pending: { unclosedBracket: true }
+                };
+            }
+        }
+        // Return minimal partial widget
+        const lines = input.split('\n');
+        const tokens = this.tokenize(lines[0]);
+        return {
+            complete: false,
+            detectedType,
+            widget: {
+                type: detectedType,
+                id: tokens[1] || 'pending'
+            },
+            pending
+        };
+    }
+    /**
+     * Auto-complete unclosed arrays by adding closing bracket
+     */
+    autoCompleteArrays(input) {
+        let result = input;
+        let bracketDepth = 0;
+        let inQuotes = false;
+        let quoteChar = '';
+        for (const char of input) {
+            if ((char === '"' || char === "'") && !inQuotes) {
+                inQuotes = true;
+                quoteChar = char;
+            }
+            else if (char === quoteChar && inQuotes) {
+                inQuotes = false;
+                quoteChar = '';
+            }
+            else if (char === '[' && !inQuotes) {
+                bracketDepth++;
+            }
+            else if (char === ']' && !inQuotes) {
+                bracketDepth--;
+            }
+        }
+        // Close unclosed quotes first
+        if (inQuotes) {
+            result += quoteChar;
+        }
+        // Close unclosed brackets
+        while (bracketDepth > 0) {
+            result += ']';
+            bracketDepth--;
+        }
+        return result;
+    }
+    /**
+     * Parse partial quiz, extracting whatever questions are complete
+     */
+    parsePartialQuiz(input, pending) {
+        const lines = input.split('\n');
+        const firstTokens = this.tokenize(lines[0]);
+        const widget = {
+            type: 'quiz',
+            id: firstTokens[1] || 'pending',
+            title: firstTokens[2] || 'Loading...',
+            questions: [],
+            showScore: true,
+            showProgress: true,
+            _streaming: true // Mark as streaming for UI
+        };
+        let i = 1;
+        // Parse config lines
+        while (i < lines.length) {
+            const line = lines[i].trim();
+            if (!line) {
+                i++;
+                continue;
+            }
+            if (line.includes(':')) {
+                const colonIndex = line.indexOf(':');
+                const key = line.substring(0, colonIndex).trim().toLowerCase();
+                const value = line.substring(colonIndex + 1).trim();
+                switch (key) {
+                    case 'showscore':
+                        widget.showScore = value.toLowerCase() === 'true';
+                        break;
+                    case 'showprogress':
+                        widget.showProgress = value.toLowerCase() === 'true';
+                        break;
+                    case 'passingscore':
+                        const score = parseInt(value);
+                        if (!isNaN(score))
+                            widget.passingScore = score;
+                        break;
+                }
+                i++;
+            }
+            else {
+                break;
+            }
+        }
+        // Parse questions, handling incomplete ones gracefully
+        while (i < lines.length) {
+            const line = lines[i].trim();
+            if (!line) {
+                i++;
+                continue;
+            }
+            const question = this.parsePartialQuestion(line, i);
+            if (question) {
+                widget.questions.push(question);
+            }
+            i++;
+        }
+        return {
+            complete: false,
+            detectedType: 'quiz',
+            widget,
+            pending: {
+                ...pending,
+                awaitingQuestions: widget.questions.length === 0
+            }
+        };
+    }
+    /**
+     * Parse a single question line, handling incomplete input
+     */
+    parsePartialQuestion(line, lineNum) {
+        // Auto-complete the line if needed
+        const completedLine = this.autoCompleteArrays(line);
+        try {
+            const tokens = this.tokenize(completedLine);
+            if (tokens.length === 0)
+                return null;
+            const questionType = tokens[0];
+            if (questionType === 'mcq') {
+                return {
+                    id: tokens[1] || `q${lineNum}`,
+                    type: 'mcq',
+                    question: tokens[2] || 'Loading question...',
+                    points: parseInt(tokens[3]) || 0,
+                    choices: tokens[4] ? this.parseArray(tokens[4]) : [],
+                    correctAnswer: tokens[5],
+                    _streaming: tokens.length < 5 // Mark incomplete
+                };
+            }
+            if (questionType === 'short-answer') {
+                const question = {
+                    id: tokens[1] || `q${lineNum}`,
+                    type: 'short-answer',
+                    question: tokens[2] || 'Loading question...',
+                    points: parseInt(tokens[3]) || 0,
+                    _streaming: tokens.length < 4
+                };
+                if (tokens[4])
+                    question.placeholder = tokens[4];
+                if (tokens[5]) {
+                    try {
+                        question.correctAnswers = tokens[5].startsWith('[')
+                            ? this.parseArray(tokens[5])
+                            : [tokens[5]];
+                    }
+                    catch { /* ignore */ }
+                }
+                return question;
+            }
+        }
+        catch {
+            // Return partial question on parse error
+            const partialTokens = line.split(/\s+/);
+            if (partialTokens[0] === 'mcq' || partialTokens[0] === 'short-answer') {
+                return {
+                    id: partialTokens[1] || `q${lineNum}`,
+                    type: partialTokens[0] === 'mcq' ? 'mcq' : 'short-answer',
+                    question: 'Loading...',
+                    points: 0,
+                    choices: partialTokens[0] === 'mcq' ? [] : undefined,
+                    _streaming: true
+                };
+            }
+        }
+        return null;
+    }
+    /**
+     * Parse partial form
+     */
+    parsePartialForm(input, pending) {
+        const lines = input.split('\n');
+        const firstTokens = this.tokenize(lines[0]);
+        const widget = {
+            type: 'form',
+            id: firstTokens[1] || 'pending',
+            submitLabel: firstTokens[2],
+            fields: [],
+            _streaming: true
+        };
+        // 首行参数（inline/columns/cancel/reset/align/layout/labelWidth/contentWidth/disabled）
+        for (let ti = 3; ti < firstTokens.length; ti++) {
+            const t = firstTokens[ti];
+            if (t === 'inline' || t.startsWith('inline:')) {
+                widget.inline = t === 'inline' ? true : t.split(':')[1]?.toLowerCase() === 'true';
+            }
+            else if (t.startsWith('columns:')) {
+                widget.columns = parseInt(t.split(':')[1]);
+            }
+            else if (t.startsWith('cancel:')) {
+                widget.cancelLabel = t.slice('cancel:'.length).replace(/^["']|["']$/g, '');
+            }
+            else if (t.startsWith('reset:')) {
+                widget.resetLabel = t.slice('reset:'.length).replace(/^["']|["']$/g, '');
+            }
+            else if (t.startsWith('align:')) {
+                const a = t.split(':')[1]?.toLowerCase();
+                if (a === 'left' || a === 'center' || a === 'right')
+                    widget.buttonsAlign = a;
+            }
+            else if (t.startsWith('layout:')) {
+                const l = t.split(':')[1]?.toLowerCase();
+                if (l === 'horizontal' || l === 'vertical')
+                    widget.layout = l;
+            }
+            else if (t.startsWith('labelWidth:')) {
+                const n = parseFloat(t.split(':')[1]);
+                if (!isNaN(n) && n > 0)
+                    widget.labelWidth = n;
+            }
+            else if (t.startsWith('contentWidth:')) {
+                const n = parseFloat(t.split(':')[1]);
+                if (!isNaN(n) && n > 0)
+                    widget.contentWidth = n;
+            }
+            else if (t === 'disabled') {
+                widget.disabled = true;
+            }
+        }
+        // 解析后续行
+        let i = 1;
+        let currentRow = null;
+        let currentRowGutter = undefined;
+        let hasRows = false;
+        for (; i < lines.length; i++) {
+            const line = lines[i];
+            if (!line.trim())
+                continue;
+            // 配置行
+            if (line.startsWith('  ') && !line.startsWith('    ')) {
+                const trimmed = line.trim();
+                if (trimmed.includes(':') && !hasRows) {
+                    const colonIdx = trimmed.indexOf(':');
+                    const key = trimmed.slice(0, colonIdx).trim().toLowerCase();
+                    const val = trimmed.slice(colonIdx + 1).trim();
+                    if (key === 'inline') {
+                        widget.inline = val.toLowerCase() === 'true';
+                        continue;
+                    }
+                    if (key === 'columns') {
+                        widget.columns = parseInt(val);
+                        continue;
+                    }
+                    if (key === 'cancel') {
+                        widget.cancelLabel = val.replace(/^["']|["']$/g, '');
+                        continue;
+                    }
+                    if (key === 'reset') {
+                        widget.resetLabel = val.replace(/^["']|["']$/g, '');
+                        continue;
+                    }
+                    if (key === 'align') {
+                        const a = val.toLowerCase();
+                        if (a === 'left' || a === 'center' || a === 'right')
+                            widget.buttonsAlign = a;
+                        continue;
+                    }
+                    if (key === 'layout') {
+                        const l = val.toLowerCase();
+                        if (l === 'horizontal' || l === 'vertical')
+                            widget.layout = l;
+                        continue;
+                    }
+                    if (key === 'labelwidth') {
+                        const n = parseFloat(val);
+                        if (!isNaN(n) && n > 0)
+                            widget.labelWidth = n;
+                        continue;
+                    }
+                    if (key === 'contentwidth') {
+                        const n = parseFloat(val);
+                        if (!isNaN(n) && n > 0)
+                            widget.contentWidth = n;
+                        continue;
+                    }
+                    if (key === 'disabled') {
+                        widget.disabled = val.toLowerCase() === 'true';
+                        continue;
+                    }
+                }
+                // row 关键字（可选 gutter:N）
+                if (trimmed === 'row' || trimmed.startsWith('row ') || trimmed.startsWith('row\t')) {
+                    if (currentRow && currentRow.length > 0) {
+                        widget.rows = widget.rows || [];
+                        widget.rows.push({ ...(currentRowGutter !== undefined ? { gutter: currentRowGutter } : {}), fields: currentRow });
+                    }
+                    currentRow = [];
+                    currentRowGutter = this.parseRowGutter(trimmed);
+                    hasRows = true;
+                    continue;
+                }
+                // 普通 field（支持尾部 when:field:values / span:N 修饰符，任意顺序）
+                if (!hasRows) {
+                    let fieldLine = this.autoCompleteArrays(line.slice(2));
+                    let fieldSpan;
+                    let fieldWhen;
+                    [fieldLine, fieldSpan, fieldWhen] = this.extractFieldModifiers(fieldLine);
+                    try {
+                        const fieldResult = this.parse(fieldLine);
+                        if (fieldResult.success && fieldResult.widget) {
+                            if (fieldSpan !== undefined) {
+                                fieldResult.widget.span = fieldSpan;
+                            }
+                            if (fieldWhen !== undefined) {
+                                fieldResult.widget.when = fieldWhen;
+                            }
+                            widget.fields.push(fieldResult.widget);
+                        }
+                    }
+                    catch { /* skip */ }
+                }
+            }
+            // row 内的字段（支持尾部 when:field:values / span:N，任意顺序）
+            if (line.startsWith('    ') && currentRow !== null) {
+                let fieldLine = this.autoCompleteArrays(line.slice(4).trim());
+                let fieldSpan;
+                let fieldWhen;
+                [fieldLine, fieldSpan, fieldWhen] = this.extractFieldModifiers(fieldLine);
+                try {
+                    const fieldResult = this.parse(fieldLine);
+                    if (fieldResult.success && fieldResult.widget) {
+                        if (fieldSpan !== undefined) {
+                            fieldResult.widget.span = fieldSpan;
+                        }
+                        if (fieldWhen !== undefined) {
+                            fieldResult.widget.when = fieldWhen;
+                        }
+                        currentRow.push(fieldResult.widget);
+                    }
+                }
+                catch { /* skip */ }
+            }
+        }
+        if (currentRow && currentRow.length > 0) {
+            widget.rows = widget.rows || [];
+            widget.rows.push({ ...(currentRowGutter !== undefined ? { gutter: currentRowGutter } : {}), fields: currentRow });
+        }
+        if (widget.rows && widget.rows.length > 0) {
+            widget.fields = widget.rows.map((r) => Array.isArray(r) ? r : (r.fields || [])).flat();
+        }
+        return {
+            complete: false,
+            detectedType: 'form',
+            widget,
+            pending: { ...pending, awaitingFields: true }
+        };
+    }
+    /**
+     * Parse partial chart
+     */
+    parsePartialChart(input, detectedType, pending) {
+        const lines = input.split('\n');
+        const firstTokens = this.tokenize(lines[0]);
+        const widget = {
+            type: detectedType,
+            id: firstTokens[1] || 'pending',
+            title: firstTokens[2],
+            labels: [],
+            datasets: [],
+            _streaming: true
+        };
+        // Try to parse any complete CSV rows
+        let csvStarted = false;
+        for (let i = 1; i < lines.length; i++) {
+            const line = lines[i].trim();
+            if (!line)
+                continue;
+            if (line.includes(':') && !csvStarted) {
+                // Config line
+                const [key, value] = line.split(':').map(s => s.trim());
+                if (key.toLowerCase() === 'title')
+                    widget.title = value;
+                if (key.toLowerCase() === 'id')
+                    widget.id = value;
+            }
+            else if (line.includes(',')) {
+                csvStarted = true;
+                // CSV data - just mark that we have data coming
+            }
+        }
+        return {
+            complete: false,
+            detectedType,
+            widget,
+            pending: {
+                ...pending,
+                awaitingData: true
+            }
+        };
+    }
+}
+export function parseDSL(input) {
+    const parser = new DSLParser();
+    return parser.parse(input);
+}
+export function parseDSLStreaming(input) {
+    const parser = new DSLParser();
+    return parser.parseStreaming(input);
+}