markdown-flow-ui 0.2.35 → 0.3.0-dev.1

package/dist/node_modules/remark-flow/dist/interaction-parser.es.js.map

@@ -1 +1 @@
-{"version":3,"file":"interaction-parser.es.js","sources":["../../../../node_modules/remark-flow/dist/interaction-parser.js"],"sourcesContent":["\"use strict\";\n/**\n * MarkdownFlow Interactive Block Layered Parser - TypeScript Version\n *\n * Uses a three-layer analysis architecture:\n * Layer 1: ?[] format validation\n * Layer 2: Variable detection and pattern classification\n * Layer 3: Specific content parsing\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.InteractionParser = exports.COMPILED_REGEXES = exports.InteractionType = void 0;\nexports.parseInteractionFormat = parseInteractionFormat;\nexports.createInteractionParser = createInteractionParser;\nconst escaping_1 = require(\"./escaping\");\n// Interaction input type enumeration\nvar InteractionType;\n(function (InteractionType) {\n    InteractionType[\"TEXT_ONLY\"] = \"text_only\";\n    InteractionType[\"BUTTONS_ONLY\"] = \"buttons_only\";\n    InteractionType[\"BUTTONS_WITH_TEXT\"] = \"buttons_with_text\";\n    InteractionType[\"BUTTONS_MULTI_SELECT\"] = \"buttons_multi_select\";\n    InteractionType[\"BUTTONS_MULTI_WITH_TEXT\"] = \"buttons_multi_with_text\";\n    InteractionType[\"NON_ASSIGNMENT_BUTTON\"] = \"non_assignment_button\";\n})(InteractionType || (exports.InteractionType = InteractionType = {}));\n// Pre-compiled regex constants\nexports.COMPILED_REGEXES = {\n    // Layer 1: Basic format validation - matches ?[content] but excludes ?[text](url) format.\n    // The content accepts an escaped delimiter as one unit, so a `\\]` inside an option does not\n    // end the interaction. See ./escaping.\n    LAYER1_INTERACTION: new RegExp(`\\\\?\\\\[(${escaping_1.INTERACTION_CONTENT_SOURCE})\\\\](?!\\\\()`),\n    // Layer 2: Variable detection - matches %{{variable}}content format\n    // (supports letters, numbers, underscores, Chinese characters, Japanese\n    // kana, with optional spaces inside the braces). Superset of both the\n    // repo history and the published 0.1.6 behavior.\n    LAYER2_VARIABLE: /^%\\{\\{\\s*([a-zA-Z0-9_\\u4e00-\\u9fa5\\u3040-\\u309f\\u30a0-\\u30ff]+)\\s*\\}\\}(.*)$/,\n    // Layer 3: Split content before and after ...\n    LAYER3_ELLIPSIS: /^(.*?)\\.\\.\\.(.*)/,\n    // Kept for consumers that inspect the exported regex collection. Exact\n    // single-pipe splitting requires context that Safari-safe regexes cannot\n    // express without consuming adjacent text, and now also has to skip a bar\n    // an option escaped, so the parser uses the scanner in ./escaping instead.\n    LAYER3_SINGLE_PIPE_SPLIT: /\\|(?!\\|)/g,\n};\n/**\n * Layered interaction parser class\n */\nclass InteractionParser {\n    constructor() {\n        // Constructor is intentionally empty - no initialization needed\n    }\n    /**\n     * Main parsing method\n     *\n     * @param content - Raw content of interaction block\n     * @returns Standardized parse result\n     */\n    parse(content) {\n        try {\n            // Layer 1: Validate basic format\n            const innerContent = this._layer1ValidateFormat(content);\n            if (innerContent === null) {\n                return this._createErrorResult(`Invalid interaction format: ${content}`);\n            }\n            // Layer 2: Variable detection and pattern classification\n            const [hasVariable, variableName, remainingContent] = this._layer2DetectVariable(innerContent);\n            // Layer 3: Specific content parsing\n            if (hasVariable && variableName) {\n                return this._layer3ParseVariableInteraction(variableName, remainingContent);\n            }\n            else {\n                return this._layer3ParseDisplayButtons(innerContent);\n            }\n        }\n        catch (error) {\n            return this._createErrorResult(`Parsing error: ${error instanceof Error ? error.message : 'Unknown error'}`);\n        }\n    }\n    /**\n     * Parse and convert to remark-compatible format\n     *\n     * @param content - Raw content of interaction block\n     * @returns remark-compatible result object\n     */\n    parseToRemarkFormat(content) {\n        const result = this.parse(content);\n        if (result.error) {\n            // Compatibility handling when parsing fails\n            return { placeholder: content.trim() };\n        }\n        // Convert to remark-compatible format\n        const remarkResult = {};\n        if (result.type === InteractionType.NON_ASSIGNMENT_BUTTON) {\n            // Non-assignment interaction (no variableName in the output)\n            const nonAssignmentResult = result;\n            if (nonAssignmentResult.buttons.length > 0) {\n                remarkResult.buttonTexts = nonAssignmentResult.buttons.map(b => b.display);\n                remarkResult.buttonValues = nonAssignmentResult.buttons.map(b => b.value);\n            }\n            if (nonAssignmentResult.question !== undefined) {\n                remarkResult.placeholder = nonAssignmentResult.question;\n            }\n            if (nonAssignmentResult.isMultiSelect !== undefined) {\n                remarkResult.isMultiSelect = nonAssignmentResult.isMultiSelect;\n            }\n        }\n        else if (result.type !== null) {\n            // Variable interaction\n            const variableResult = result;\n            remarkResult.variableName = variableResult.variable;\n            if (variableResult.buttons) {\n                remarkResult.buttonTexts = variableResult.buttons.map(b => b.display);\n                remarkResult.buttonValues = variableResult.buttons.map(b => b.value);\n            }\n            if (variableResult.question !== undefined) {\n                remarkResult.placeholder = variableResult.question;\n            }\n            if (variableResult.isMultiSelect !== undefined) {\n                remarkResult.isMultiSelect = variableResult.isMultiSelect;\n            }\n        }\n        return remarkResult;\n    }\n    /**\n     * Layer 1: Validate ?[] format and extract content\n     *\n     * @param content - Raw content\n     * @returns Extracted bracket content, returns null if validation fails\n     */\n    _layer1ValidateFormat(content) {\n        content = content.trim();\n        const match = exports.COMPILED_REGEXES.LAYER1_INTERACTION.exec(content);\n        if (!match) {\n            return null;\n        }\n        // Ensure the match is the complete content (no other text)\n        const matchedText = match[0];\n        if (matchedText.trim() !== content) {\n            return null;\n        }\n        return match[1];\n    }\n    /**\n     * Layer 2: Detect variables and perform pattern classification\n     *\n     * @param innerContent - Content extracted from layer 1\n     * @returns [hasVariable, variableName, remainingContent]\n     */\n    _layer2DetectVariable(innerContent) {\n        const match = exports.COMPILED_REGEXES.LAYER2_VARIABLE.exec(innerContent);\n        if (!match) {\n            // No variable, entire content used for display button parsing\n            return [false, null, innerContent];\n        }\n        const variableName = match[1].trim();\n        const remainingContent = match[2].trim();\n        return [true, variableName, remainingContent];\n    }\n    /**\n     * Parse the structural shape of interaction content: buttons, optional\n     * `...question` text input, multi-select flag. Shared by the variable and\n     * non-assignment branches, which only differ in how they map the shape\n     * into their result types.\n     *\n     * @param content - Content after the (optional) variable\n     * @returns The parsed content shape\n     */\n    _parseContentShape(content) {\n        const ellipsis = (0, escaping_1.splitOnEllipsis)(content);\n        if (ellipsis) {\n            const beforeEllipsis = ellipsis[0].trim();\n            const question = (0, escaping_1.unescapeInteractionText)(ellipsis[1]).trim();\n            if (beforeEllipsis) {\n                // Button group + text input: ?[Button1 | Button2 | ...question]\n                const [buttons, isMultiSelect] = this._parseButtons(beforeEllipsis);\n                return { buttons, question, isMultiSelect, hasTextInput: true };\n            }\n            // Pure text input: ?[...question]\n            return {\n                buttons: [],\n                question,\n                isMultiSelect: false,\n                hasTextInput: true,\n            };\n        }\n        if ((0, escaping_1.findUnescaped)(content, '|') >= 0) {\n            // Button group: ?[Button1 | Button2] or ?[Button1 || Button2]\n            const [buttons, isMultiSelect] = this._parseButtons(content);\n            return { buttons, isMultiSelect, hasTextInput: false };\n        }\n        if (content) {\n            // Single button: ?[Button1] or ?[Button1//id1]\n            return {\n                buttons: [this._parseSingleButton(content)],\n                isMultiSelect: false,\n                hasTextInput: false,\n            };\n        }\n        // Empty content: pure text input with no prompt\n        return {\n            buttons: [],\n            question: '',\n            isMultiSelect: false,\n            hasTextInput: true,\n        };\n    }\n    /**\n     * Layer 3: Parse variable interaction (variable assignment type)\n     *\n     * @param variableName - Variable name\n     * @param content - Content after variable\n     * @returns Parse result\n     */\n    _layer3ParseVariableInteraction(variableName, content) {\n        const shape = this._parseContentShape(content);\n        if (shape.hasTextInput) {\n            if (shape.buttons.length > 0) {\n                // Button group + text input: ?[%{{var}} Button1 | Button2 | ...question]\n                return {\n                    type: shape.isMultiSelect\n                        ? InteractionType.BUTTONS_MULTI_WITH_TEXT\n                        : InteractionType.BUTTONS_WITH_TEXT,\n                    variable: variableName,\n                    buttons: shape.buttons,\n                    question: shape.question,\n                    isMultiSelect: shape.isMultiSelect,\n                };\n            }\n            // Pure text input: ?[%{{var}}...question] or ?[%{{var}}]\n            return {\n                type: InteractionType.TEXT_ONLY,\n                variable: variableName,\n                question: shape.question ?? '',\n                isMultiSelect: false,\n            };\n        }\n        // Button group or single button: ?[%{{var}} Button1 | Button2]\n        return {\n            type: shape.isMultiSelect\n                ? InteractionType.BUTTONS_MULTI_SELECT\n                : InteractionType.BUTTONS_ONLY,\n            variable: variableName,\n            buttons: shape.buttons,\n            isMultiSelect: shape.isMultiSelect,\n        };\n    }\n    /**\n     * Layer 3: Parse non-assignment interactions (no variable). Same shapes as\n     * the variable branch; the answer is not assigned to a variable.\n     *\n     * @param content - Content\n     * @returns Parse result\n     */\n    _layer3ParseDisplayButtons(content) {\n        if (!content) {\n            // Empty content: ?[]\n            return {\n                type: InteractionType.NON_ASSIGNMENT_BUTTON,\n                buttons: [{ display: '', value: '' }],\n            };\n        }\n        const shape = this._parseContentShape(content);\n        const result = {\n            type: InteractionType.NON_ASSIGNMENT_BUTTON,\n            buttons: shape.buttons,\n            isMultiSelect: shape.isMultiSelect,\n        };\n        if (shape.hasTextInput) {\n            result.question = shape.question;\n        }\n        return result;\n    }\n    /**\n     * Parse button group with fault tolerance\n     *\n     * @param content - Button content, separated by | or ||\n     * @returns [button list, isMultiSelect]\n     */\n    _parseButtons(content) {\n        if (!content || typeof content !== 'string') {\n            return [[], false];\n        }\n        const [_separator, isMultiSelect] = this._detectSeparatorType(content);\n        const buttons = [];\n        try {\n            // Use different splitting logic based on separator type\n            let buttonTexts;\n            if (isMultiSelect) {\n                // Multi-select mode: split on ||, preserve single |\n                buttonTexts = (0, escaping_1.splitUnescaped)(content, '||');\n            }\n            else {\n                // Single-select mode: split on single |, but preserve ||\n                buttonTexts = (0, escaping_1.splitOnSingleUnescapedPipe)(content);\n            }\n            for (const buttonText of buttonTexts) {\n                const trimmed = buttonText.trim();\n                if (trimmed) {\n                    const button = this._parseSingleButton(trimmed);\n                    buttons.push(button);\n                }\n            }\n        }\n        catch {\n            // Fallback to treating entire content as single button\n            const whole = (0, escaping_1.unescapeInteractionText)(content).trim();\n            return [[{ display: whole, value: whole }], false];\n        }\n        // For empty content (like just separators), return empty list\n        if (!buttons.length &&\n            (content.trim() === '||' || content.trim() === '|')) {\n            return [[], isMultiSelect];\n        }\n        // Ensure at least one button exists (but only if there's actual content)\n        if (!buttons.length && content.trim()) {\n            const whole = (0, escaping_1.unescapeInteractionText)(content).trim();\n            buttons.push({ display: whole, value: whole });\n        }\n        return [buttons, isMultiSelect];\n    }\n    /**\n     * Parse single button, supports Button//value format\n     *\n     * @param buttonText - Button text\n     * @returns {display: display text, value: actual value}\n     */\n    _parseSingleButton(buttonText) {\n        buttonText = buttonText.trim();\n        // Detect Button//value format: split at the first \"//\" with a non-empty\n        // display before it and a non-empty value after it. (indexOf instead of\n        // a lazy/greedy regex, whose backtracking is super-linear.)\n        const separatorIndex = (0, escaping_1.findUnescaped)(buttonText, '//');\n        if (separatorIndex > 0 && separatorIndex + 2 < buttonText.length) {\n            return {\n                display: (0, escaping_1.unescapeInteractionText)(buttonText.slice(0, separatorIndex)).trim(),\n                value: (0, escaping_1.unescapeInteractionText)(buttonText.slice(separatorIndex + 2)).trim(),\n            };\n        }\n        const resolved = (0, escaping_1.unescapeInteractionText)(buttonText);\n        return { display: resolved, value: resolved };\n    }\n    /**\n     * Detect separator type and whether it's multi-select\n     *\n     * Logic: The first separator type encountered determines the parsing mode:\n     * - If first separator is |, then || is treated as part of the value\n     * - If first separator is ||, then single | is treated as part of the value\n     *\n     * @param content - Button content to analyze\n     * @returns [separator, isMultiSelect] where separator is '|' or '||'\n     */\n    _detectSeparatorType(content) {\n        if (!content || typeof content !== 'string') {\n            return ['|', false];\n        }\n        // Find the position of first single pipe and first double pipe.\n        // A bar an option escaped is not a separator.\n        const singlePipePos = (0, escaping_1.findUnescaped)(content, '|');\n        const doublePipePos = (0, escaping_1.findUnescaped)(content, '||');\n        // If no pipes found\n        if (singlePipePos === -1) {\n            return ['|', false];\n        }\n        // If no double pipe found, definitely single-select\n        if (doublePipePos === -1) {\n            return ['|', false];\n        }\n        // Both found - check which comes first\n        // If double pipe comes first or at the same position (which means\n        // the single pipe is part of the double pipe), it's multi-select mode\n        if (doublePipePos <= singlePipePos) {\n            return ['||', true];\n        }\n        // If single pipe comes first, it's single-select mode\n        return ['|', false];\n    }\n    /**\n     * Create error result\n     *\n     * @param errorMessage - Error message\n     * @returns Error result\n     */\n    _createErrorResult(errorMessage) {\n        return {\n            type: null,\n            error: errorMessage,\n        };\n    }\n}\nexports.InteractionParser = InteractionParser;\n/**\n * Convenience function for parsing interaction format\n *\n * Supported formats:\n * 1. ?[%{{var}}...question] - Pure text input\n * 2. ?[%{{var}} option1|option2] - Pure button group (supports display//value format)\n * 3. ?[%{{var}} option1|option2|...question] - Button group + text input\n * 4. ?[%{{var}} option1||option2] - Multi-select button group\n * 5. ?[%{{var}} option1||option2||...question] - Multi-select button group + text input\n * 6. ?[%{{var}} single option] - Single button selection\n * 7. ?[Continue] or ?[Continue|Cancel] - Non-assignment button\n *\n * @param content - Raw content of interaction block\n * @returns [interaction type, parsed data]\n */\nfunction parseInteractionFormat(content) {\n    // Use new layered parser\n    const parser = new InteractionParser();\n    const result = parser.parse(content);\n    // Handle parse errors\n    if (result.error) {\n        // Compatibility handling when parsing fails\n        return [InteractionType.TEXT_ONLY, { question: content.trim() }];\n    }\n    // Extract parse result and convert to original return format\n    const interactionType = result.type;\n    // Build return data dictionary for backward compatibility\n    const returnData = {};\n    if (result.type !== InteractionType.NON_ASSIGNMENT_BUTTON) {\n        const variableResult = result;\n        if (variableResult.variable !== undefined) {\n            returnData.variable = variableResult.variable;\n        }\n        if (variableResult.buttons !== undefined) {\n            returnData.buttons = variableResult.buttons;\n        }\n        if (variableResult.question !== undefined) {\n            returnData.question = variableResult.question;\n        }\n        if (variableResult.isMultiSelect !== undefined) {\n            returnData.isMultiSelect = variableResult.isMultiSelect;\n        }\n    }\n    else {\n        const buttonResult = result;\n        if (buttonResult.buttons !== undefined) {\n            returnData.buttons = buttonResult.buttons;\n        }\n    }\n    // Ensure we have a valid interaction type, fallback to TEXT_ONLY if null\n    const finalType = interactionType || InteractionType.TEXT_ONLY;\n    return [finalType, returnData];\n}\n/**\n * Factory function to create parser instance\n */\nfunction createInteractionParser() {\n    return new InteractionParser();\n}\n//# sourceMappingURL=interaction-parser.js.map"],"names":["exports","parseInteractionFormat","createInteractionParser","escaping_1","require$$0","InteractionType","InteractionParser","content","innerContent","hasVariable","variableName","remainingContent","error","result","remarkResult","nonAssignmentResult","b","variableResult","match","ellipsis","beforeEllipsis","question","buttons","isMultiSelect","shape","_separator","buttonTexts","buttonText","trimmed","button","whole","separatorIndex","resolved","singlePipePos","doublePipePos","errorMessage","interactionType","returnData","buttonResult"],"mappings":"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","x_google_ignoreList":[0]}
+{"version":3,"file":"interaction-parser.es.js","sources":["../../../../node_modules/remark-flow/dist/interaction-parser.js"],"sourcesContent":["\"use strict\";\n/**\n * MarkdownFlow Interactive Block Layered Parser - TypeScript Version\n *\n * Uses a three-layer analysis architecture:\n * Layer 1: ?[] format validation\n * Layer 2: Variable detection and pattern classification\n * Layer 3: Specific content parsing\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.InteractionParser = exports.COMPILED_REGEXES = exports.InteractionType = void 0;\nexports.parseInteractionFormat = parseInteractionFormat;\nexports.createInteractionParser = createInteractionParser;\nconst escaping_1 = require(\"./escaping\");\nconst variable_name_1 = require(\"./variable-name\");\n// Interaction input type enumeration\nvar InteractionType;\n(function (InteractionType) {\n    InteractionType[\"TEXT_ONLY\"] = \"text_only\";\n    InteractionType[\"BUTTONS_ONLY\"] = \"buttons_only\";\n    InteractionType[\"BUTTONS_WITH_TEXT\"] = \"buttons_with_text\";\n    InteractionType[\"BUTTONS_MULTI_SELECT\"] = \"buttons_multi_select\";\n    InteractionType[\"BUTTONS_MULTI_WITH_TEXT\"] = \"buttons_multi_with_text\";\n    InteractionType[\"NON_ASSIGNMENT_BUTTON\"] = \"non_assignment_button\";\n})(InteractionType || (exports.InteractionType = InteractionType = {}));\n// Pre-compiled regex constants\nexports.COMPILED_REGEXES = {\n    // Layer 1: Basic format validation - matches ?[content] but excludes ?[text](url) format.\n    // The content accepts an escaped delimiter as one unit, so a `\\]` inside an option does not\n    // end the interaction. See ./escaping.\n    LAYER1_INTERACTION: new RegExp(`\\\\?\\\\[(${escaping_1.INTERACTION_CONTENT_SOURCE})\\\\](?!\\\\()`),\n    // Names use the teaching engine's grammar; only the content after the marker is split into\n    // choices, display/value pairs or a text input. Punctuation inside the name is ordinary text.\n    LAYER2_VARIABLE: new RegExp(`^${variable_name_1.VARIABLE_PADDING_SOURCE}${variable_name_1.VARIABLE_ASSIGNMENT_SOURCE}([\\\\s\\\\S]*)$`),\n    // Layer 3: Split content before and after ...\n    LAYER3_ELLIPSIS: /^(.*?)\\.\\.\\.(.*)/,\n    // Kept for consumers that inspect the exported regex collection. Exact\n    // single-pipe splitting requires context that Safari-safe regexes cannot\n    // express without consuming adjacent text, and now also has to skip a bar\n    // an option escaped, so the parser uses the scanner in ./escaping instead.\n    LAYER3_SINGLE_PIPE_SPLIT: /\\|(?!\\|)/g,\n};\n/**\n * Layered interaction parser class\n */\nclass InteractionParser {\n    constructor() {\n        // Constructor is intentionally empty - no initialization needed\n    }\n    /**\n     * Main parsing method\n     *\n     * @param content - Raw content of interaction block\n     * @returns Standardized parse result\n     */\n    parse(content) {\n        try {\n            // Layer 1: Validate basic format\n            const innerContent = this._layer1ValidateFormat(content);\n            if (innerContent === null) {\n                return this._createErrorResult(`Invalid interaction format: ${content}`);\n            }\n            // Layer 2: Variable detection and pattern classification\n            const [hasVariable, variableName, remainingContent] = this._layer2DetectVariable(innerContent);\n            // Layer 3: Specific content parsing\n            if (hasVariable && variableName === null) {\n                return this._createErrorResult('Invalid variable name');\n            }\n            if (hasVariable && variableName) {\n                return this._layer3ParseVariableInteraction(variableName, remainingContent);\n            }\n            else {\n                return this._layer3ParseDisplayButtons(innerContent);\n            }\n        }\n        catch (error) {\n            return this._createErrorResult(`Parsing error: ${error instanceof Error ? error.message : 'Unknown error'}`);\n        }\n    }\n    /**\n     * Parse and convert to remark-compatible format\n     *\n     * @param content - Raw content of interaction block\n     * @returns remark-compatible result object\n     */\n    parseToRemarkFormat(content) {\n        const result = this.parse(content);\n        if (result.error) {\n            // Compatibility handling when parsing fails\n            return { placeholder: (0, variable_name_1.trimVariablePadding)(content) };\n        }\n        // Convert to remark-compatible format\n        const remarkResult = {};\n        if (result.type === InteractionType.NON_ASSIGNMENT_BUTTON) {\n            // Non-assignment interaction (no variableName in the output)\n            const nonAssignmentResult = result;\n            if (nonAssignmentResult.buttons.length > 0) {\n                remarkResult.buttonTexts = nonAssignmentResult.buttons.map(b => b.display);\n                remarkResult.buttonValues = nonAssignmentResult.buttons.map(b => b.value);\n            }\n            if (nonAssignmentResult.question !== undefined) {\n                remarkResult.placeholder = nonAssignmentResult.question;\n            }\n            if (nonAssignmentResult.isMultiSelect !== undefined) {\n                remarkResult.isMultiSelect = nonAssignmentResult.isMultiSelect;\n            }\n        }\n        else if (result.type !== null) {\n            // Variable interaction\n            const variableResult = result;\n            remarkResult.variableName = variableResult.variable;\n            if (variableResult.buttons) {\n                remarkResult.buttonTexts = variableResult.buttons.map(b => b.display);\n                remarkResult.buttonValues = variableResult.buttons.map(b => b.value);\n            }\n            if (variableResult.question !== undefined) {\n                remarkResult.placeholder = variableResult.question;\n            }\n            if (variableResult.isMultiSelect !== undefined) {\n                remarkResult.isMultiSelect = variableResult.isMultiSelect;\n            }\n        }\n        return remarkResult;\n    }\n    /**\n     * Layer 1: Validate ?[] format and extract content\n     *\n     * @param content - Raw content\n     * @returns Extracted bracket content, returns null if validation fails\n     */\n    _layer1ValidateFormat(content) {\n        content = (0, variable_name_1.trimVariablePadding)(content);\n        const span = (0, escaping_1.readInteraction)(content);\n        return span?.complete && span.end === content.length ? span.content : null;\n    }\n    /**\n     * Layer 2: Detect variables and perform pattern classification\n     *\n     * @param innerContent - Content extracted from layer 1\n     * @returns [hasVariable, variableName, remainingContent]\n     */\n    _layer2DetectVariable(innerContent) {\n        innerContent = (0, variable_name_1.trimVariablePadding)(innerContent);\n        if (!innerContent.startsWith('%{{')) {\n            // No variable, entire content used for display button parsing\n            return [false, null, innerContent];\n        }\n        const marker = (0, variable_name_1.readVariableMarker)(innerContent, 1);\n        if (!marker)\n            return [true, null, innerContent];\n        const variableName = (0, variable_name_1.normalizeVariableName)(marker.rawName);\n        const remainingContent = (0, variable_name_1.trimVariablePadding)(innerContent.slice(marker.end));\n        return [true, variableName, remainingContent];\n    }\n    /**\n     * Parse the structural shape of interaction content: buttons, optional\n     * `...question` text input, multi-select flag. Shared by the variable and\n     * non-assignment branches, which only differ in how they map the shape\n     * into their result types.\n     *\n     * @param content - Content after the (optional) variable\n     * @returns The parsed content shape\n     */\n    _parseContentShape(content) {\n        const ellipsis = (0, escaping_1.splitOnEllipsis)(content);\n        if (ellipsis) {\n            const beforeEllipsis = (0, variable_name_1.trimVariablePadding)(ellipsis[0]);\n            const question = (0, variable_name_1.trimVariablePadding)((0, escaping_1.unescapeInteractionText)(ellipsis[1]));\n            if (beforeEllipsis) {\n                // Button group + text input: ?[Button1 | Button2 | ...question]\n                const [buttons, isMultiSelect] = this._parseButtons(beforeEllipsis);\n                return { buttons, question, isMultiSelect, hasTextInput: true };\n            }\n            // Pure text input: ?[...question]\n            return {\n                buttons: [],\n                question,\n                isMultiSelect: false,\n                hasTextInput: true,\n            };\n        }\n        if ((0, escaping_1.findUnescaped)(content, '|') >= 0) {\n            // Button group: ?[Button1 | Button2] or ?[Button1 || Button2]\n            const [buttons, isMultiSelect] = this._parseButtons(content);\n            return { buttons, isMultiSelect, hasTextInput: false };\n        }\n        if (content) {\n            // Single button: ?[Button1] or ?[Button1//id1]\n            return {\n                buttons: [this._parseSingleButton(content)],\n                isMultiSelect: false,\n                hasTextInput: false,\n            };\n        }\n        // Empty content: pure text input with no prompt\n        return {\n            buttons: [],\n            question: '',\n            isMultiSelect: false,\n            hasTextInput: true,\n        };\n    }\n    /**\n     * Layer 3: Parse variable interaction (variable assignment type)\n     *\n     * @param variableName - Variable name\n     * @param content - Content after variable\n     * @returns Parse result\n     */\n    _layer3ParseVariableInteraction(variableName, content) {\n        const shape = this._parseContentShape(content);\n        if (shape.hasTextInput) {\n            if (shape.buttons.length > 0) {\n                // Button group + text input: ?[%{{var}} Button1 | Button2 | ...question]\n                return {\n                    type: shape.isMultiSelect\n                        ? InteractionType.BUTTONS_MULTI_WITH_TEXT\n                        : InteractionType.BUTTONS_WITH_TEXT,\n                    variable: variableName,\n                    buttons: shape.buttons,\n                    question: shape.question,\n                    isMultiSelect: shape.isMultiSelect,\n                };\n            }\n            // Pure text input: ?[%{{var}}...question] or ?[%{{var}}]\n            return {\n                type: InteractionType.TEXT_ONLY,\n                variable: variableName,\n                question: shape.question ?? '',\n                isMultiSelect: false,\n            };\n        }\n        // Button group or single button: ?[%{{var}} Button1 | Button2]\n        return {\n            type: shape.isMultiSelect\n                ? InteractionType.BUTTONS_MULTI_SELECT\n                : InteractionType.BUTTONS_ONLY,\n            variable: variableName,\n            buttons: shape.buttons,\n            isMultiSelect: shape.isMultiSelect,\n        };\n    }\n    /**\n     * Layer 3: Parse non-assignment interactions (no variable). Same shapes as\n     * the variable branch; the answer is not assigned to a variable.\n     *\n     * @param content - Content\n     * @returns Parse result\n     */\n    _layer3ParseDisplayButtons(content) {\n        if (!content) {\n            // Empty content: ?[]\n            return {\n                type: InteractionType.NON_ASSIGNMENT_BUTTON,\n                buttons: [{ display: '', value: '' }],\n            };\n        }\n        const shape = this._parseContentShape(content);\n        const result = {\n            type: InteractionType.NON_ASSIGNMENT_BUTTON,\n            buttons: shape.buttons,\n            isMultiSelect: shape.isMultiSelect,\n        };\n        if (shape.hasTextInput) {\n            result.question = shape.question;\n        }\n        return result;\n    }\n    /**\n     * Parse button group with fault tolerance\n     *\n     * @param content - Button content, separated by | or ||\n     * @returns [button list, isMultiSelect]\n     */\n    _parseButtons(content) {\n        if (!content || typeof content !== 'string') {\n            return [[], false];\n        }\n        const [_separator, isMultiSelect] = this._detectSeparatorType(content);\n        const buttons = [];\n        try {\n            // Use different splitting logic based on separator type\n            let buttonTexts;\n            if (isMultiSelect) {\n                // Multi-select mode: split on ||, preserve single |\n                buttonTexts = (0, escaping_1.splitUnescaped)(content, '||');\n            }\n            else {\n                // Single-select mode: split on single |, but preserve ||\n                buttonTexts = (0, escaping_1.splitOnSingleUnescapedPipe)(content);\n            }\n            for (const buttonText of buttonTexts) {\n                const trimmed = (0, variable_name_1.trimVariablePadding)(buttonText);\n                if (trimmed) {\n                    const button = this._parseSingleButton(trimmed);\n                    buttons.push(button);\n                }\n            }\n        }\n        catch {\n            // Fallback to treating entire content as single button\n            const whole = (0, variable_name_1.trimVariablePadding)((0, escaping_1.unescapeInteractionText)(content));\n            return [[{ display: whole, value: whole }], false];\n        }\n        // For empty content (like just separators), return empty list\n        if (!buttons.length &&\n            ((0, variable_name_1.trimVariablePadding)(content) === '||' ||\n                (0, variable_name_1.trimVariablePadding)(content) === '|')) {\n            return [[], isMultiSelect];\n        }\n        // Ensure at least one button exists (but only if there's actual content)\n        if (!buttons.length && (0, variable_name_1.trimVariablePadding)(content)) {\n            const whole = (0, variable_name_1.trimVariablePadding)((0, escaping_1.unescapeInteractionText)(content));\n            buttons.push({ display: whole, value: whole });\n        }\n        return [buttons, isMultiSelect];\n    }\n    /**\n     * Parse single button, supports Button//value format\n     *\n     * @param buttonText - Button text\n     * @returns {display: display text, value: actual value}\n     */\n    _parseSingleButton(buttonText) {\n        buttonText = (0, variable_name_1.trimVariablePadding)(buttonText);\n        // Detect Button//value format: split at the first \"//\" with a non-empty\n        // display before it and a non-empty value after it. (indexOf instead of\n        // a lazy/greedy regex, whose backtracking is super-linear.)\n        const separatorIndex = (0, escaping_1.findUnescaped)(buttonText, '//');\n        if (separatorIndex > 0 && separatorIndex + 2 < buttonText.length) {\n            return {\n                display: (0, variable_name_1.trimVariablePadding)((0, escaping_1.unescapeInteractionText)(buttonText.slice(0, separatorIndex))),\n                value: (0, variable_name_1.trimVariablePadding)((0, escaping_1.unescapeInteractionText)(buttonText.slice(separatorIndex + 2))),\n            };\n        }\n        const resolved = (0, escaping_1.unescapeInteractionText)(buttonText);\n        return { display: resolved, value: resolved };\n    }\n    /**\n     * Detect separator type and whether it's multi-select\n     *\n     * Logic: The first separator type encountered determines the parsing mode:\n     * - If first separator is |, then || is treated as part of the value\n     * - If first separator is ||, then single | is treated as part of the value\n     *\n     * @param content - Button content to analyze\n     * @returns [separator, isMultiSelect] where separator is '|' or '||'\n     */\n    _detectSeparatorType(content) {\n        if (!content || typeof content !== 'string') {\n            return ['|', false];\n        }\n        // Find the position of first single pipe and first double pipe.\n        // A bar an option escaped is not a separator.\n        const singlePipePos = (0, escaping_1.findUnescaped)(content, '|');\n        const doublePipePos = (0, escaping_1.findUnescaped)(content, '||');\n        // If no pipes found\n        if (singlePipePos === -1) {\n            return ['|', false];\n        }\n        // If no double pipe found, definitely single-select\n        if (doublePipePos === -1) {\n            return ['|', false];\n        }\n        // Both found - check which comes first\n        // If double pipe comes first or at the same position (which means\n        // the single pipe is part of the double pipe), it's multi-select mode\n        if (doublePipePos <= singlePipePos) {\n            return ['||', true];\n        }\n        // If single pipe comes first, it's single-select mode\n        return ['|', false];\n    }\n    /**\n     * Create error result\n     *\n     * @param errorMessage - Error message\n     * @returns Error result\n     */\n    _createErrorResult(errorMessage) {\n        return {\n            type: null,\n            error: errorMessage,\n        };\n    }\n}\nexports.InteractionParser = InteractionParser;\n/**\n * Convenience function for parsing interaction format\n *\n * Supported formats:\n * 1. ?[%{{var}}...question] - Pure text input\n * 2. ?[%{{var}} option1|option2] - Pure button group (supports display//value format)\n * 3. ?[%{{var}} option1|option2|...question] - Button group + text input\n * 4. ?[%{{var}} option1||option2] - Multi-select button group\n * 5. ?[%{{var}} option1||option2||...question] - Multi-select button group + text input\n * 6. ?[%{{var}} single option] - Single button selection\n * 7. ?[Continue] or ?[Continue|Cancel] - Non-assignment button\n *\n * @param content - Raw content of interaction block\n * @returns [interaction type, parsed data]\n */\nfunction parseInteractionFormat(content) {\n    // Use new layered parser\n    const parser = new InteractionParser();\n    const result = parser.parse(content);\n    // Handle parse errors\n    if (result.error) {\n        // Compatibility handling when parsing fails\n        return [\n            InteractionType.TEXT_ONLY,\n            { question: (0, variable_name_1.trimVariablePadding)(content) },\n        ];\n    }\n    // Extract parse result and convert to original return format\n    const interactionType = result.type;\n    // Build return data dictionary for backward compatibility\n    const returnData = {};\n    if (result.type !== InteractionType.NON_ASSIGNMENT_BUTTON) {\n        const variableResult = result;\n        if (variableResult.variable !== undefined) {\n            returnData.variable = variableResult.variable;\n        }\n        if (variableResult.buttons !== undefined) {\n            returnData.buttons = variableResult.buttons;\n        }\n        if (variableResult.question !== undefined) {\n            returnData.question = variableResult.question;\n        }\n        if (variableResult.isMultiSelect !== undefined) {\n            returnData.isMultiSelect = variableResult.isMultiSelect;\n        }\n    }\n    else {\n        const buttonResult = result;\n        if (buttonResult.buttons !== undefined) {\n            returnData.buttons = buttonResult.buttons;\n        }\n    }\n    // Ensure we have a valid interaction type, fallback to TEXT_ONLY if null\n    const finalType = interactionType || InteractionType.TEXT_ONLY;\n    return [finalType, returnData];\n}\n/**\n * Factory function to create parser instance\n */\nfunction createInteractionParser() {\n    return new InteractionParser();\n}\n//# sourceMappingURL=interaction-parser.js.map"],"names":["interactionParser","parseInteractionFormat","createInteractionParser","escaping_1","require$$0","variable_name_1","require$$1","InteractionType","InteractionParser","content","innerContent","hasVariable","variableName","remainingContent","error","result","remarkResult","nonAssignmentResult","b","variableResult","span","marker","ellipsis","beforeEllipsis","question","buttons","isMultiSelect","shape","_separator","buttonTexts","buttonText","trimmed","button","whole","separatorIndex","resolved","singlePipePos","doublePipePos","errorMessage","interactionType","returnData","buttonResult"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/remark-flow/dist/interaction-plugin-core.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const l=require("../../../_virtual/interaction-plugin-core.cjs"),v=require("../../../_virtual/index3.cjs"),C=require("./interaction-parser.cjs"),q=require("./escaping.cjs"),O=require("./interaction-syntax.cjs");var g;function P(){if(g)return l.__exports;g=1,Object.defineProperty(l.__exports,"__esModule",{value:!0}),l.__exports.transformInteractionsInTree=E;const p=v.default,I=C.__require(),d=q.__require(),f=O.__require();function m(e,i,s,n,t){return[{type:"text",value:e.substring(0,i)},{type:"element",data:{hName:t,hProperties:n}},{type:"text",value:e.substring(s)}]}function y(e,i,s){const n=new RegExp(`^\\?\\[(${d.INTERACTION_CONTENT_SOURCE})\\]$`).exec(e);if(!n)return null;const t=n[1];if(t.includes("%{")&&(!t.includes("%{{")||t.includes("%{{}}")))return null;try{return i.parseToRemarkFormat(e)}catch(r){return console.warn(`Failed to parse ${s} syntax:`,r),null}}function E(e,i){const s=e.data,n=new I.InteractionParser;if(s?.[f.TOKENIZED_TREE]===!0){(0,p.visit)(e,f.INTERACTION_NODE,(t,r,o)=>{if(r===null||o===null)return;const c=t.value,_=y(c,n,i);o.children.splice(r,1,_?{type:"element",data:{hName:"custom-variable",hProperties:_}}:{type:"text",value:c})});return}(0,p.visit)(e,"text",(t,r,o)=>{if(r===null||o===null)return;const c=t.value,u=new RegExp(`\\?\\[(${d.INTERACTION_CONTENT_SOURCE})\\](?!\\()`).exec(c);if(u){const x=u[0],T=u.index,R=T+x.length;try{const a=u[1];if(a.includes("%{")&&(!a.includes("%{{")||a.includes("%{{}}")))return;const h=n.parseToRemarkFormat(x),N=m(c,T,R,h,"custom-variable");o.children.splice(r,1,...N)}catch(a){console.warn(`Failed to parse ${i} syntax:`,a)}}})}return l.__exports}exports.__require=P;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const _=require("../../../_virtual/interaction-plugin-core.cjs"),P=require("../../../_virtual/index4.cjs"),b=require("./interaction-parser.cjs"),E=require("./escaping.cjs"),T=require("./interaction-syntax.cjs"),N=require("./variable-name.cjs");var v;function O(){if(v)return _.__exports;v=1,Object.defineProperty(_.__exports,"__esModule",{value:!0}),_.__exports.transformInteractionsInTree=q;const p=P.default,y=b.__require(),f=E.__require(),d=T.__require(),h=N.__require();function g(e,s,l,o,r){return[{type:"text",value:e.substring(0,s)},{type:"element",data:{hName:r,hProperties:o}},{type:"text",value:e.substring(l)}]}function m(e,s,l){const o=(0,f.readInteraction)(e);if(!o?.complete||o.end!==e.length)return null;const r=(0,h.trimVariablePadding)(o.content);if(r.startsWith("%{")&&!r.startsWith("%{{"))return null;try{return s.parse(e).error?null:s.parseToRemarkFormat(e)}catch(n){return console.warn(`Failed to parse ${l} syntax:`,n),null}}function q(e,s){const l=e.data,o=new y.InteractionParser;if(l?.[d.TOKENIZED_TREE]===!0){(0,p.visit)(e,d.VARIABLE_NODE,(r,n,a)=>{n===null||a===null||a.children.splice(n,1,{type:"text",value:r.value})}),(0,p.visit)(e,d.INTERACTION_NODE,(r,n,a)=>{if(n===null||a===null)return;const i=r.value,t=m(i,o,s);a.children.splice(n,1,t?{type:"element",data:{hName:"custom-variable",hProperties:t}}:{type:"text",value:i})});return}(0,p.visit)(e,"text",(r,n,a)=>{if(n===null||a===null)return;const i=r.value;let t=0;for(;t<i.length;){if(i.startsWith("{{",t)){const c=(0,h.readVariableMarker)(i,t);if(!c)return;t=c.end;continue}if(!i.startsWith("?[",t)){t+=1;continue}const u=(0,f.readInteraction)(i,t);if(!u){t+=2;continue}if(!u.complete)return;const I=i.slice(u.start,u.end);try{const c=m(I,o,s);if(!c){t=u.end;continue}const x=g(i,u.start,u.end,c,"custom-variable");a.children.splice(n,1,...x);return}catch(c){console.warn(`Failed to parse ${s} syntax:`,c);return}}})}return _.__exports}exports.__require=O;
 //# sourceMappingURL=interaction-plugin-core.cjs.map

package/dist/node_modules/remark-flow/dist/interaction-plugin-core.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"interaction-plugin-core.cjs","sources":["../../../../node_modules/remark-flow/dist/interaction-plugin-core.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.transformInteractionsInTree = transformInteractionsInTree;\nconst unist_util_visit_1 = require(\"unist-util-visit\");\nconst interaction_parser_1 = require(\"./interaction-parser\");\nconst escaping_1 = require(\"./escaping\");\nconst interaction_syntax_1 = require(\"./interaction-syntax\");\n/**\n * Create AST node segments\n */\nfunction createSegments(value, startIndex, endIndex, parsedResult, hName) {\n    return [\n        {\n            type: 'text',\n            value: value.substring(0, startIndex),\n        },\n        {\n            type: 'element',\n            data: {\n                hName,\n                hProperties: parsedResult,\n            },\n        },\n        {\n            type: 'text',\n            value: value.substring(endIndex),\n        },\n    ];\n}\n/**\n * Parse `value` as one whole interaction, or return null if it should stay text.\n *\n * Invalid variable syntax is kept as text rather than misparsed: `%{variable}` with one brace,\n * or `%{{}}` with no name, would otherwise become display buttons.\n */\nfunction parseWhole(value, parser, warnLabel) {\n    const whole = new RegExp(`^\\\\?\\\\[(${escaping_1.INTERACTION_CONTENT_SOURCE})\\\\]$`).exec(value);\n    if (!whole)\n        return null;\n    const innerContent = whole[1];\n    if (innerContent.includes('%{') &&\n        (!innerContent.includes('%{{') || innerContent.includes('%{{}}'))) {\n        return null;\n    }\n    try {\n        return parser.parseToRemarkFormat(value);\n    }\n    catch (error) {\n        console.warn(`Failed to parse ${warnLabel} syntax:`, error);\n        return null;\n    }\n}\n/**\n * Shared visitor body for the remark plugins: find `?[...]` interaction\n * syntax and replace it with a `custom-variable` element.\n * remark-interaction and remark-custom-variable are thin wrappers around\n * this (they only differ in the warning label used on parse failures).\n *\n * @param tree - The AST to transform in place\n * @param warnLabel - Label used in the console warning on parse failures\n *\n * A tree parsed with the interaction tokenizer is marked so at its root, and its interactions\n * are the tokenizer's own nodes, which nothing else rewrites: each becomes an element, or text\n * if it does not parse. Text nodes are not read in such a tree -- any `?[` in one is something\n * Markdown has already rewritten, `\\?[` with its escape consumed, and reading it as a question\n * would turn text the author escaped into buttons. A tree without the mark (parsed by another\n * processor, or built by hand) is read from its text nodes, as it always was.\n */\nfunction transformInteractionsInTree(tree, warnLabel) {\n    const rootData = tree.data;\n    const parser = new interaction_parser_1.InteractionParser();\n    if (rootData?.[interaction_syntax_1.TOKENIZED_TREE] === true) {\n        (0, unist_util_visit_1.visit)(tree, interaction_syntax_1.INTERACTION_NODE, (node, index, parent) => {\n            if (index === null || parent === null)\n                return;\n            const value = node.value;\n            const parsed = parseWhole(value, parser, warnLabel);\n            parent.children.splice(index, 1, parsed\n                ? {\n                    type: 'element',\n                    data: { hName: 'custom-variable', hProperties: parsed },\n                }\n                : { type: 'text', value });\n        });\n        return;\n    }\n    (0, unist_util_visit_1.visit)(tree, 'text', (node, index, parent) => {\n        // Input validation\n        if (index === null || parent === null)\n            return;\n        const value = node.value;\n        // Check if contains interaction syntax\n        const interactionRegex = new RegExp(`\\\\?\\\\[(${escaping_1.INTERACTION_CONTENT_SOURCE})\\\\](?!\\\\()`);\n        const match = interactionRegex.exec(value);\n        if (match) {\n            const fullMatch = match[0];\n            const startIndex = match.index;\n            const endIndex = startIndex + fullMatch.length;\n            try {\n                // Check for invalid variable syntax: keep the original text\n                // instead of misparsing %{variable} / %{{}} as display buttons.\n                const innerContent = match[1];\n                if (innerContent.includes('%{')) {\n                    if (!innerContent.includes('%{{')) {\n                        // Contains invalid variable syntax %{variable} instead of %{{variable}}\n                        return;\n                    }\n                    // Check for empty variable name %{{}}\n                    if (innerContent.includes('%{{}}')) {\n                        return;\n                    }\n                }\n                const parsedResult = parser.parseToRemarkFormat(fullMatch);\n                // Create AST segments\n                const segments = createSegments(value, startIndex, endIndex, parsedResult, 'custom-variable');\n                parent.children.splice(index, 1, ...segments);\n            }\n            catch (error) {\n                console.warn(`Failed to parse ${warnLabel} syntax:`, error);\n                // Keep original if parsing fails\n            }\n        }\n    });\n}\n//# sourceMappingURL=interaction-plugin-core.js.map"],"names":["interactionPluginCore","transformInteractionsInTree","unist_util_visit_1","require$$0","interaction_parser_1","require$$1","escaping_1","require$$2","interaction_syntax_1","require$$3","createSegments","value","startIndex","endIndex","parsedResult","hName","parseWhole","parser","warnLabel","whole","innerContent","error","tree","rootData","node","index","parent","parsed","match","fullMatch","segments"],"mappings":"kVACA,OAAO,eAAeA,EAAAA,UAAS,aAAc,CAAE,MAAO,GAAM,EAC5DA,EAAAA,UAAA,4BAAsCC,EACtC,MAAMC,EAAqBC,EAAAA,QACrBC,EAAuBC,EAAAA,UAAA,EACvBC,EAAaC,EAAAA,UAAA,EACbC,EAAuBC,EAAAA,UAAA,EAI7B,SAASC,EAAeC,EAAOC,EAAYC,EAAUC,EAAcC,EAAO,CACtE,MAAO,CACH,CACI,KAAM,OACN,MAAOJ,EAAM,UAAU,EAAGC,CAAU,GAExC,CACI,KAAM,UACN,KAAM,CACF,MAAAG,EACA,YAAaD,IAGrB,CACI,KAAM,OACN,MAAOH,EAAM,UAAUE,CAAQ,GAG3C,CAOA,SAASG,EAAWL,EAAOM,EAAQC,EAAW,CAC1C,MAAMC,EAAQ,IAAI,OAAO,WAAWb,EAAW,0BAA0B,OAAO,EAAE,KAAKK,CAAK,EAC5F,GAAI,CAACQ,EACD,OAAO,KACX,MAAMC,EAAeD,EAAM,CAAC,EAC5B,GAAIC,EAAa,SAAS,IAAI,IACzB,CAACA,EAAa,SAAS,KAAK,GAAKA,EAAa,SAAS,OAAO,GAC/D,OAAO,KAEX,GAAI,CACA,OAAOH,EAAO,oBAAoBN,CAAK,CAC/C,OACWU,EAAO,CACV,eAAQ,KAAK,mBAAmBH,CAAS,WAAYG,CAAK,EACnD,IACf,CACA,CAiBA,SAASpB,EAA4BqB,EAAMJ,EAAW,CAClD,MAAMK,EAAWD,EAAK,KAChBL,EAAS,IAAIb,EAAqB,kBACxC,GAAImB,IAAWf,EAAqB,cAAc,IAAM,GAAM,IACtDN,EAAmB,OAAOoB,EAAMd,EAAqB,iBAAkB,CAACgB,EAAMC,EAAOC,IAAW,CAChG,GAAID,IAAU,MAAQC,IAAW,KAC7B,OACJ,MAAMf,EAAQa,EAAK,MACbG,EAASX,EAAWL,EAAOM,EAAQC,CAAS,EAClDQ,EAAO,SAAS,OAAOD,EAAO,EAAGE,EAC3B,CACE,KAAM,UACN,KAAM,CAAE,MAAO,kBAAmB,YAAaA,CAAM,CACzE,EACkB,CAAE,KAAM,OAAQ,MAAAhB,EAAO,CACzC,CAAS,EACD,MACR,IACQT,EAAmB,OAAOoB,EAAM,OAAQ,CAACE,EAAMC,EAAOC,IAAW,CAEjE,GAAID,IAAU,MAAQC,IAAW,KAC7B,OACJ,MAAMf,EAAQa,EAAK,MAGbI,EADmB,IAAI,OAAO,UAAUtB,EAAW,0BAA0B,aAAa,EACjE,KAAKK,CAAK,EACzC,GAAIiB,EAAO,CACP,MAAMC,EAAYD,EAAM,CAAC,EACnBhB,EAAagB,EAAM,MACnBf,EAAWD,EAAaiB,EAAU,OACxC,GAAI,CAGA,MAAMT,EAAeQ,EAAM,CAAC,EAC5B,GAAIR,EAAa,SAAS,IAAI,IACtB,CAACA,EAAa,SAAS,KAAK,GAK5BA,EAAa,SAAS,OAAO,GAC7B,OAGR,MAAMN,EAAeG,EAAO,oBAAoBY,CAAS,EAEnDC,EAAWpB,EAAeC,EAAOC,EAAYC,EAAUC,EAAc,iBAAiB,EAC5FY,EAAO,SAAS,OAAOD,EAAO,EAAG,GAAGK,CAAQ,CAC5D,OACmBT,EAAO,CACV,QAAQ,KAAK,mBAAmBH,CAAS,WAAYG,CAAK,CAE1E,CACA,CACA,CAAK,CACL","x_google_ignoreList":[0]}
+{"version":3,"file":"interaction-plugin-core.cjs","sources":["../../../../node_modules/remark-flow/dist/interaction-plugin-core.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.transformInteractionsInTree = transformInteractionsInTree;\nconst unist_util_visit_1 = require(\"unist-util-visit\");\nconst interaction_parser_1 = require(\"./interaction-parser\");\nconst escaping_1 = require(\"./escaping\");\nconst interaction_syntax_1 = require(\"./interaction-syntax\");\nconst variable_name_1 = require(\"./variable-name\");\n/**\n * Create AST node segments\n */\nfunction createSegments(value, startIndex, endIndex, parsedResult, hName) {\n    return [\n        {\n            type: 'text',\n            value: value.substring(0, startIndex),\n        },\n        {\n            type: 'element',\n            data: {\n                hName,\n                hProperties: parsedResult,\n            },\n        },\n        {\n            type: 'text',\n            value: value.substring(endIndex),\n        },\n    ];\n}\n/**\n * Parse `value` as one whole interaction, or return null if it should stay text.\n *\n * A leading assignment is validated after reading its whole body. Marker-looking text inside\n * an opaque name or an option does not change whether the interaction is valid.\n */\nfunction parseWhole(value, parser, warnLabel) {\n    const span = (0, escaping_1.readInteraction)(value);\n    if (!span?.complete || span.end !== value.length)\n        return null;\n    const innerContent = (0, variable_name_1.trimVariablePadding)(span.content);\n    if (innerContent.startsWith('%{') && !innerContent.startsWith('%{{')) {\n        return null;\n    }\n    try {\n        if (parser.parse(value).error)\n            return null;\n        return parser.parseToRemarkFormat(value);\n    }\n    catch (error) {\n        console.warn(`Failed to parse ${warnLabel} syntax:`, error);\n        return null;\n    }\n}\n/**\n * Shared visitor body for the remark plugins: find `?[...]` interaction\n * syntax and replace it with a `custom-variable` element.\n * remark-interaction and remark-custom-variable are thin wrappers around\n * this (they only differ in the warning label used on parse failures).\n *\n * @param tree - The AST to transform in place\n * @param warnLabel - Label used in the console warning on parse failures\n *\n * A tree parsed with the interaction tokenizer is marked so at its root, and its interactions\n * are the tokenizer's own nodes, which nothing else rewrites: each becomes an element, or text\n * if it does not parse. Text nodes are not read in such a tree -- any `?[` in one is something\n * Markdown has already rewritten, `\\?[` with its escape consumed, and reading it as a question\n * would turn text the author escaped into buttons. A tree without the mark (parsed by another\n * processor, or built by hand) is read from its text nodes, as it always was.\n */\nfunction transformInteractionsInTree(tree, warnLabel) {\n    const rootData = tree.data;\n    const parser = new interaction_parser_1.InteractionParser();\n    if (rootData?.[interaction_syntax_1.TOKENIZED_TREE] === true) {\n        (0, unist_util_visit_1.visit)(tree, interaction_syntax_1.VARIABLE_NODE, (node, index, parent) => {\n            if (index === null || parent === null)\n                return;\n            parent.children.splice(index, 1, {\n                type: 'text',\n                value: node.value,\n            });\n        });\n        (0, unist_util_visit_1.visit)(tree, interaction_syntax_1.INTERACTION_NODE, (node, index, parent) => {\n            if (index === null || parent === null)\n                return;\n            // The tokenizer retains raw NUL provenance without reintroducing container prefixes.\n            const value = node.value;\n            const parsed = parseWhole(value, parser, warnLabel);\n            parent.children.splice(index, 1, parsed\n                ? {\n                    type: 'element',\n                    data: { hName: 'custom-variable', hProperties: parsed },\n                }\n                : { type: 'text', value });\n        });\n        return;\n    }\n    (0, unist_util_visit_1.visit)(tree, 'text', (node, index, parent) => {\n        // Input validation\n        if (index === null || parent === null)\n            return;\n        const value = node.value;\n        let cursor = 0;\n        while (cursor < value.length) {\n            if (value.startsWith('{{', cursor)) {\n                const marker = (0, variable_name_1.readVariableMarker)(value, cursor);\n                if (!marker)\n                    return;\n                cursor = marker.end;\n                continue;\n            }\n            if (!value.startsWith('?[', cursor)) {\n                cursor += 1;\n                continue;\n            }\n            const span = (0, escaping_1.readInteraction)(value, cursor);\n            if (!span) {\n                cursor += 2;\n                continue;\n            }\n            if (!span.complete)\n                return;\n            const fullMatch = value.slice(span.start, span.end);\n            try {\n                const parsedResult = parseWhole(fullMatch, parser, warnLabel);\n                if (!parsedResult) {\n                    cursor = span.end;\n                    continue;\n                }\n                // Create AST segments\n                const segments = createSegments(value, span.start, span.end, parsedResult, 'custom-variable');\n                parent.children.splice(index, 1, ...segments);\n                return;\n            }\n            catch (error) {\n                console.warn(`Failed to parse ${warnLabel} syntax:`, error);\n                // Keep original if parsing fails\n                return;\n            }\n        }\n    });\n}\n//# sourceMappingURL=interaction-plugin-core.js.map"],"names":["interactionPluginCore","transformInteractionsInTree","unist_util_visit_1","require$$0","interaction_parser_1","require$$1","escaping_1","require$$2","interaction_syntax_1","require$$3","variable_name_1","require$$4","createSegments","value","startIndex","endIndex","parsedResult","hName","parseWhole","parser","warnLabel","span","innerContent","error","tree","rootData","node","index","parent","parsed","cursor","marker","fullMatch","segments"],"mappings":"mXACA,OAAO,eAAeA,EAAAA,UAAS,aAAc,CAAE,MAAO,GAAM,EAC5DA,EAAAA,UAAA,4BAAsCC,EACtC,MAAMC,EAAqBC,EAAAA,QACrBC,EAAuBC,EAAAA,UAAA,EACvBC,EAAaC,EAAAA,UAAA,EACbC,EAAuBC,EAAAA,UAAA,EACvBC,EAAkBC,EAAAA,UAAA,EAIxB,SAASC,EAAeC,EAAOC,EAAYC,EAAUC,EAAcC,EAAO,CACtE,MAAO,CACH,CACI,KAAM,OACN,MAAOJ,EAAM,UAAU,EAAGC,CAAU,GAExC,CACI,KAAM,UACN,KAAM,CACF,MAAAG,EACA,YAAaD,IAGrB,CACI,KAAM,OACN,MAAOH,EAAM,UAAUE,CAAQ,GAG3C,CAOA,SAASG,EAAWL,EAAOM,EAAQC,EAAW,CAC1C,MAAMC,KAAWf,EAAW,iBAAiBO,CAAK,EAClD,GAAI,CAACQ,GAAM,UAAYA,EAAK,MAAQR,EAAM,OACtC,OAAO,KACX,MAAMS,KAAmBZ,EAAgB,qBAAqBW,EAAK,OAAO,EAC1E,GAAIC,EAAa,WAAW,IAAI,GAAK,CAACA,EAAa,WAAW,KAAK,EAC/D,OAAO,KAEX,GAAI,CACA,OAAIH,EAAO,MAAMN,CAAK,EAAE,MACb,KACJM,EAAO,oBAAoBN,CAAK,CAC/C,OACWU,EAAO,CACV,eAAQ,KAAK,mBAAmBH,CAAS,WAAYG,CAAK,EACnD,IACf,CACA,CAiBA,SAAStB,EAA4BuB,EAAMJ,EAAW,CAClD,MAAMK,EAAWD,EAAK,KAChBL,EAAS,IAAIf,EAAqB,kBACxC,GAAIqB,IAAWjB,EAAqB,cAAc,IAAM,GAAM,IACtDN,EAAmB,OAAOsB,EAAMhB,EAAqB,cAAe,CAACkB,EAAMC,EAAOC,IAAW,CACzFD,IAAU,MAAQC,IAAW,MAEjCA,EAAO,SAAS,OAAOD,EAAO,EAAG,CAC7B,KAAM,OACN,MAAOD,EAAK,KAC5B,CAAa,CACb,CAAS,KACGxB,EAAmB,OAAOsB,EAAMhB,EAAqB,iBAAkB,CAACkB,EAAMC,EAAOC,IAAW,CAChG,GAAID,IAAU,MAAQC,IAAW,KAC7B,OAEJ,MAAMf,EAAQa,EAAK,MACbG,EAASX,EAAWL,EAAOM,EAAQC,CAAS,EAClDQ,EAAO,SAAS,OAAOD,EAAO,EAAGE,EAC3B,CACE,KAAM,UACN,KAAM,CAAE,MAAO,kBAAmB,YAAaA,CAAM,CACzE,EACkB,CAAE,KAAM,OAAQ,MAAAhB,EAAO,CACzC,CAAS,EACD,MACR,IACQX,EAAmB,OAAOsB,EAAM,OAAQ,CAACE,EAAMC,EAAOC,IAAW,CAEjE,GAAID,IAAU,MAAQC,IAAW,KAC7B,OACJ,MAAMf,EAAQa,EAAK,MACnB,IAAII,EAAS,EACb,KAAOA,EAASjB,EAAM,QAAQ,CAC1B,GAAIA,EAAM,WAAW,KAAMiB,CAAM,EAAG,CAChC,MAAMC,KAAarB,EAAgB,oBAAoBG,EAAOiB,CAAM,EACpE,GAAI,CAACC,EACD,OACJD,EAASC,EAAO,IAChB,QAChB,CACY,GAAI,CAAClB,EAAM,WAAW,KAAMiB,CAAM,EAAG,CACjCA,GAAU,EACV,QAChB,CACY,MAAMT,KAAWf,EAAW,iBAAiBO,EAAOiB,CAAM,EAC1D,GAAI,CAACT,EAAM,CACPS,GAAU,EACV,QAChB,CACY,GAAI,CAACT,EAAK,SACN,OACJ,MAAMW,EAAYnB,EAAM,MAAMQ,EAAK,MAAOA,EAAK,GAAG,EAClD,GAAI,CACA,MAAML,EAAeE,EAAWc,EAAWb,EAAQC,CAAS,EAC5D,GAAI,CAACJ,EAAc,CACfc,EAAST,EAAK,IACd,QACpB,CAEgB,MAAMY,EAAWrB,EAAeC,EAAOQ,EAAK,MAAOA,EAAK,IAAKL,EAAc,iBAAiB,EAC5FY,EAAO,SAAS,OAAOD,EAAO,EAAG,GAAGM,CAAQ,EAC5C,MAChB,OACmBV,EAAO,CACV,QAAQ,KAAK,mBAAmBH,CAAS,WAAYG,CAAK,EAE1D,MAChB,CACA,CACA,CAAK,CACL","x_google_ignoreList":[0]}

package/dist/node_modules/remark-flow/dist/interaction-plugin-core.es.js

@@ -1,80 +1,109 @@
-import { __exports as l } from "../../../_virtual/interaction-plugin-core.es.js";
-import C from "../../../_virtual/index.es3.js";
-import { __require as v } from "./interaction-parser.es.js";
-import { __require as q } from "./escaping.es.js";
-import { __require as O } from "./interaction-syntax.es.js";
-var x;
-function S() {
-  if (x) return l;
-  x = 1, Object.defineProperty(l, "__esModule", { value: !0 }), l.transformInteractionsInTree = R;
-  const _ = C, T = v(), m = q(), f = O();
-  function E(e, i, o, r, t) {
+import { __exports as p } from "../../../_virtual/interaction-plugin-core.es.js";
+import P from "../../../_virtual/index.es4.js";
+import { __require as x } from "./interaction-parser.es.js";
+import { __require as b } from "./escaping.es.js";
+import { __require as N } from "./interaction-syntax.es.js";
+import { __require as T } from "./variable-name.es.js";
+var I;
+function $() {
+  if (I) return p;
+  I = 1, Object.defineProperty(p, "__esModule", { value: !0 }), p.transformInteractionsInTree = g;
+  const m = P, v = x(), _ = b(), f = N(), d = T();
+  function y(e, a, l, o, r) {
     return [
       {
         type: "text",
-        value: e.substring(0, i)
+        value: e.substring(0, a)
       },
       {
         type: "element",
         data: {
-          hName: t,
-          hProperties: r
+          hName: r,
+          hProperties: o
         }
       },
       {
         type: "text",
-        value: e.substring(o)
+        value: e.substring(l)
       }
     ];
   }
-  function g(e, i, o) {
-    const r = new RegExp(`^\\?\\[(${m.INTERACTION_CONTENT_SOURCE})\\]$`).exec(e);
-    if (!r)
+  function h(e, a, l) {
+    const o = (0, _.readInteraction)(e);
+    if (!o?.complete || o.end !== e.length)
       return null;
-    const t = r[1];
-    if (t.includes("%{") && (!t.includes("%{{") || t.includes("%{{}}")))
+    const r = (0, d.trimVariablePadding)(o.content);
+    if (r.startsWith("%{") && !r.startsWith("%{{"))
       return null;
     try {
-      return i.parseToRemarkFormat(e);
+      return a.parse(e).error ? null : a.parseToRemarkFormat(e);
     } catch (n) {
-      return console.warn(`Failed to parse ${o} syntax:`, n), null;
+      return console.warn(`Failed to parse ${l} syntax:`, n), null;
     }
   }
-  function R(e, i) {
-    const o = e.data, r = new T.InteractionParser();
-    if (o?.[f.TOKENIZED_TREE] === !0) {
-      (0, _.visit)(e, f.INTERACTION_NODE, (t, n, s) => {
+  function g(e, a) {
+    const l = e.data, o = new v.InteractionParser();
+    if (l?.[f.TOKENIZED_TREE] === !0) {
+      (0, m.visit)(e, f.VARIABLE_NODE, (r, n, s) => {
+        n === null || s === null || s.children.splice(n, 1, {
+          type: "text",
+          value: r.value
+        });
+      }), (0, m.visit)(e, f.INTERACTION_NODE, (r, n, s) => {
         if (n === null || s === null)
           return;
-        const a = t.value, p = g(a, r, i);
-        s.children.splice(n, 1, p ? {
+        const i = r.value, t = h(i, o, a);
+        s.children.splice(n, 1, t ? {
           type: "element",
-          data: { hName: "custom-variable", hProperties: p }
-        } : { type: "text", value: a });
+          data: { hName: "custom-variable", hProperties: t }
+        } : { type: "text", value: i });
       });
       return;
     }
-    (0, _.visit)(e, "text", (t, n, s) => {
+    (0, m.visit)(e, "text", (r, n, s) => {
       if (n === null || s === null)
         return;
-      const a = t.value, u = new RegExp(`\\?\\[(${m.INTERACTION_CONTENT_SOURCE})\\](?!\\()`).exec(a);
-      if (u) {
-        const d = u[0], I = u.index, h = I + d.length;
-        try {
-          const c = u[1];
-          if (c.includes("%{") && (!c.includes("%{{") || c.includes("%{{}}")))
+      const i = r.value;
+      let t = 0;
+      for (; t < i.length; ) {
+        if (i.startsWith("{{", t)) {
+          const c = (0, d.readVariableMarker)(i, t);
+          if (!c)
             return;
-          const N = r.parseToRemarkFormat(d), y = E(a, I, h, N, "custom-variable");
-          s.children.splice(n, 1, ...y);
+          t = c.end;
+          continue;
+        }
+        if (!i.startsWith("?[", t)) {
+          t += 1;
+          continue;
+        }
+        const u = (0, _.readInteraction)(i, t);
+        if (!u) {
+          t += 2;
+          continue;
+        }
+        if (!u.complete)
+          return;
+        const q = i.slice(u.start, u.end);
+        try {
+          const c = h(q, o, a);
+          if (!c) {
+            t = u.end;
+            continue;
+          }
+          const E = y(i, u.start, u.end, c, "custom-variable");
+          s.children.splice(n, 1, ...E);
+          return;
         } catch (c) {
-          console.warn(`Failed to parse ${i} syntax:`, c);
+          console.warn(`Failed to parse ${a} syntax:`, c);
+          return;
         }
       }
     });
   }
-  return l;
+  return p;
 }
 export {
-  S as __require
+  $ as __require
 };
 //# sourceMappingURL=interaction-plugin-core.es.js.map

package/dist/node_modules/remark-flow/dist/interaction-plugin-core.es.js.map

@@ -1 +1 @@
-{"version":3,"file":"interaction-plugin-core.es.js","sources":["../../../../node_modules/remark-flow/dist/interaction-plugin-core.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.transformInteractionsInTree = transformInteractionsInTree;\nconst unist_util_visit_1 = require(\"unist-util-visit\");\nconst interaction_parser_1 = require(\"./interaction-parser\");\nconst escaping_1 = require(\"./escaping\");\nconst interaction_syntax_1 = require(\"./interaction-syntax\");\n/**\n * Create AST node segments\n */\nfunction createSegments(value, startIndex, endIndex, parsedResult, hName) {\n    return [\n        {\n            type: 'text',\n            value: value.substring(0, startIndex),\n        },\n        {\n            type: 'element',\n            data: {\n                hName,\n                hProperties: parsedResult,\n            },\n        },\n        {\n            type: 'text',\n            value: value.substring(endIndex),\n        },\n    ];\n}\n/**\n * Parse `value` as one whole interaction, or return null if it should stay text.\n *\n * Invalid variable syntax is kept as text rather than misparsed: `%{variable}` with one brace,\n * or `%{{}}` with no name, would otherwise become display buttons.\n */\nfunction parseWhole(value, parser, warnLabel) {\n    const whole = new RegExp(`^\\\\?\\\\[(${escaping_1.INTERACTION_CONTENT_SOURCE})\\\\]$`).exec(value);\n    if (!whole)\n        return null;\n    const innerContent = whole[1];\n    if (innerContent.includes('%{') &&\n        (!innerContent.includes('%{{') || innerContent.includes('%{{}}'))) {\n        return null;\n    }\n    try {\n        return parser.parseToRemarkFormat(value);\n    }\n    catch (error) {\n        console.warn(`Failed to parse ${warnLabel} syntax:`, error);\n        return null;\n    }\n}\n/**\n * Shared visitor body for the remark plugins: find `?[...]` interaction\n * syntax and replace it with a `custom-variable` element.\n * remark-interaction and remark-custom-variable are thin wrappers around\n * this (they only differ in the warning label used on parse failures).\n *\n * @param tree - The AST to transform in place\n * @param warnLabel - Label used in the console warning on parse failures\n *\n * A tree parsed with the interaction tokenizer is marked so at its root, and its interactions\n * are the tokenizer's own nodes, which nothing else rewrites: each becomes an element, or text\n * if it does not parse. Text nodes are not read in such a tree -- any `?[` in one is something\n * Markdown has already rewritten, `\\?[` with its escape consumed, and reading it as a question\n * would turn text the author escaped into buttons. A tree without the mark (parsed by another\n * processor, or built by hand) is read from its text nodes, as it always was.\n */\nfunction transformInteractionsInTree(tree, warnLabel) {\n    const rootData = tree.data;\n    const parser = new interaction_parser_1.InteractionParser();\n    if (rootData?.[interaction_syntax_1.TOKENIZED_TREE] === true) {\n        (0, unist_util_visit_1.visit)(tree, interaction_syntax_1.INTERACTION_NODE, (node, index, parent) => {\n            if (index === null || parent === null)\n                return;\n            const value = node.value;\n            const parsed = parseWhole(value, parser, warnLabel);\n            parent.children.splice(index, 1, parsed\n                ? {\n                    type: 'element',\n                    data: { hName: 'custom-variable', hProperties: parsed },\n                }\n                : { type: 'text', value });\n        });\n        return;\n    }\n    (0, unist_util_visit_1.visit)(tree, 'text', (node, index, parent) => {\n        // Input validation\n        if (index === null || parent === null)\n            return;\n        const value = node.value;\n        // Check if contains interaction syntax\n        const interactionRegex = new RegExp(`\\\\?\\\\[(${escaping_1.INTERACTION_CONTENT_SOURCE})\\\\](?!\\\\()`);\n        const match = interactionRegex.exec(value);\n        if (match) {\n            const fullMatch = match[0];\n            const startIndex = match.index;\n            const endIndex = startIndex + fullMatch.length;\n            try {\n                // Check for invalid variable syntax: keep the original text\n                // instead of misparsing %{variable} / %{{}} as display buttons.\n                const innerContent = match[1];\n                if (innerContent.includes('%{')) {\n                    if (!innerContent.includes('%{{')) {\n                        // Contains invalid variable syntax %{variable} instead of %{{variable}}\n                        return;\n                    }\n                    // Check for empty variable name %{{}}\n                    if (innerContent.includes('%{{}}')) {\n                        return;\n                    }\n                }\n                const parsedResult = parser.parseToRemarkFormat(fullMatch);\n                // Create AST segments\n                const segments = createSegments(value, startIndex, endIndex, parsedResult, 'custom-variable');\n                parent.children.splice(index, 1, ...segments);\n            }\n            catch (error) {\n                console.warn(`Failed to parse ${warnLabel} syntax:`, error);\n                // Keep original if parsing fails\n            }\n        }\n    });\n}\n//# sourceMappingURL=interaction-plugin-core.js.map"],"names":["interactionPluginCore","transformInteractionsInTree","unist_util_visit_1","require$$0","interaction_parser_1","require$$1","escaping_1","require$$2","interaction_syntax_1","require$$3","createSegments","value","startIndex","endIndex","parsedResult","hName","parseWhole","parser","warnLabel","whole","innerContent","error","tree","rootData","node","index","parent","parsed","match","fullMatch","segments"],"mappings":";;;;;;;;SACA,OAAO,eAAeA,GAAS,cAAc,EAAE,OAAO,IAAM,GAC5DA,EAAA,8BAAsCC;AACtC,QAAMC,IAAqBC,GACrBC,IAAuBC,EAAA,GACvBC,IAAaC,EAAA,GACbC,IAAuBC,EAAA;AAI7B,WAASC,EAAeC,GAAOC,GAAYC,GAAUC,GAAcC,GAAO;AACtE,WAAO;AAAA,MACH;AAAA,QACI,MAAM;AAAA,QACN,OAAOJ,EAAM,UAAU,GAAGC,CAAU;AAAA;MAExC;AAAA,QACI,MAAM;AAAA,QACN,MAAM;AAAA,UACF,OAAAG;AAAA,UACA,aAAaD;AAAA;;MAGrB;AAAA,QACI,MAAM;AAAA,QACN,OAAOH,EAAM,UAAUE,CAAQ;AAAA;;EAG3C;AAOA,WAASG,EAAWL,GAAOM,GAAQC,GAAW;AAC1C,UAAMC,IAAQ,IAAI,OAAO,WAAWb,EAAW,0BAA0B,OAAO,EAAE,KAAKK,CAAK;AAC5F,QAAI,CAACQ;AACD,aAAO;AACX,UAAMC,IAAeD,EAAM,CAAC;AAC5B,QAAIC,EAAa,SAAS,IAAI,MACzB,CAACA,EAAa,SAAS,KAAK,KAAKA,EAAa,SAAS,OAAO;AAC/D,aAAO;AAEX,QAAI;AACA,aAAOH,EAAO,oBAAoBN,CAAK;AAAA,IAC/C,SACWU,GAAO;AACV,qBAAQ,KAAK,mBAAmBH,CAAS,YAAYG,CAAK,GACnD;AAAA,IACf;AAAA,EACA;AAiBA,WAASpB,EAA4BqB,GAAMJ,GAAW;AAClD,UAAMK,IAAWD,EAAK,MAChBL,IAAS,IAAIb,EAAqB,kBAAiB;AACzD,QAAImB,IAAWf,EAAqB,cAAc,MAAM,IAAM;AAC1D,UAAIN,EAAmB,OAAOoB,GAAMd,EAAqB,kBAAkB,CAACgB,GAAMC,GAAOC,MAAW;AAChG,YAAID,MAAU,QAAQC,MAAW;AAC7B;AACJ,cAAMf,IAAQa,EAAK,OACbG,IAASX,EAAWL,GAAOM,GAAQC,CAAS;AAClD,QAAAQ,EAAO,SAAS,OAAOD,GAAO,GAAGE,IAC3B;AAAA,UACE,MAAM;AAAA,UACN,MAAM,EAAE,OAAO,mBAAmB,aAAaA,EAAM;AAAA,QACzE,IACkB,EAAE,MAAM,QAAQ,OAAAhB,GAAO;AAAA,MACzC,CAAS;AACD;AAAA,IACR;AACI,QAAIT,EAAmB,OAAOoB,GAAM,QAAQ,CAACE,GAAMC,GAAOC,MAAW;AAEjE,UAAID,MAAU,QAAQC,MAAW;AAC7B;AACJ,YAAMf,IAAQa,EAAK,OAGbI,IADmB,IAAI,OAAO,UAAUtB,EAAW,0BAA0B,aAAa,EACjE,KAAKK,CAAK;AACzC,UAAIiB,GAAO;AACP,cAAMC,IAAYD,EAAM,CAAC,GACnBhB,IAAagB,EAAM,OACnBf,IAAWD,IAAaiB,EAAU;AACxC,YAAI;AAGA,gBAAMT,IAAeQ,EAAM,CAAC;AAC5B,cAAIR,EAAa,SAAS,IAAI,MACtB,CAACA,EAAa,SAAS,KAAK,KAK5BA,EAAa,SAAS,OAAO;AAC7B;AAGR,gBAAMN,IAAeG,EAAO,oBAAoBY,CAAS,GAEnDC,IAAWpB,EAAeC,GAAOC,GAAYC,GAAUC,GAAc,iBAAiB;AAC5F,UAAAY,EAAO,SAAS,OAAOD,GAAO,GAAG,GAAGK,CAAQ;AAAA,QAC5D,SACmBT,GAAO;AACV,kBAAQ,KAAK,mBAAmBH,CAAS,YAAYG,CAAK;AAAA,QAE1E;AAAA,MACA;AAAA,IACA,CAAK;AAAA,EACL;;;","x_google_ignoreList":[0]}
+{"version":3,"file":"interaction-plugin-core.es.js","sources":["../../../../node_modules/remark-flow/dist/interaction-plugin-core.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.transformInteractionsInTree = transformInteractionsInTree;\nconst unist_util_visit_1 = require(\"unist-util-visit\");\nconst interaction_parser_1 = require(\"./interaction-parser\");\nconst escaping_1 = require(\"./escaping\");\nconst interaction_syntax_1 = require(\"./interaction-syntax\");\nconst variable_name_1 = require(\"./variable-name\");\n/**\n * Create AST node segments\n */\nfunction createSegments(value, startIndex, endIndex, parsedResult, hName) {\n    return [\n        {\n            type: 'text',\n            value: value.substring(0, startIndex),\n        },\n        {\n            type: 'element',\n            data: {\n                hName,\n                hProperties: parsedResult,\n            },\n        },\n        {\n            type: 'text',\n            value: value.substring(endIndex),\n        },\n    ];\n}\n/**\n * Parse `value` as one whole interaction, or return null if it should stay text.\n *\n * A leading assignment is validated after reading its whole body. Marker-looking text inside\n * an opaque name or an option does not change whether the interaction is valid.\n */\nfunction parseWhole(value, parser, warnLabel) {\n    const span = (0, escaping_1.readInteraction)(value);\n    if (!span?.complete || span.end !== value.length)\n        return null;\n    const innerContent = (0, variable_name_1.trimVariablePadding)(span.content);\n    if (innerContent.startsWith('%{') && !innerContent.startsWith('%{{')) {\n        return null;\n    }\n    try {\n        if (parser.parse(value).error)\n            return null;\n        return parser.parseToRemarkFormat(value);\n    }\n    catch (error) {\n        console.warn(`Failed to parse ${warnLabel} syntax:`, error);\n        return null;\n    }\n}\n/**\n * Shared visitor body for the remark plugins: find `?[...]` interaction\n * syntax and replace it with a `custom-variable` element.\n * remark-interaction and remark-custom-variable are thin wrappers around\n * this (they only differ in the warning label used on parse failures).\n *\n * @param tree - The AST to transform in place\n * @param warnLabel - Label used in the console warning on parse failures\n *\n * A tree parsed with the interaction tokenizer is marked so at its root, and its interactions\n * are the tokenizer's own nodes, which nothing else rewrites: each becomes an element, or text\n * if it does not parse. Text nodes are not read in such a tree -- any `?[` in one is something\n * Markdown has already rewritten, `\\?[` with its escape consumed, and reading it as a question\n * would turn text the author escaped into buttons. A tree without the mark (parsed by another\n * processor, or built by hand) is read from its text nodes, as it always was.\n */\nfunction transformInteractionsInTree(tree, warnLabel) {\n    const rootData = tree.data;\n    const parser = new interaction_parser_1.InteractionParser();\n    if (rootData?.[interaction_syntax_1.TOKENIZED_TREE] === true) {\n        (0, unist_util_visit_1.visit)(tree, interaction_syntax_1.VARIABLE_NODE, (node, index, parent) => {\n            if (index === null || parent === null)\n                return;\n            parent.children.splice(index, 1, {\n                type: 'text',\n                value: node.value,\n            });\n        });\n        (0, unist_util_visit_1.visit)(tree, interaction_syntax_1.INTERACTION_NODE, (node, index, parent) => {\n            if (index === null || parent === null)\n                return;\n            // The tokenizer retains raw NUL provenance without reintroducing container prefixes.\n            const value = node.value;\n            const parsed = parseWhole(value, parser, warnLabel);\n            parent.children.splice(index, 1, parsed\n                ? {\n                    type: 'element',\n                    data: { hName: 'custom-variable', hProperties: parsed },\n                }\n                : { type: 'text', value });\n        });\n        return;\n    }\n    (0, unist_util_visit_1.visit)(tree, 'text', (node, index, parent) => {\n        // Input validation\n        if (index === null || parent === null)\n            return;\n        const value = node.value;\n        let cursor = 0;\n        while (cursor < value.length) {\n            if (value.startsWith('{{', cursor)) {\n                const marker = (0, variable_name_1.readVariableMarker)(value, cursor);\n                if (!marker)\n                    return;\n                cursor = marker.end;\n                continue;\n            }\n            if (!value.startsWith('?[', cursor)) {\n                cursor += 1;\n                continue;\n            }\n            const span = (0, escaping_1.readInteraction)(value, cursor);\n            if (!span) {\n                cursor += 2;\n                continue;\n            }\n            if (!span.complete)\n                return;\n            const fullMatch = value.slice(span.start, span.end);\n            try {\n                const parsedResult = parseWhole(fullMatch, parser, warnLabel);\n                if (!parsedResult) {\n                    cursor = span.end;\n                    continue;\n                }\n                // Create AST segments\n                const segments = createSegments(value, span.start, span.end, parsedResult, 'custom-variable');\n                parent.children.splice(index, 1, ...segments);\n                return;\n            }\n            catch (error) {\n                console.warn(`Failed to parse ${warnLabel} syntax:`, error);\n                // Keep original if parsing fails\n                return;\n            }\n        }\n    });\n}\n//# sourceMappingURL=interaction-plugin-core.js.map"],"names":["interactionPluginCore","transformInteractionsInTree","unist_util_visit_1","require$$0","interaction_parser_1","require$$1","escaping_1","require$$2","interaction_syntax_1","require$$3","variable_name_1","require$$4","createSegments","value","startIndex","endIndex","parsedResult","hName","parseWhole","parser","warnLabel","span","innerContent","error","tree","rootData","node","index","parent","parsed","cursor","marker","fullMatch","segments"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/remark-flow/dist/interaction-syntax.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const I=require("../../../_virtual/interaction-syntax.cjs");var m;function b(){return m||(m=1,(function(r){Object.defineProperty(r,"__esModule",{value:!0}),r.TOKENIZED_TREE=r.INTERACTION_NODE=void 0,r.interactionSyntax=A,r.interactionFromMarkdown=R,r.registerInteractionSyntax=M,r.INTERACTION_NODE="flowInteraction",r.TOKENIZED_TREE="flowInteractionTokenized";const y=63,x=91,T=93,D=40,f=92,h=new Set([124,47,46,93]),u="flowInteraction",a="flowInteractionMarker",l="flowInteractionData",_="lineEnding",N=n=>n!==null&&n<-2;function w(n,e,i){return E;function E(t){return n.enter(u),n.enter(a),n.consume(t),s}function s(t){return t!==x?i(t):(n.consume(t),n.exit(a),o)}function o(t){return t===null?i(t):t===T?O(t):N(t)?S(t):(n.enter(l),c(t))}function S(t){return n.enter(_),n.consume(t),n.exit(_),o}function c(t){return t===null?i(t):t===T?(n.exit(l),O(t)):N(t)?(n.exit(l),S(t)):(n.consume(t),t===f?k:c)}function k(t){return t!==null&&h.has(t)?(n.consume(t),c):c(t)}function O(t){return n.enter(a),n.consume(t),n.exit(a),L}function L(t){return t===D?i(t):(n.exit(u),e(t))}}function A(){return{text:{[y]:{name:"flowInteraction",tokenize:w}}}}function R(){return{transforms:[n=>{n.data={...n.data,[r.TOKENIZED_TREE]:!0}}],enter:{[u](n){this.enter({type:r.INTERACTION_NODE,value:""},n)}},exit:{[u](n){const e=this.stack[this.stack.length-1];e.value=this.sliceSerialize(n),this.exit(n)}}}}const C=n=>(typeof n=="object"||typeof n=="function")&&n!==null&&typeof n.data=="function";function M(n){if(!C(n))return;const e=n.data(),i=(E,s)=>{const o=e[E]??[];o.includes(s)||o.push(s),e[E]=o};i("micromarkExtensions",K),i("fromMarkdownExtensions",g)}const K=A(),g=R()})(I.__exports)),I.__exports}exports.__require=b;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const bn=require("../../../_virtual/interaction-syntax.cjs"),Ft=require("./variable-name.cjs");var tt;function Gt(){return tt||(tt=1,(function(A){Object.defineProperty(A,"__esModule",{value:!0}),A.TOKENIZED_TREE=A.OPAQUE_PARAGRAPH=A.VARIABLE_NODE=A.INTERACTION_NODE=void 0,A.interactionSyntax=Mn,A.interactionFromMarkdown=jn,A.registerInteractionSyntax=Ot;const Nn=Ft.__require();A.INTERACTION_NODE="flowInteraction",A.VARIABLE_NODE="flowVariableMarker",A.OPAQUE_PARAGRAPH="flowOpaqueParagraph";const Y="flowOpaqueHeading";A.TOKENIZED_TREE="flowInteractionTokenized";const vn=63,V=91,W=93,rt=40,sn=60,Ln=92,B=96,on=35,M=36,et=33,it=32,ut=6,j=123,H=125,yn=new Set([124,47,46,93]),J="flowInteraction",Q="flowVariableMarker",v="flowInteractionMarker",x="flowInteractionData",q="lineEnding",at=65533,lt=-3,fn=-2,cn=-1,pn=new WeakMap,zn=new WeakMap,$=[],st=new Uint32Array;function hn(t,r){let i=zn.get(t);i===void 0&&(i=$[$.length-1]??st,zn.set(t,i));let a=0,l=i.length;for(;a<l;){const u=a+l>>>1;i[u]<r?a=u+1:l=u}return i[a]===r}function ot(t){return this.parser.constructs.text[B]?.find(i=>i.name==="codeText")?.previous?.call(this,t)??!0}function ft(t){return this.parser.constructs.text[M]?.find(i=>i.name==="mathText")?.previous?.call(this,t)??!0}function Pn(t,r,i){if(!hn(this.parser,this.now().offset)&&!pn.get(this.parser)?.has(this.now().offset))return i;let a;return l;function l(f){return a=f,t.enter("data"),u(f)}function u(f){return f===a?(t.consume(f),u):(t.exit("data"),r(f))}}function Dn(t,r){const i=[];let a=0,l=!1;for(const u of t.sliceStream(r))u===cn&&l||(u===at&&i.push(a),a+=typeof u=="string"?u.length:u===lt?2:1,l=u===fn);i.length&&(r.flowNullOffsets=i)}function Bn(t,r){const i=t.sliceSerialize(r);if(!r.flowNullOffsets)return i;const a=[];let l=0;for(const u of r.flowNullOffsets)a.push(i.slice(l,u),"\0"),l=u+1;return a.push(i.slice(l)),a.join("")}const T=t=>t!==null&&t<-2;function ct(t,r,i){const a=()=>Dn(this,t.exit(J));return l;function l(e){return t.enter(J),t.enter(v),t.consume(e),u}function u(e){return e!==V?i(e):(t.consume(e),t.exit(v),f)}function f(e){return e===null?i(e):e===W?P(e):T(e)?k(e):(t.enter(x),b(e))}function O(e){return e!==j?b(e):(t.consume(e),S)}function S(e){return e===null?(t.exit(x),a(),r(e)):T(e)?(t.exit(x),L(e)):(t.consume(e),e===H?s:S)}function s(e){return e!==H?S(e):(t.consume(e),b)}function L(e){return t.enter(q),t.consume(e),t.exit(q),d}function d(e){return e===null?(a(),r(e)):T(e)?L(e):(t.enter(x),S(e))}function k(e){return t.enter(q),t.consume(e),t.exit(q),f}function b(e){return e===null?i(e):e===W?(t.exit(x),P(e)):T(e)?(t.exit(x),k(e)):(t.consume(e),e===j?O:e===Ln?nn:b)}function nn(e){return e!==null&&yn.has(e)?(t.consume(e),b):b(e)}function P(e){return t.enter(v),t.consume(e),t.exit(v),F}function F(e){return e===rt?i(e):(a(),r(e))}}function pt(t,r,i){const a=()=>Dn(this,t.exit(Q));return l;function l(s){return t.enter(Q),t.consume(s),u}function u(s){return s!==j?i(s):(t.consume(s),f)}function f(s){return s===null?(a(),r(s)):T(s)?(t.enter(q),t.consume(s),t.exit(q),f):(t.enter(x),O(s))}function O(s){return s===null||T(s)?(t.exit(x),f(s)):(t.consume(s),s===H?S:O)}function S(s){return s!==H?O(s):(t.consume(s),t.exit(x),a(),r)}}function ht(t,r,i){const a=mn(this,t,r,i,!1),l=this.parser.constructs.contentInitial?.[V]?.find(u=>u.name==="definition");return!l||this.interrupt?a:u=>u===V?t.check({partial:!0,tokenize(f,O,S){const s=Object.create(this,{parser:{value:Object.create(this.parser,{defined:{value:[]}})}});return l.tokenize.call(s,f,O,S)}},i,a)(u):a(u)}function mt(t,r,i){return mn(this,t,r,i,!0)}function mn(t,r,i,a,l,u=!1){let f=!1,O=!1,S=!1,s=!1,L=!1,d=0,k=0,b=0,nn=0,P=!1,F=0,e=0,En=!1,G=null,gn=null;const On=[],tn=new Set,rn=new Set;let X,Gn;const kn=l?Y:"content",An=t.parser.constructs.text[sn]?.find(n=>n.name==="htmlText"),Tn=t.parser.constructs.text[sn]?.find(n=>n.name==="autolink"),In=t.parser.constructs.text[M]?.find(n=>n.name==="mathText"),_n=t.parser.constructs.text[W]?.find(n=>n.name==="labelEnd");let D;const Un={partial:!0,tokenize:nt},At={partial:!0,tokenize:jt},Tt={partial:!0,tokenize:Ht},It={...t.currentConstruct,concrete:!0},Vn={...t.currentConstruct,concrete:!1},_t=Object.fromEntries(Object.entries(t.parser.constructs.flow).map(([n,p])=>[n,p.map(o=>({...o,partial:!0}))]));return wt;function wt(n){return t.interrupt?a(n):(u||(t.currentConstruct=Vn),Gn=r.enter(kn),l?(r.enter(v),Wn(n)):(r.enter("paragraph"),Zn(n)))}function Wn(n){return n===on?++d>ut?a(n):(r.consume(n),Wn):n!==null&&!T(n)&&!K(n)?a(n):(Gn.flowHeadingDepth=d,Qn(n))}function Qn(n){return K(n)?(r.consume(n),Qn):(r.exit(v),Zn(n))}function Zn(n){return n===null||T(n)?a(n):(X=r.enter("chunkText",{contentType:"text"}),y(n))}function y(n){if(n===null||T(n))return u?!f||n===null?a(n):(r.exit("chunkText"),xn(),i(n)):f&&n!==null?(S=!0,O=!1,r.consume(n),r.exit("chunkText"),Yn):n!==null&&!l?r.check(Un,Mt,dn)(n):dn(n);if(!f){if(!s&&n===B)return hn(t.parser,t.now().offset)?(gn=n,wn(n)):(k=0,b=0,nn=t.now().offset,P=!1,r.check({partial:!0,tokenize:xt},N,yt)(n));if(!s&&n===sn&&(Tn||An))return k=0,r.check({partial:!0,tokenize:Ct},N,bt)(n);if(!s&&n===M&&In)return hn(t.parser,t.now().offset)?(gn=n,wn(n)):(k=0,F=0,e=t.now().offset,En=!1,r.check({partial:!0,tokenize:Nt},N,zt)(n));if(n===W&&On.length&&_n&&(D=On.pop(),D&&tn.delete(D),!D?.inactive))return k=0,r.check({partial:!0,tokenize:vt},Pt,Sn)(n);if(l&&K(n))return k=0,r.check({partial:!0,tokenize:Dt},Bt,N)(n);if(n===Ln)return r.consume(n),O=!1,L=!1,St}return Sn(n)}function wn(n){return n!==gn?y(n):(r.consume(n),G=n,O=!1,L=!1,wn)}function Sn(n){const p=G;if(r.consume(n),G=n,!f&&n===V){const g={type:p===et?"labelImage":"labelLink",end:t.now()};On.push(g),g.type==="labelLink"&&tn.add(g)}const o=f;return f?O&&n===H?(f=!1,O=!1):O=n===H:O&&n===j?(f=!0,O=!1):O=n===j,!u&&o!==f&&(t.currentConstruct=f?It:Vn),f||(L&&n===V&&(s=!0),n===W&&(s=!1),L=n===vn),y}function St(n){return s&&(n===null||!yn.has(n))||n===null||T(n)?y(n):(r.consume(n),G=null,y)}function xt(n,p,o){let g=0,m=0;return R;function E(c){n.consume(c),k++}function R(c){return c===B?(g++,b++,E(c),R):C(c)}function C(c){return c===null?o(c):T(c)?u||l?(P=l,o(c)):n.check(Un,h,Rn)(c):c===B?(m=0,an(c)):(E(c),C)}function h(c){return E(c),C}function Rn(c){return n.check({partial:!0,tokenize:Cn},un,o)(c)}function un(c){return P=!0,o(c)}function Cn(c,ln,_){let w="";return z;function z(I){return c.consume(I),U}function U(I){return I===null||T(I)?(0,Nn.isInlineCodeBoundaryLine)(w)?ln(I):_(I):(w+=I===fn?"	":I===cn?" ":String.fromCodePoint(I),c.consume(I),U)}}function an(c){return c===B?(m++,E(c),an):m===g?p(c):C(c)}}function Rt(n,p,o){return An?en.call(this,An,"htmlText",n,p,o):o}function Ct(n,p,o){return Tn?en.call(this,Tn,"autolink",n,p,o):o}function bt(n){return k=0,r.check({partial:!0,tokenize:Rt},N,Sn)(n)}function Nt(n,p,o){if(!In)return o;let g=!0,m=0;const E=Object.create(this,{previous:{value:null}});return en.call(E,In,"mathText",{...n,consume(R){g&&R===M?F++:g=!1,m=R===M?m+1:0,n.consume(R)}},p,o,()=>m===F,()=>{En=!0})}function vt(n,p,o){if(!_n||!D)return o;const g=Object.create(this,{events:{value:[["enter",D]]}});return en.call(g,_n,"resource",n,p,o)}function en(n,p,o,g,m,E=()=>!1,R=()=>{}){let C=!1,h=!1;const Rn=n.tokenize.call(this,un(o),Cn,an);return c(Rn);function un(_){return{..._,consume(w){k++,_.consume(w)},exit(w){const z=_.exit(w);return w===p&&(C=!0),z},attempt(w,z,U){return _.attempt({...w,tokenize(I,qt,Kt){return w.tokenize.call(this,un(I),qt,Kt)}},z,U)}}}function Cn(_){return h=!0,C?g(_):m(_)}function an(_){return h=!0,m(_)}function c(_){return w=>{if(!C&&T(w)&&!E())return u||l?ln(w):o.check(At,z,ln)(w);return z(w);function z(U){const I=_(U);return I&&!h?c(I):I}}}function ln(_){return R(),m(_)}}function N(n){return k?(r.consume(n),G=n,k--,O=!1,L=!1,T(n)?(r.exit("chunkText"),Lt):N):y(n)}function Lt(n){return Jn(),N(n)}function yt(n){return!u&&P&&rn.add(nn),k=b,N(n)}function zt(n){return!u&&En&&rn.add(e),k=F,N(n)}function Pt(n){if(D?.type==="labelLink"){for(const p of tn)p.inactive=!0;tn.clear()}return s=!1,N(n)}function Dt(n,p,o){let g=!1;return E;function m(h){n.consume(h),k++}function E(h){return K(h)?(m(h),E):R(h)}function R(h){return h===on?(g=!0,m(h),R):g?C(h):o(h)}function C(h){return K(h)?(m(h),C):h===null||T(h)?p(h):o(h)}}function Bt(n){return S?(r.exit("chunkText"),r.enter(v),Xn(n)):a(n)}function Xn(n){return k?(r.consume(n),k--,Xn):(r.exit(v),$n(),r.exit(kn),i(n))}function Yn(n){return n===null?(xn(),i(n)):(Jn(),y(n))}function Jn(){X.next=r.enter("chunkText",{contentType:"text",previous:X}),X=X.next}function xn(){$n(),l||r.exit("paragraph"),r.exit(kn)}function $n(){if(u||!rn.size)return;let n=pn.get(t.parser);n||(n=new Set,pn.set(t.parser,n));for(const p of rn)n.add(p)}function dn(n){return S?(r.exit("chunkText"),xn(),i(n)):a(n)}function Mt(n){return r.consume(n),G=null,r.exit("chunkText"),Yn}function nt(n,p,o){return g;function g(E){return n.consume(E),m}function m(E){return K(E)?(n.consume(E),m):E===null||T(E)?o(E):n.check(Tt,p,n.interrupt(_t,o,p))(E)}}function jt(n,p,o){return m=>(n.enter(x),nt(n,g(p),g(o))(m));function g(m){return E=>(n.exit(x),m(E))}}function Ht(n,p,o){return mn(this,n,p,o,!1,!0)}}const K=t=>t===it||t===fn||t===cn;function Mn(){return{flow:{[on]:{name:Y,concrete:!0,tokenize:mt},null:{name:A.OPAQUE_PARAGRAPH,concrete:!0,tokenize:ht}},text:{[B]:{name:"flowLiteralCodeOpening",previous:ot,tokenize:Pn},[M]:{name:"flowLiteralMathOpening",previous:ft,tokenize:Pn},[vn]:{name:"flowInteraction",tokenize:ct},[j]:{name:Q,tokenize:pt}}}}function jn(){return{transforms:[t=>{t.data={...t.data,[A.TOKENIZED_TREE]:!0}}],enter:{[Y](t){this.enter({type:"heading",depth:t.flowHeadingDepth,children:[]},t)},[Q](t){this.enter({type:A.VARIABLE_NODE,value:""},t)},[J](t){this.enter({type:A.INTERACTION_NODE,value:""},t)}},exit:{[Y](t){this.exit(t)},[Q](t){const r=this.stack[this.stack.length-1];r.value=Bn(this,t),this.exit(t)},[J](t){const r=this.stack[this.stack.length-1];r.value=Bn(this,t),this.exit(t)}}}}const Hn=new WeakSet,qn=new WeakMap,Kn=new WeakSet;function Fn(t){if(typeof t!="function")return t;const r=t;if(Kn.has(r))return r;let i=qn.get(r);return i||(i=function(a,l){const u=a.startsWith("\uFEFF")?a.slice(1):a;$.push((0,Nn.findRejectedDocumentInlineOpenings)(u));try{return r.call(this,a,l)}finally{$.pop()}},qn.set(r,i),Kn.add(i)),i}function Et(t){if(!Hn.has(t)){Hn.add(t);for(const r of["parser","Parser"]){const i=Object.getOwnPropertyDescriptor(t,r);if(i&&!i.configurable){"value"in i&&i.writable&&(t[r]=Fn(t[r]));continue}let a=t[r];const l=!i||!!i.set||"value"in i&&i.writable;Object.defineProperty(t,r,{configurable:i?.configurable??!0,enumerable:i?.enumerable??!0,get(){const u=t.data(),f=u.micromarkExtensions;return f?.includes(Z)&&f[f.length-1]!==Z&&(u.micromarkExtensions=[...f.filter(O=>O!==Z),Z]),Fn(i?.get?i.get.call(this):a)},...l?{set(u){i?.set?i.set.call(this,u):a=u}}:{}})}}}const gt=t=>(typeof t=="object"||typeof t=="function")&&t!==null&&typeof t.data=="function";function Ot(t){if(!gt(t))return;const r=t.data();Et(t);const i=(a,l)=>{const u=r[a]??[];u.includes(l)||u.push(l),r[a]=u};i("micromarkExtensions",Z),i("fromMarkdownExtensions",kt)}const Z=Mn(),kt=jn()})(bn.__exports)),bn.__exports}exports.__require=Gt;
 //# sourceMappingURL=interaction-syntax.cjs.map