{"version":3,"file":"grokkoli/static/js/build/speech.js","mappings":"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","sources":["webpack:///webpack/runtime/chunk loaded","webpack:///./js/src/monitors/keyboardButtonRepeatMonitor.ts","webpack:///./js/src/question/answer/response.ts","webpack:///./js/src/question/createFigure.ts","webpack:///./js/src/question/debug/touchCursor.ts","webpack:///./js/src/question/debug/breakTools.ts","webpack:///./js/src/question/loadQuestion.ts","webpack:///./js/src/question/timer.ts","webpack:///./js/src/question/tools/criticalAnimation.ts","webpack:///./js/src/question/tools/enums.ts","webpack:///./js/src/question/tools/equation.ts","webpack:///./js/src/question/tools/eqn.ts","webpack:///./js/src/question/tools/notifications.ts","webpack:///./js/src/question/tools/sceneZoomFailure.ts","webpack:///./js/src/question/tools/sceneZoomTelemetry.ts","webpack:///./js/src/question/speechErrorDiagnostics.ts","webpack:///./js/src/speech.ts","webpack:///external var \"Fig\"","webpack:///external var \"React\"","webpack:///external var \"ReactDOM\"","webpack:///webpack/bootstrap","webpack:///webpack/runtime/compat get default export","webpack:///webpack/runtime/define property getters","webpack:///webpack/runtime/hasOwnProperty shorthand","webpack:///webpack/runtime/runtimeId","webpack:///webpack/runtime/jsonp chunk loading","webpack:///webpack/startup"],"sourcesContent":["var deferred = [];\n__webpack_require__.O = (result, chunkIds, fn, priority) => {\n\tif(chunkIds) {\n\t\tpriority = priority || 0;\n\t\tfor(var i = deferred.length; i > 0 && deferred[i - 1][2] > priority; i--) deferred[i] = deferred[i - 1];\n\t\tdeferred[i] = [chunkIds, fn, priority];\n\t\treturn;\n\t}\n\tvar notFulfilled = Infinity;\n\tfor (var i = 0; i < deferred.length; i++) {\n\t\tvar [chunkIds, fn, priority] = deferred[i];\n\t\tvar fulfilled = true;\n\t\tfor (var j = 0; j < chunkIds.length; j++) {\n\t\t\tif ((priority & 1 === 0 || notFulfilled >= priority) && Object.keys(__webpack_require__.O).every((key) => (__webpack_require__.O[key](chunkIds[j])))) {\n\t\t\t\tchunkIds.splice(j--, 1);\n\t\t\t} else {\n\t\t\t\tfulfilled = false;\n\t\t\t\tif(priority < notFulfilled) notFulfilled = priority;\n\t\t\t}\n\t\t}\n\t\tif(fulfilled) {\n\t\t\tdeferred.splice(i--, 1)\n\t\t\tvar r = fn();\n\t\t\tif (r !== undefined) result = r;\n\t\t}\n\t}\n\treturn result;\n};","var __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nimport Monitor from './base';\n/**\n * Monitors on-screen keyboard button presses to detect when a user repeatedly\n * presses the same button.\n *\n * This monitor detects repetitive single-button pressing on the on-screen\n * keyboard that may indicate frustration or distraction. It works identically\n * to KeyRepeatMonitor but for the on-screen keyboard buttons instead of\n * physical keyboard keys.\n *\n * How it works:\n * 1. Initialized by keyboard creation code (not at page load) so it only\n *    exists when a keyboard is present\n * 2. Listens for mousedown/touchstart in the capture phase (because the\n *    keyboard's processClick calls stopPropagation in the bubble phase)\n * 3. Walks up the DOM from the event target to find keyboard button containers\n *    and extracts the button label from the element's ID (keyboard_button_{label})\n * 4. Tracks button presses with timestamps in a rolling window\n * 5. Trips if any single button dominates the recent presses\n *\n * For example, with defaults:\n * - After 10 total button presses are recorded, examines the most recent 10\n * - If 9+ of those 10 are the same button (e.g., pressing '3' 9 times) → trips\n * - All presses must occur within 20 seconds to be counted\n *\n * Parameters:\n * - RECENT_PRESS_COUNT (10): Number of most recent presses to examine\n * - MIN_SAME_BUTTON_COUNT (9): Minimum occurrences of same button to trigger\n * - TRACKING_WINDOW (20000ms): Time window for keeping press history\n * - minTripInterval (30000ms): Minimum time between trip reports\n */\nvar KeyboardButtonRepeatMonitor = /** @class */ (function (_super) {\n    __extends(KeyboardButtonRepeatMonitor, _super);\n    function KeyboardButtonRepeatMonitor() {\n        var _this = _super.call(this, 'KeyboardButtonRepeatMonitor', 30000) || this;\n        // Number of recent button presses to examine\n        _this.RECENT_PRESS_COUNT = 10;\n        // Minimum occurrences of the same button to trigger\n        _this.MIN_SAME_BUTTON_COUNT = 9;\n        // Time window (ms) for tracking button presses\n        _this.TRACKING_WINDOW = 20000; // 20 seconds\n        return _this;\n    }\n    /**\n     * Start monitoring on-screen keyboard button presses for repetitive behavior.\n     * @returns Cleanup function to remove the event listeners\n     */\n    KeyboardButtonRepeatMonitor.prototype.start = function () {\n        var _this = this;\n        // State tracking\n        var pressHistory = [];\n        var getButtonLabel = function (target) {\n            if (!(target instanceof HTMLElement)) {\n                return null;\n            }\n            // Walk up the DOM to find the button container with the ID\n            var el = target;\n            while (el) {\n                if (el.id && el.id.startsWith('keyboard_button_')\n                    && (el.classList.contains('keyboard_button_container')\n                        || el.classList.contains('entry_field_keyboard_button_container'))) {\n                    return el.id.replace('keyboard_button_', '');\n                }\n                el = el.parentElement;\n            }\n            return null;\n        };\n        var handlePress = function (event) {\n            var label = getButtonLabel(event.target);\n            if (label === null || label === 'Submit') {\n                return;\n            }\n            var now = Date.now();\n            pressHistory.push({\n                label: label,\n                timestamp: now,\n            });\n            // Remove presses outside the tracking window\n            pressHistory = pressHistory.filter(function (entry) { return now - entry.timestamp <= _this.TRACKING_WINDOW; });\n            // Only check if we have enough presses\n            if (pressHistory.length >= _this.RECENT_PRESS_COUNT) {\n                var recentPresses = pressHistory.slice(-_this.RECENT_PRESS_COUNT);\n                // Count occurrences of each button\n                var buttonCounts = new Map();\n                for (var _i = 0, recentPresses_1 = recentPresses; _i < recentPresses_1.length; _i++) {\n                    var entry = recentPresses_1[_i];\n                    buttonCounts.set(entry.label, (buttonCounts.get(entry.label) || 0) + 1);\n                }\n                // Check if any button appears enough times\n                buttonCounts.forEach(function (count, buttonLabel) {\n                    if (count >= _this.MIN_SAME_BUTTON_COUNT) {\n                        _this.trip({\n                            repeated_button: buttonLabel,\n                            occurrences: count,\n                            total_recent_presses: _this.RECENT_PRESS_COUNT,\n                        });\n                    }\n                });\n            }\n        };\n        // Use capture phase so we receive the event before the keyboard's\n        // processClick handler calls stopPropagation() in the bubble phase.\n        document.addEventListener('mousedown', handlePress, true);\n        document.addEventListener('touchstart', handlePress, true);\n        // Return cleanup function\n        return function () {\n            document.removeEventListener('mousedown', handlePress, true);\n            document.removeEventListener('touchstart', handlePress, true);\n        };\n    };\n    return KeyboardButtonRepeatMonitor;\n}(Monitor));\nexport { KeyboardButtonRepeatMonitor };\n","import { setSpeechToken } from '../../tools/speech_token';\nimport { stampInlineSpeechResponse } from '../../tools/inlineSpeech';\nimport { AnswerResult } from '../tools/enums';\nimport alignElementToElement from '../tools/alignElementToElement';\nimport pulseElement from '../tools/pulse';\nimport { getAnswerInput } from '../tools/getAnswerInput';\nimport { logError } from '../request/request';\n// import { clearCriticalAnimation, criticalAnimation } from '../tools/criticalAnimation';\nimport { startCriticalAnimation } from '../tools/criticalAnimation';\nfunction getElem(elemName) {\n    var element = figure.getElement(elemName);\n    if (element == null) {\n        element = figure.getElement(\"expression.\".concat(elemName));\n    }\n    return element;\n}\nfunction processHint(hintOptions) {\n    var hnt = figure.get('hnt');\n    if (hnt == null) {\n        return;\n    }\n    if (hintOptions != null && hnt != null) {\n        if (hintOptions !== 'hide') {\n            if (hnt.scenarios[hintOptions.form] != null) {\n                hnt.setScenario(hintOptions.form);\n            }\n            else {\n                hnt.setScenario('default');\n            }\n        }\n        if (hintOptions !== 'hide') {\n            hnt._hint.showForm(hintOptions.form);\n            hnt._box.surround(hnt._hint, 0.08);\n            // @ts-expect-error: TS2339\n            hnt._box._line.setPosition(hnt._box._line.getPosition().add(0, 0, 0.001));\n            if (figure.resumeCountdownAfterHint != null) {\n                figure.resumeCountdownAfterHint();\n            }\n            if (hintOptions.element != null) {\n                var element = getElem(hintOptions.element);\n                if (element != null) {\n                    var offset = [0, 0];\n                    if (hintOptions.top != null) {\n                        alignElementToElement(hnt, element, {\n                            xPosition: 'center',\n                            yPosition: 'top',\n                            xAlign: 'center',\n                            yAlign: 'bottom',\n                            offset: hintOptions.top,\n                        });\n                    }\n                    else if (hintOptions.bottom != null) {\n                        alignElementToElement(hnt, element, {\n                            xPosition: 'center',\n                            yPosition: 'bottom',\n                            xAlign: 'center',\n                            yAlign: 'top',\n                            offset: hintOptions.bottom,\n                        });\n                    }\n                    else if (hintOptions.left != null) {\n                        alignElementToElement(hnt, element, {\n                            xPosition: 'left',\n                            yPosition: 'middle',\n                            xAlign: 'right',\n                            yAlign: 'middle',\n                            offset: hintOptions.left,\n                        });\n                    }\n                    else if (hintOptions.right != null) {\n                        alignElementToElement(hnt, element, {\n                            xPosition: 'right',\n                            yPosition: 'middle',\n                            xAlign: 'left',\n                            yAlign: 'middle',\n                            offset: hintOptions.right,\n                        });\n                    }\n                    // hint.setPositionToElement(element);\n                }\n            }\n            hnt.setPosition(hnt.getPosition().add(0, 0, 0.1));\n            if (hintOptions.pulse != null) {\n                pulseElement(hnt, hintOptions.pulse);\n            }\n        }\n        else {\n            hnt.hide();\n        }\n    }\n}\nfunction enableAnswerInputAfterDelay(answer_input, delay) {\n    if (delay === void 0) { delay = 1; }\n    startCriticalAnimation('answerInputFadeIn', delay, function () {\n        if (figure.custom.helperPlaying !== true) {\n            figure.custom.enableInteraction();\n        }\n    }, figure.elements);\n    // criticalAnimation(\n    //   'answerInputFadeIn',\n    //   delay,\n    //   () => {\n    //     if (figure.custom.helperPlaying !== true) {\n    //       figure.custom.enableInteraction();\n    //     }\n    //   },\n    //   figure.elements,\n    // );\n    // figure.elements.animations.new('answerInputFadeIn')\n    //   .delay(delay)\n    //   .trigger(() => {\n    //     if (figure.custom.helperPlaying !== true) {\n    //       figure.custom.enableInteraction();\n    //     }\n    //     clearCriticalAnimation('enableAnswerInputAfterDelay');\n    //   })\n    //   .start();\n    // figure.custom.enableAnswerInput();\n}\nfunction processResponse(data, answer_input) {\n    var _a, _b;\n    // console.log('processResponse', data)\n    // The legacy global request() in static/js/tools.js calls back with undefined\n    // after a failed fetch; there is nothing to process.\n    if (data == null) {\n        return;\n    }\n    // Graded answers start the reset on submit. Decision-style question inputs\n    // call processResponse directly; they still need the scene restored before\n    // feedback and answer bubbles are positioned.\n    var zoomReset = (_b = (_a = figure.custom).resetSceneZoom) === null || _b === void 0 ? void 0 : _b.call(_a);\n    if (zoomReset) {\n        void zoomReset.then(function () { return processResponseAfterZoom(data, answer_input); });\n        return;\n    }\n    processResponseAfterZoom(data, answer_input);\n}\nfunction processResponseAfterZoom(data, answer_input) {\n    var _a;\n    stampInlineSpeechResponse(data);\n    try {\n        figure.custom.response = data;\n        // A response may carry a reissued speech token — the server sends one when an\n        // action changed a speech setting, so the rest of THIS question speaks in the new\n        // voice instead of waiting for the next question's config. Ignored when absent.\n        setSpeechToken(data.speech_token);\n        if (data.exception_msg) {\n            window.location.href = \"\".concat(window.location.origin, \"/exception_msg\");\n        }\n        figure.custom.answerSubmitted = true;\n        var reloadDelay \n        // Do NOT sync the chrome here — the current question's DOM is still on\n        // screen, and data.screen_type may reflect a post-answer state (e.g. 0\n        // for a completion summary) that would hide the chrome before the star\n        // animation can play.  syncProgressChrome runs after reloadQuestion in\n        // transitionToNextQuestion, when the new screen's DOM is ready.\n        = void 0;\n        // Do NOT sync the chrome here — the current question's DOM is still on\n        // screen, and data.screen_type may reflect a post-answer state (e.g. 0\n        // for a completion summary) that would hide the chrome before the star\n        // animation can play.  syncProgressChrome runs after reloadQuestion in\n        // transitionToNextQuestion, when the new screen's DOM is ready.\n        if (window.animateMathProgress) {\n            reloadDelay = animateMathProgress(data.completion_score, data.total_correct_answers, data.star_earned);\n        }\n        if (reloadDelay == null) {\n            reloadDelay = 0;\n        }\n        if (data.reload !== true && data.speech != null) {\n            if (figure.speechManager) {\n                // @ts-expect-error: TS2367\n                if (data.speech.chunked == \"[]\") {\n                    console.log('No speech returned!');\n                }\n                else {\n                    // @ts-expect-error: TS2345\n                    figure.chunkedSpeech[data.speech.hash] = JSON.parse(data.speech.chunked);\n                    figure.speechOptions[data.speech.hash] = {\n                        require_answer: data.speech.require_answer == null ? true : data.speech.require_answer,\n                    };\n                    if (data.speech.interrupt && figure.speechId != null) {\n                        // Interrupt speech — pause current play, play this, then resume\n                        figure.speechManager.interruptPlay(data.speech.hash, true);\n                    }\n                    else {\n                        // Normal speech — replace current playback.\n                        // Mark the guide as pending BEFORE figure.stop('complete'): that call\n                        // force-completes any in-flight animation, including an answer-reveal's\n                        // pending continue-button delay. If guideInit isn't set yet when that\n                        // fires, the reveal's guard sees no guide and shows the continue button\n                        // immediately (mid-/pre-narration). Setting guideInit first lets the\n                        // guard defer the reveal until this guide's speech finishes.\n                        figure.helper.guideInit = data.speech.hash;\n                        figure.stop('complete');\n                        figure.speechManager.interruptedState = null;\n                        if (figure.helper.guideStart == null) {\n                            figure.helper.guideStart = performance.now();\n                        }\n                        figure.speechManager.play(data.speech.hash);\n                        if (data.show_answer) {\n                            figure.helper.answerShown = true;\n                        }\n                        figure.helper.startPlaying(data.speech.hash);\n                    }\n                }\n            }\n        }\n        if (data.result != null) {\n            var hideBubble = true;\n            var enableAnswerInput = true;\n            figure.elements.stop('complete');\n            if (data.reload != true) {\n                // Do not delete next line - it is needed for slides continue button\n                figure.elements.hasTouchableElements = true;\n                figure.custom.keyboard = 'enabled';\n            }\n            if (data.result === AnswerResult.CORRECT) {\n                stopHelper();\n                if (figure.custom.bubble != null) {\n                    var correctMsg = null;\n                    if (data.math_fact_speed_test != null && data.math_fact_speed_test.msg != null) {\n                        correctMsg = data.math_fact_speed_test.msg;\n                        reloadDelay = 3000;\n                        if (data.math_fact_speed_test.achievements.indexOf(1) > -1) {\n                            figure.custom.move_fastest_ever(data.math_fact_speed_test.ever.fastest);\n                        }\n                        // if (data.math_fact_speed_test.achievements.indexOf(3) > -1) {\n                        //   figure.custom.move_average_ever(data.math_fact_speed_test.ever.average)\n                        // }\n                    }\n                    figure.custom.bubble.show(correctMsg, 'correct');\n                }\n                if (answer_input != null && answer_input.custom.showAnswerInfo != null && data.answer_info != null) {\n                    answer_input.custom.showAnswerInfo(data.answer_info);\n                    if (figure.speechManager) {\n                        figure.helper.answerShown = true;\n                    }\n                }\n                if (answer_input.custom.showCorrectness != null) {\n                    answer_input.custom.showCorrectness(true);\n                }\n                figure.elements.animations\n                    .new()\n                    .delay(0.5 + reloadDelay)\n                    .trigger(function () {\n                    if (answer_input != null) {\n                        answer_input.hasTouchableElements = true;\n                    }\n                })\n                    .start();\n                hideBubble = false;\n                enableAnswerInput = false;\n            }\n            else if (data.show_answer) {\n                stopHelper();\n                var ai = getAnswerInput();\n                figure.custom.answerSubmitted = false;\n                if (ai != null && (data.cancel_show_answer == null || data.cancel_show_answer === false)) {\n                    ai.showAnswer(data.answer_info);\n                }\n                if (figure.speechManager) {\n                    figure.helper.answerShown = true;\n                }\n                if (ai != null) {\n                    ai.hasTouchableElements = true;\n                }\n                // answer_input.showAnswer();\n                figure.elements.hasTouchableElements = true;\n                if (figure.resumeCountdown != null && figure.resumeCountdownOnIncorrect) {\n                    figure.resumeCountdown();\n                }\n                if (data.result == AnswerResult.NEEDS_HELP) {\n                    figure.custom.bubble.hide();\n                }\n                hideBubble = false;\n                enableAnswerInput = false;\n            }\n            else if (data.result === AnswerResult.DONT_KNOW && data.honing) {\n                figure.custom.bubble.show(\"Ok, let's try something else\", 'correct');\n                hideBubble = false;\n                enableAnswerInput = false;\n            }\n            else if (data.result === AnswerResult.INVALID) {\n                if (data.msg != null) {\n                    figure.custom.bubble.show(data.msg, 'invalid');\n                }\n                else if (data.answer_info != null && data.answer_info.msg != null) {\n                    figure.custom.bubble.show(data.answer_info.msg, 'invalid');\n                }\n                else {\n                    figure.custom.bubble.show('Invalid Answer', 'invalid');\n                }\n            }\n            else if (data.result === AnswerResult.INVALID_EMPTY) {\n                figure.custom.bubble.show('No answer submitted!', 'invalid');\n                if (figure.resumeCountdown != null) {\n                    figure.resumeCountdown();\n                }\n            }\n            else if (data.result === AnswerResult.INVALID_FRACTION) {\n                figure.custom.bubble.show('Fraction answer incomplete!', 'invalid');\n            }\n            else if (data.result === AnswerResult.INVALID_REPEATER_AT_END) {\n                figure.custom.bubble.show('Repeater can only be at end!', 'invalid');\n            }\n            else if (data.result === AnswerResult.INVALID_REPEATER_DECIMAL) {\n                figure.custom.bubble.show('Repeater can only be after a decimal point!', 'invalid');\n            }\n            else if (data.result === AnswerResult.INVALID_MULTI_REPEATER) {\n                figure.custom.bubble.show('Only one repeater can be used!', 'invalid');\n            }\n            else if (data.result === AnswerResult.INVALID_REPEATER_DIGIT) {\n                figure.custom.bubble.show('Only numbers can be in a repeater!', 'invalid');\n            }\n            else if (data.result === AnswerResult.INVALID_REPEATER_EMPTY) {\n                figure.custom.bubble.show('Repeater is empty!', 'invalid');\n            }\n            else if (data.result === AnswerResult.INVALID_POWER) {\n                figure.custom.bubble.show('Power answer incomplete!', 'invalid');\n            }\n            else if (data.result === AnswerResult.INVALID_BACKWARDS) {\n                // The spoken prompt varies (see BACKWARDS_ANSWER_SPEECHES); this is the\n                // fallback for a learner with speech off.\n                figure.custom.bubble.show('Is that backwards?', 'invalid');\n                // Submitting paused the countdown. Unlike the malformed-entry results,\n                // this was a real attempt on the question, so the timer has to restart\n                // or a speed-tested question can never time out. resumeCountdown credits\n                // the paused interval, so the prompt itself costs the learner nothing.\n                if (figure.resumeCountdown != null) {\n                    figure.resumeCountdown();\n                }\n            }\n            else if (data.result === AnswerResult.INCORRECT &&\n                data.reload &&\n                data.honing) {\n                figure.custom.bubble.show(\"Ok, let's try something else\", 'incorrect');\n            }\n            else if (data.result === AnswerResult.NEEDS_HELP) {\n                figure.elements.hasTouchableElements = true;\n                figure.custom.bubble.hide();\n            }\n            else if (data.result === AnswerResult.TECHNICALLY_CORRECT) {\n                if (answer_input.custom.showCorrectness != null) {\n                    answer_input.custom.showCorrectness();\n                }\n                if (data.msg != null) {\n                    figure.custom.bubble.show(data.msg, 'technically_correct');\n                }\n                else if (data.answer_info != null && data.answer_info.msg != null) {\n                    figure.custom.bubble.show(data.answer_info.msg, 'technically_correct');\n                }\n                else {\n                    figure.custom.bubble.show('Almost!', 'technically_correct');\n                }\n                // // figure.custom.bubble.show(data.msg, 'technically_correct');\n                // answer_input.hasTouchableElements = true;\n                // answer_input.stop();\n                // answer_input.setOpacity(0.6);\n                // if (answer_input.custom.afterSubmit != null) {\n                //   answer_input.custom.afterSubmit();\n                // } else {\n                //   answer_input.animations\n                //     .new()\n                //     .delay(0.2)\n                //     .opacity({ target: 1, duration: 0.2 })\n                //     .start();\n                //   // hideBubble = true;\n                // }\n                hideBubble = false;\n                enableAnswerInput = true;\n                if (figure.resumeCountdown != null) {\n                    figure.resumeCountdown();\n                }\n            }\n            else {\n                var answer_input_1 = figure.elements.custom.answer_input;\n                // console.log(data.msg)\n                if (data.honing) {\n                    figure.custom.bubble.show('Whoops!', 'incorrect');\n                }\n                else if (data.msg != null) {\n                    figure.custom.bubble.show(data.msg, 'incorrect');\n                }\n                else if (data.answer_info != null && data.answer_info.msg != null) {\n                    figure.custom.bubble.show(data.answer_info.msg, 'incorrect');\n                }\n                else {\n                    figure.custom.bubble.show(null, 'incorrect');\n                }\n                if (data.msg === '_HIDE_') {\n                    figure.custom.bubble.hide();\n                    reloadDelay = 0.2;\n                }\n                if (answer_input_1 != null && answer_input_1.custom.showAnswerInfo != null && data.answer_info != null) {\n                    answer_input_1.custom.showAnswerInfo(data.answer_info);\n                    // if (figure.speechManager) {\n                    //   figure.helper.answerShown = true;\n                    // }\n                }\n                var afterDelayAnimations = [];\n                if (answer_input_1 != null) {\n                    if (answer_input_1.custom.afterSubmit != null) {\n                        afterDelayAnimations.push(answer_input_1.animations.trigger(function () { return answer_input_1.custom.afterSubmit(); }));\n                        // answer_input.cusotm.afterSubmit();\n                    }\n                    else {\n                        afterDelayAnimations.push(answer_input_1.animations.opacity({ target: 1, duration: 0.2 }));\n                    }\n                }\n                // if (data.msg == null && (data.answer_info == null || data.answer_info.msg == null)) {\n                //   // afterDelayAnimations.push(\n                //   //   figure.elements.animations.trigger({\n                //   //     callback: () => {\n                //   //       figure.custom.bubble.hide();\n                //   //     },\n                //   //   }),\n                //   // );\n                // }\n                // console.log('start animations')\n                figure.elements.animations\n                    .new('answerInputFadeIn')\n                    .delay(0.5)\n                    .trigger(function () {\n                    if (answer_input_1 != null) {\n                        answer_input_1.hasTouchableElements = true;\n                    }\n                })\n                    .delay(1)\n                    .inParallel(afterDelayAnimations)\n                    .start();\n                // for (let i = 0; i < figure.elements.animations.animations.length; i += 1) {\n                //   console.log(i, figure.elements.animations.animations[i].name);\n                // }\n                if (answer_input_1.custom.showCorrectness != null) {\n                    answer_input_1.custom.showCorrectness();\n                }\n                if (figure.resumeCountdown != null) {\n                    figure.resumeCountdown();\n                }\n            }\n            if (hideBubble || enableAnswerInput) {\n                if (hideBubble) {\n                    figure.elements.animations\n                        .new()\n                        .delay(5)\n                        .trigger(function () { return figure.custom.bubble.hide(); })\n                        .start();\n                }\n                if (enableAnswerInput) {\n                    enableAnswerInputAfterDelay(answer_input, 1);\n                }\n            }\n        }\n        if (data.reload !== true\n            && data.fastReload !== true\n            && data.answer_info != null\n            && data.answer_info.exec != null\n            && (data.show_answer !== true\n                || data.answer_info.exec.onShow)) {\n            // Stop the helper icon from showing when planning a reload\n            if (figure.speechManager && data.answer_info.reload === true) {\n                figure.helper.answerShown = true;\n            }\n            var exec = data.answer_info.exec;\n            var element = figure.elements._expression.getElement(exec.element);\n            if (element == null) {\n                element = figure.getElement(exec.element);\n            }\n            if (element) {\n                element[exec.method](exec.params);\n            }\n        }\n        if (data.reload != null) {\n            if (data.redirect != null) {\n                figure.custom.reloadRedirect = data.redirect;\n            }\n            figure.custom.reloadFalse = false;\n            if (data.force_reload) {\n                figure.custom.forceReload = true;\n            }\n            if (data.reload === true) {\n                figure.custom.disableInteraction();\n                var timeout_1 = 1;\n                if (data.result != null) {\n                    timeout_1 = 1000;\n                }\n                if (reloadDelay > 0) {\n                    timeout_1 = reloadDelay;\n                    if (data.speech) {\n                        timeout_1 += 1;\n                    }\n                }\n                if (data.fastReload) {\n                    timeout_1 = 0;\n                }\n                // timeout = 100000\n                // console.log(timeout, data.speech)\n                if (timeout_1 > 0 && data.speech != null) {\n                    if (figure.speechManager) {\n                        // @ts-expect-error: TS2367\n                        if (data.speech.chunked == \"[]\") {\n                            console.log('No speech returned!');\n                        }\n                        else {\n                            figure.helper.reload = true;\n                            // @ts-expect-error: TS2345\n                            figure.chunkedSpeech[data.speech.hash] = JSON.parse(data.speech.chunked);\n                            figure.speechOptions[data.speech.hash] = {\n                                require_answer: data.speech.require_answer || true,\n                            };\n                            var reloadTriggered_1 = false;\n                            var doReload_1 = function () {\n                                var _a, _b;\n                                if (reloadTriggered_1)\n                                    return;\n                                reloadTriggered_1 = true;\n                                (_b = (_a = figure.custom).reload) === null || _b === void 0 ? void 0 : _b.call(_a);\n                            };\n                            figure.speechManager.playFinishedCallback1 = function () {\n                                setTimeout(function () { return doReload_1(); }, timeout_1);\n                            };\n                            // Record time before playing to detect if speech actually started\n                            var playStartedBefore_1 = figure.speechManager.playStartedTime;\n                            figure.speechManager.play(data.speech.hash);\n                            figure.helper.guideInit = data.speech.hash;\n                            figure.helper.startPlaying(data.speech.hash);\n                            // Fallback: if speech hasn't started or isn't actively playing\n                            // after 5 seconds (e.g. failed to load, or iOS suspended the\n                            // AudioContext mid-playback), force reload so the learner\n                            // isn't stuck.\n                            figure.custom._speechFallbackTimer = setTimeout(function () {\n                                figure.custom._speechFallbackTimer = null;\n                                var neverStarted = figure.speechManager.playStartedTime === playStartedBefore_1;\n                                var ctx = figure.speechManager.ctx;\n                                var ctxDead = ctx == null || ctx.state !== 'running';\n                                if (neverStarted || !figure.speechManager.isPlaying || ctxDead) {\n                                    doReload_1();\n                                }\n                            }, 5000);\n                        }\n                    }\n                }\n                else {\n                    setTimeout(function () { var _a, _b; return (_b = (_a = figure.custom).reload) === null || _b === void 0 ? void 0 : _b.call(_a); }, timeout_1);\n                }\n                return;\n            }\n            else if (data.reload === false) {\n                figure.custom.reloadFalse = true;\n            }\n        }\n        if (data.show_back != null) {\n            var back_button = figure.get('back_button');\n            if (back_button != null) {\n                if (data.show_back) {\n                    back_button.showAll();\n                }\n                else {\n                    back_button.hide();\n                }\n            }\n        }\n        if (data.answer_input != null && answer_input != null) {\n            if (data.answer_input != null) {\n                answer_input.custom.answer_expected = data.answer_input.answer_expected;\n            }\n        }\n        var hnt = figure.get('hnt');\n        var inst = figure.get('instruction');\n        var expr = figure.get('expression');\n        if (data.overrides != null) {\n            if (hnt != null) {\n                hnt._hint.updateElementText(data.overrides);\n            }\n            if (expr != null) {\n                expr.updateElementText(data.overrides);\n            }\n            if (inst != null) {\n                inst.updateElementText(data.overrides);\n            }\n        }\n        if (data.sub_answer != null) {\n            if (hnt != null) {\n                hnt._hint.updateElementText({ sub_answer: data.sub_answer.toString() });\n            }\n            if (expr != null) {\n                expr.updateElementText({ sub_answer: data.sub_answer.toString() });\n            }\n            if (inst != null) {\n                inst.updateElementText({ sub_answer: data.sub_answer.toString() });\n            }\n        }\n        processHint(data.hint);\n        if (data.pulse != null) {\n            if (typeof data.pulse == 'string') {\n                var element = getElem(data.pulse);\n                if (element != null) {\n                    pulseElement(element, {\n                        mag: 0.03,\n                        duration: 0.8,\n                        type: 'v',\n                        frequency: 2.5,\n                        delay: 0,\n                    });\n                }\n            }\n            else {\n                var pulse = {};\n                var element = void 0;\n                if (typeof data.pulse !== 'string') {\n                    pulse = data.pulse;\n                    element = data.pulse.element;\n                }\n                else {\n                    element = data.pulse;\n                }\n                // let element: string or Array<string> = [];\n                // if (Array.isArray(pulse)) {\n                //   element = pulse;\n                //   pulse = {};\n                // } else {\n                //   element = pulse.element;\n                // }\n                pulseElement(element, pulse);\n            }\n        }\n        if (data.expression != null && expr != null) {\n            expr.goToForm({ form: data.expression, animate: 'move' });\n            if (expr.scenarios[data.expression] != null) {\n                expr.animations.new().scenario({ target: data.expression }).start();\n            }\n            else {\n                expr.animations.new().scenario({ target: 'default' }).start();\n            }\n        }\n        if (data.instruction != null && inst != null) {\n            inst.goToForm({ form: data.instruction, animate: 'move' });\n            if (inst.scenarios[data.instruction] != null) {\n                inst.animations.new().scenario({ target: data.instruction }).start();\n            }\n            else {\n                inst.animations.new().scenario({ target: 'default' }).start();\n            }\n        }\n        // throw new Error('Test error');\n        if (data.slide != null && data.slide === 'next') {\n            var nav_1 = figure.get('nav');\n            answer_input.hasTouchableElements = false;\n            if (nav_1 != null) {\n                if (data.result != null) {\n                    var doNextSlide_1 = function () {\n                        nav_1.nav.nextSlide();\n                        figure.loadTime = performance.now();\n                        figure.custom.bubble.hide();\n                        answer_input.setOpacity(1);\n                        answer_input.hasTouchableElements = true;\n                        figure.elements.clear();\n                        figure.animateNextFrame();\n                    };\n                    // Speech from this response is kicked off earlier in this handler\n                    // (the `data.speech` branch) via speechManager.play(), which\n                    // synchronously sets isPlaying=false and only flips it back to\n                    // true from a later microtask/timeout.  So we can't just check\n                    // isPlaying here — if a guide was just started, it hasn't\n                    // started \"playing\" yet by this point.\n                    var willPlaySpeech = data.speech != null\n                        // @ts-expect-error: TS2367\n                        && data.speech.chunked !== \"[]\";\n                    if (willPlaySpeech || ((_a = figure.speechManager) === null || _a === void 0 ? void 0 : _a.isPlaying)) {\n                        // Wait for speech to actually start playing, then for it to end,\n                        // before advancing. Fallbacks handle speech that never starts\n                        // (e.g. AudioContext suspended) or never ends.\n                        var done_1 = false;\n                        var startedPlaying_1 = false;\n                        var advance_1 = function () {\n                            if (done_1)\n                                return;\n                            done_1 = true;\n                            clearInterval(poll_1);\n                            figure._slideNextPoll = null;\n                            if (figure._slideNextFallback != null) {\n                                clearTimeout(figure._slideNextFallback);\n                                figure._slideNextFallback = null;\n                            }\n                            if (figure._slideNextCeiling != null) {\n                                clearTimeout(figure._slideNextCeiling);\n                                figure._slideNextCeiling = null;\n                            }\n                            figure._slideNextDoTimer = setTimeout(doNextSlide_1, 1000);\n                        };\n                        var poll_1 = setInterval(function () {\n                            var _a;\n                            if ((_a = figure.speechManager) === null || _a === void 0 ? void 0 : _a.isPlaying) {\n                                startedPlaying_1 = true;\n                            }\n                            else if (startedPlaying_1) {\n                                advance_1();\n                            }\n                        }, 250);\n                        figure._slideNextPoll = poll_1;\n                        // Fallback: if speech never starts within 2s, advance anyway\n                        figure._slideNextFallback = setTimeout(function () {\n                            if (!startedPlaying_1)\n                                advance_1();\n                        }, 2000);\n                        // Hard ceiling: advance after 30s no matter what\n                        figure._slideNextCeiling = setTimeout(advance_1, 30000);\n                    }\n                    else {\n                        figure._slideNextDoTimer = setTimeout(doNextSlide_1, 1000);\n                    }\n                }\n                else {\n                    answer_input.setOpacity(1);\n                    nav_1.nav.nextSlide();\n                    figure.loadTime = performance.now();\n                    answer_input.hasTouchableElements = true;\n                    figure.custom.bubble.hide();\n                }\n            }\n        }\n    }\n    catch (err) {\n        var errorStr = \"\";\n        if (err.error != null) {\n            errorStr = JSON.stringify(err.error, Object.getOwnPropertyNames(err.error));\n        }\n        logError({\n            msg: err.message,\n            filename: err.filename,\n            lineno: err.lineno,\n            colno: err.colno,\n            error: errorStr,\n            srcElement: err.srcElement,\n            target: err.target,\n            timestamp: err.timeStamp,\n            stack: err.stack,\n        }, 'response');\n        // throw err;\n    }\n}\nexport { processResponse, processHint };\n","var __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nvar __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nvar __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n        if (ar || !(i in from)) {\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n            ar[i] = from[i];\n        }\n    }\n    return to.concat(ar || Array.prototype.slice.call(from));\n};\nimport request from './request/request';\nimport setupExternalSubmitPreview from './externalSubmitPreview';\nimport { setupTouchCursor } from './debug/touchCursor';\nimport { setupKeyboardViewport } from './keyboardViewport';\nimport { setupQuestionHeaderFit } from './questionHeaderFit';\nimport { getGPUDeviceInfo, getWebGLSnapshot, getWebGLHistory } from './request/webglDiagnostics';\nimport { getSceneZoomTelemetry } from './tools/sceneZoomTelemetry';\n// Remove the slow-load indicator (alpha.html), if the page still has it\nfunction removePageLoading() {\n    var pageLoading = document.getElementById('page-loading');\n    if (pageLoading)\n        pageLoading.remove();\n}\n// Thrown when the browser refuses the initial WebGL context. Caller\n// (loadQuestion) catches this and aborts question setup — the overlay\n// is already on screen, so there's nothing more to render.\nvar WebGLUnavailableError = /** @class */ (function (_super) {\n    __extends(WebGLUnavailableError, _super);\n    function WebGLUnavailableError() {\n        var _this = _super.call(this, 'WebGL unavailable') || this;\n        _this.name = 'WebGLUnavailableError';\n        return _this;\n    }\n    return WebGLUnavailableError;\n}(Error));\nexport { WebGLUnavailableError };\n// ---------------------------------------------------------------------------\n// Letter spacing for all FigureOne canvas text — global switch.\n//\n//   LETTER_SPACING_ON     build-time default: flip to false to ship it off\n//   LETTER_SPACING_VALUE  the amount, as a fraction of the font size\n//\n// Runtime override, no rebuild needed (survives reloads and question changes):\n//   localStorage.setItem('_grokkoli_letter_spacing', 'off')      // force off\n//   localStorage.setItem('_grokkoli_letter_spacing', 'on')       // force on\n//   localStorage.setItem('_grokkoli_letter_spacing', '0.1em')    // custom\n//   localStorage.removeItem('_grokkoli_letter_spacing')          // default\n// Or call ls() / ls('off') / ls('0.1em') in the console to switch and relayout\n// on the spot, without a reload.\n//\n// The value must be in `em`: FigureOne always measures at a fixed 20px canvas\n// font and draws under a transform, so `em` stays correct at any font size and\n// any devicePixelRatio, where a `px` value would not.\n// ---------------------------------------------------------------------------\nexport var LETTER_SPACING_ON = true;\nexport var LETTER_SPACING_VALUE = '0.06em';\nexport var LETTER_SPACING_KEY = '_grokkoli_letter_spacing';\nvar LETTER_SPACING_OFF = '0px';\n// The spacing this page should use — build-time default, localStorage wins.\nexport function getLetterSpacing() {\n    var value = LETTER_SPACING_ON ? LETTER_SPACING_VALUE : LETTER_SPACING_OFF;\n    try {\n        var override = localStorage.getItem(LETTER_SPACING_KEY);\n        if (override === 'off') {\n            value = LETTER_SPACING_OFF;\n        }\n        else if (override === 'on') {\n            value = LETTER_SPACING_VALUE;\n        }\n        else if (override) {\n            value = override;\n        }\n    }\n    catch ( /* localStorage unavailable */_a) { /* localStorage unavailable */ }\n    return value;\n}\n// Apply letter spacing to FigureOne's text canvas the ONLY way both engines\n// agree on: the ctx.letterSpacing attribute.\n//\n// The CSS route does not work cross-browser. Chrome applies the canvas\n// element's computed CSS letter-spacing to canvas 2D text, Safari 26 does not\n// (iOS Safari 18.5 still did — a WebKit version change), so inheriting\n// `body { letter-spacing: 1px }` silently widened every string in Chrome only.\n// FigureOne measures text with ctx.measureText, so that discrepancy moved\n// LAYOUT, not just pixels. figureone.css now pins .figureone__canvas to\n// `letter-spacing: normal` to shut that path off; this is the replacement.\n//\n// FigureOne's own font.letterSpacing (content/utils/constants.py) is NOT an\n// alternative: it is only consumed by the atlas/WebGL glyph path, never by the\n// '2d' render path these questions use.\n//\n// Verified: the attribute survives ctx.font assignment and save()/restore(),\n// and overrides (does not add to) any inherited CSS letter-spacing.\n//\n// Below Chrome 99 / Safari 17.4 the property does not exist and text renders\n// with no extra spacing — i.e. slightly tighter, never wider. Layouts must\n// therefore keep fitting at ZERO spacing; treat this as clearance, not budget.\n// Returns false when the browser has no ctx.letterSpacing (below Chrome 99 /\n// Safari 17.4) — there text simply renders unspaced, never wider.\n//\n// The spacing currently in force, so the resize hook below can restore it\n// (rather than a stale captured value) after ls() has changed it.\nvar activeLetterSpacing = null;\nexport function setFigureLetterSpacing(fig, value) {\n    var draw2D = fig && fig.draw2DLow;\n    var ctx = draw2D && draw2D.ctx;\n    if (!ctx || !('letterSpacing' in ctx)) {\n        return false;\n    }\n    activeLetterSpacing = value != null ? value : getLetterSpacing();\n    ctx.letterSpacing = activeLetterSpacing;\n    // Re-apply on every canvas resize, or the setting silently dies mid-session.\n    // DrawContext2D.resize() assigns canvas.width, which resets the ENTIRE 2D\n    // context state — letterSpacing included (verified in-browser: '2px' -> '0px',\n    // and figure.resize() took 0.06em -> 0px with measureText('more') 58.8 -> 54).\n    // Figure.resize() then calls sizeHtmlText() and elements.resize(), which\n    // re-measure and re-lay-out text, BEFORE it publishes its 'resize'\n    // notification — so a notification listener would restore the spacing one\n    // relayout too late. Wrapping resize itself is the only hook early enough.\n    if (!draw2D.grokkoliLetterSpacingPatched) {\n        draw2D.grokkoliLetterSpacingPatched = true;\n        var originalResize_1 = draw2D.resize.bind(draw2D);\n        draw2D.resize = function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            originalResize_1.apply(void 0, args);\n            if (activeLetterSpacing != null) {\n                ctx.letterSpacing = activeLetterSpacing;\n            }\n        };\n    }\n    return true;\n}\nexport default function createFigure(config) {\n    var _a, _b, _c;\n    var _d;\n    setupExternalSubmitPreview();\n    setupTouchCursor();\n    setupKeyboardViewport();\n    setupQuestionHeaderFit();\n    window.__load_pre_figure = new Date().getTime();\n    window.colors = config.colors;\n    var defaultFontFamily = config.defaultFontFamily;\n    var defaultFontFamilyMath = config.defaultFontFamilyMath;\n    window.defaultFontFamily = defaultFontFamily;\n    window.defaultFontFamilyMath = defaultFontFamilyMath;\n    window.defaultLetterSpacing = config.defaultLetterSpacing;\n    window.defaultFont = {\n        family: defaultFontFamily, render: '2d', glyphs: 'latin',\n        size: config.defaultFontSize, style: 'normal', weight: config.defaultFontWeight,\n    };\n    window.defaultTextFont = {\n        family: defaultFontFamily, render: '2d', glyphs: 'latin',\n        size: config.defaultFontSize, weight: config.defaultFontWeight, style: 'normal',\n    };\n    var Figure = Fig.Figure, tools = Fig.tools, joinObjects = Fig.joinObjects, round = Fig.round;\n    window.joinObjects = joinObjects;\n    window.round = round;\n    window.grokkoli = {};\n    var figureOptions = {\n        color: tools.color.HexToArray(config.foregroundColor),\n        backgroundColor: [0, 0, 0, 0],\n        textStyle: 'normal',\n        font: {\n            family: defaultFontFamily, render: '2d', glyphs: 'latin',\n            size: config.defaultFontSize, weight: config.defaultFontWeight,\n        },\n    };\n    if (config.scene) {\n        figureOptions.scene = config.scene;\n    }\n    // Debug: simulate the browser refusing the initial WebGL context, to\n    // manually exercise the unavailability path (overlay + loadQuestion\n    // abort).  Enable via URL query (?disable_webgl=1) for one page load,\n    // or localStorage (_grokkoli_disable_webgl='1') across reloads.\n    // The URL param is stripped after reading so a manual refresh (or\n    // the overlay's \"Reload now\" button) loads cleanly.\n    var params = new URLSearchParams(window.location.search);\n    var disableWebGLFromQuery = params.get('disable_webgl') === '1';\n    if (disableWebGLFromQuery) {\n        params.delete('disable_webgl');\n        var qs = params.toString();\n        var newUrl = window.location.pathname + (qs ? \"?\".concat(qs) : '') + window.location.hash;\n        window.history.replaceState(null, '', newUrl);\n    }\n    var disableWebGL = disableWebGLFromQuery;\n    try {\n        disableWebGL = disableWebGL || localStorage.getItem('_grokkoli_disable_webgl') === '1';\n    }\n    catch ( /* localStorage unavailable */_e) { /* localStorage unavailable */ }\n    if (disableWebGL) {\n        var origGetContext_1 = HTMLCanvasElement.prototype.getContext;\n        HTMLCanvasElement.prototype.getContext = function (type) {\n            var _a;\n            var rest = [];\n            for (var _i = 1; _i < arguments.length; _i++) {\n                rest[_i - 1] = arguments[_i];\n            }\n            if (type === 'webgl' || type === 'webgl2' || type === 'experimental-webgl')\n                return null;\n            return (_a = origGetContext_1).call.apply(_a, __spreadArray([this, type], rest, false));\n        };\n    }\n    var fig = new Figure(figureOptions);\n    window.figure = fig;\n    window.figureOneFigures = [fig];\n    setFigureLetterSpacing(fig);\n    fig.gesturePreventDefault = 'ifTouched';\n    // FigureOne calls preventDefault() from its touchmove handler after a drag.\n    // Chrome can mark later moves non-cancelable once native scrolling begins;\n    // forwarding those moves produces an intervention warning and cannot stop\n    // the scroll. Let the browser finish that gesture instead.\n    var ignoreUncancelableTouchMove = function (event) {\n        if (!event.cancelable)\n            event.stopImmediatePropagation();\n    };\n    fig.gestureCanvas.addEventListener('touchmove', ignoreUncancelableTouchMove, { capture: true, passive: false });\n    (_a = (_d = fig)._docListeners) !== null && _a !== void 0 ? _a : (_d._docListeners = []);\n    fig._docListeners.push({\n        target: fig.gestureCanvas,\n        event: 'touchmove',\n        handler: ignoreUncancelableTouchMove,\n        options: { capture: true },\n    });\n    fig.custom = {};\n    fig.custom.showContinueDelay = config.showContinueDelay;\n    fig.loadTime = performance.now();\n    // Defer the 'fontsLoaded' relayout while an animation is in flight.\n    //\n    // When a web font finishes loading (or times out), FigureOne's FontManager\n    // publishes 'fontsLoaded', which runs figure.fontsLoaded() -> layoutForms() ->\n    // form.setPositions() on every equation. setPositions snaps every element to\n    // its *current form's resting pose*. If this lands mid form-animation (e.g.\n    // the first |f_tri| move on a play question, while the equation is tweening\n    // f_all -> f_tri), it slams the elements to the target pose for a single frame\n    // before the tween's next frame overwrites them again — the intermittent\n    // \"jump to the end\" seen on the FIRST/cold play. It only happens cold because\n    // the font load resolves once, early on, and races against that first move; on\n    // warm plays the font is already loaded so the event never fires mid-play.\n    //\n    // We intercept the publish and, if the figure is animating, hold the event\n    // (all subscribers together, so relayout / autoCenter / enable-interaction\n    // stay in their original order) until animations settle, capped so a\n    // long-running animation can't starve the relayout indefinitely.\n    var fontNotifs = fig.fonts && fig.fonts.notifications;\n    if (fontNotifs && typeof fontNotifs.publish === 'function' && !fontNotifs.__grokFontsLoadedDefer) {\n        fontNotifs.__grokFontsLoadedDefer = true;\n        var origPublish_1 = fontNotifs.publish.bind(fontNotifs);\n        var DEFER_CAP_MS_1 = 3000;\n        var isAnimating_1 = function () { return typeof fig.getRemainingAnimationTime === 'function'\n            && fig.getRemainingAnimationTime() > 0; };\n        fontNotifs.publish = function publishWithFontDefer(name) {\n            var args = [];\n            for (var _i = 1; _i < arguments.length; _i++) {\n                args[_i - 1] = arguments[_i];\n            }\n            if (name === 'fontsLoaded' && isAnimating_1()) {\n                var started_1 = performance.now();\n                var run_1 = function () {\n                    if (isAnimating_1() && performance.now() - started_1 < DEFER_CAP_MS_1) {\n                        window.setTimeout(run_1, 50);\n                    }\n                    else {\n                        origPublish_1.apply(void 0, __spreadArray([name], args, false));\n                    }\n                };\n                window.setTimeout(run_1, 50);\n                return undefined;\n            }\n            return origPublish_1.apply(void 0, __spreadArray([name], args, false));\n        };\n    }\n    // Capture GPU/device diagnostics once per page load (renderer, GL\n    // limits, DPR).  Used to correlate context-loss reports with specific\n    // hardware — especially MAX_TEXTURE_SIZE, which sets the atlas clamp\n    // ceiling.  Stored on window so js_error_report can read it too.\n    var deviceInfo = getGPUDeviceInfo(fig);\n    window.__grokkoliGPUDeviceInfo = deviceInfo;\n    // Overlay copy for non-recoverable graphics failures. Defined once and\n    // shared between the live handlers and the debug helpers so the two can\n    // never drift. Declared here (before the synchronous born-dead check\n    // below) to stay out of the temporal dead zone.\n    var BORN_DEAD_HEADING = 'Your computer’s graphics system needs attention.';\n    var BORN_DEAD_DETAIL = 'Please restart your computer (and install any available system '\n        + 'updates), then reload this page. This isn’t caused by your browser tabs or memory.';\n    var UNRECOVERED_HEADING = 'Graphics didn’t recover.';\n    var UNRECOVERED_DETAIL = 'Please reload this page. If this keeps happening, restart your '\n        + 'computer.';\n    // Record the browser's reason for any WebGL context-creation failure.\n    // The event's statusMessage explains refusals like \"Out of memory\" or\n    // \"Too many active WebGL contexts\" — far more specific than a bare\n    // contextLost.  Caught here for restore-time / subsequent failures;\n    // the listener is harmless if it never fires.\n    //\n    // Lifetime: createFigure runs exactly once per page load (SPA\n    // transitions reuse this figure via _rebuildQuestion, they don't call\n    // createFigure), so this registers a single listener for the page's\n    // lifetime, bound to the figure's own canvas.  It is intentionally NOT\n    // removed in teardownQuestion — it must survive SPA transitions to\n    // catch a restore-time failure — and it is GC'd with the canvas/figure\n    // on full page navigation.  Not the accumulating document/window\n    // listener pattern CLAUDE.md warns about.\n    try {\n        if (fig.canvasLow && typeof fig.canvasLow.addEventListener === 'function') {\n            fig.canvasLow.addEventListener('webglcontextcreationerror', function (e) {\n                window.__grokkoliLastContextCreationError = e && e.statusMessage\n                    ? String(e.statusMessage).slice(0, 200) : 'unknown';\n            }, false);\n        }\n    }\n    catch ( /* canvas unavailable */_f) { /* canvas unavailable */ }\n    // If the browser refused the initial WebGL context (resource\n    // exhaustion, too many live contexts, driver refusal), FigureOne\n    // substitutes a constants-only stub for `gl` and exposes\n    // figure.webglAvailable === false. The Figure object itself is\n    // constructed successfully — including lostContextMessage — but any\n    // subsequent atlas creation would crash on gl.getParameter (the stub\n    // has no methods). Render the overlay now, then throw a sentinel so\n    // loadQuestion can abort before we get to figure.add() with text\n    // elements.\n    if (fig.webglAvailable === false) {\n        // Report to the same backend endpoint as contextLost so initial\n        // WebGL refusal is visible in the logs too. This runs before the\n        // trackContextEvent/contextState machinery below is initialised, and\n        // it fires exactly once before we throw and abort, so we POST\n        // directly rather than route through trackContextEvent (no\n        // dedup/rate-limiting needed). 'webglUnavailable' distinguishes it\n        // from 'contextLost' in the logs.\n        request('POST', 'webgl_context_event/', {\n            event: 'webglUnavailable',\n            figure: 'main',\n            source: 'createFigure:webglUnavailable',\n            question_id: (_b = window.grokkoli_question_id) !== null && _b !== void 0 ? _b : null,\n            count: 1,\n            timing: {\n                performanceNow: Math.round(performance.now()),\n                duringFontsLoading: fig.fonts.checkTimer != null,\n            },\n            device: deviceInfo,\n            snapshot: getWebGLSnapshot(),\n            zoom: getSceneZoomTelemetry(),\n        }, function () { });\n        // No spinner: nothing is happening in the background.  The browser\n        // refused outright; the user has to take action (reload / free\n        // resources).  A spinner would falsely suggest auto-recovery.\n        showContextLossOverlay('Your browser is running low on resources.', 'Try reloading the page, closing other tabs, or switching browsers.', true, false);\n        throw new WebGLUnavailableError();\n    }\n    // Born-dead context. FigureOne reports WebGL as available and gl.getParameter\n    // exists, yet MAX_TEXTURE_SIZE comes back empty — the GL context is\n    // non-functional at construction. Seen on macOS, cross-browser (Safari AND\n    // Chrome on the same machine), when the system GPU/Metal process is wedged:\n    // the browser hands over a context the OS can't actually back, getParameter\n    // returns null, and a contextLost fires 1-2s later. Atlas creation would\n    // crash on this stub-like gl, so we abort exactly like the refusal case above\n    // — but with guidance pointing at the real fix (restart the computer / update\n    // the OS), not the misleading \"close tabs / free memory\".\n    //\n    // Gate on webglVersion (gl was reachable enough to detect its version) and\n    // key ONLY on MAX_TEXTURE_SIZE: renderer/vendor being null is normal (Safari\n    // privacy masking) and must NOT trip this, but MAX_TEXTURE_SIZE is a core,\n    // non-privacy-gated parameter that is always a positive integer on a working\n    // context in every supported browser.\n    if (deviceInfo.webglVersion != null\n        && (deviceInfo.maxTextureSize == null || deviceInfo.maxTextureSize === 0)) {\n        // 'webglBornDead' distinguishes it from 'contextLost'/'webglUnavailable' in\n        // the logs. POST directly (the trackContextEvent machinery isn't set up\n        // yet) — it fires once before we throw and abort.\n        request('POST', 'webgl_context_event/', {\n            event: 'webglBornDead',\n            figure: 'main',\n            source: 'createFigure:bornDead',\n            question_id: (_c = window.grokkoli_question_id) !== null && _c !== void 0 ? _c : null,\n            count: 1,\n            timing: {\n                performanceNow: Math.round(performance.now()),\n                duringFontsLoading: fig.fonts.checkTimer != null,\n            },\n            device: deviceInfo,\n            snapshot: getWebGLSnapshot(),\n            zoom: getSceneZoomTelemetry(),\n        }, function () { });\n        showContextLossOverlay(BORN_DEAD_HEADING, BORN_DEAD_DETAIL, true, false);\n        throw new WebGLUnavailableError();\n    }\n    // Font debug logging — logs FontManager watch/timedCheck activity to console.\n    // Enable from browser console:  localStorage.setItem('_grokkoli_debug_font', 'true') \n    //   Then reload page\n    // Disable:                      localStorage.removeItem('_grokkoli_debug_font')\n    var DEBUG_FONT = !!window._grokkoli_debug_font;\n    try {\n        DEBUG_FONT = DEBUG_FONT || localStorage.getItem('_grokkoli_debug_font') === 'true';\n    }\n    catch ( /* localStorage unavailable */_g) { /* localStorage unavailable */ }\n    if (DEBUG_FONT) {\n        var origWatch_1 = fig.fonts.watch.bind(fig.fonts);\n        fig.fonts.watch = function (fontOrElement, optionsOrCallback) {\n            var result = origWatch_1(fontOrElement, optionsOrCallback);\n            if (fontOrElement && !fontOrElement.getFonts) {\n                var family = (fontOrElement.family || '').toLowerCase();\n                var glyphs = fontOrElement.glyphs;\n                var weight = fontOrElement.weight;\n                var style = fontOrElement.style;\n                console.log(\"[FontManager] watch: family=\\\"\".concat(family, \"\\\" glyphs=\\\"\").concat(glyphs, \"\\\" weight=\\\"\").concat(weight, \"\\\" style=\\\"\").concat(style, \"\\\" => id=\\\"\").concat(result === null || result === void 0 ? void 0 : result[0], \"\\\" available=\").concat(result === null || result === void 0 ? void 0 : result[1]));\n                if (result && !result[1]) {\n                    console.warn(\"[FontManager] NOT AVAILABLE: family=\\\"\".concat(family, \"\\\" glyphs=\\\"\").concat(glyphs, \"\\\" weight=\\\"\").concat(weight, \"\\\" style=\\\"\").concat(style, \"\\\" id=\\\"\").concat(result[0], \"\\\"\"));\n                }\n            }\n            return result;\n        };\n        var origTimedCheck_1 = fig.fonts.timedCheck.bind(fig.fonts);\n        fig.fonts.timedCheck = function () {\n            var fonts = fig.fonts.fonts;\n            var pending = [];\n            Object.keys(fonts).forEach(function (id) {\n                if (!fonts[id].loaded && !fonts[id].timedOut) {\n                    pending.push(id);\n                }\n            });\n            if (pending.length > 0) {\n                console.log(\"[FontManager] timedCheck at \".concat(Math.round(performance.now()), \"ms \\u2014 pending: \").concat(pending.join(', ')));\n            }\n            return origTimedCheck_1();\n        };\n    }\n    // Track WebGL context lost/restored events with escalating cooldowns\n    var CONTEXT_COOLDOWNS = [30000, 60000, 120000]; // 30s, 1min, 2min\n    if (!window.grokkoliWebGLContextTracker) {\n        window.grokkoliWebGLContextTracker = {\n            figures: 1,\n            events: [],\n            reportTracker: {},\n            lastFontsLoadedAt: null,\n        };\n    }\n    var contextState = window.grokkoliWebGLContextTracker;\n    function getTimingInfo() {\n        var _a;\n        var info = {\n            performanceNow: Math.round(performance.now()),\n            sincePageLoad: null,\n            sinceLastFontsLoaded: null,\n            duringFontsLoading: false,\n        };\n        if ((_a = performance.timing) === null || _a === void 0 ? void 0 : _a.loadEventEnd) {\n            var pageLoadedAt = performance.timing.loadEventEnd - performance.timeOrigin;\n            if (pageLoadedAt > 0) {\n                info.sincePageLoad = Math.round(performance.now() - pageLoadedAt);\n            }\n        }\n        if (contextState.lastFontsLoadedAt != null) {\n            info.sinceLastFontsLoaded = Math.round(performance.now() - contextState.lastFontsLoadedAt);\n        }\n        if (fig.fonts.checkTimer != null) {\n            info.duringFontsLoading = true;\n        }\n        return info;\n    }\n    // `source` is a stable per-call-site tag (file:reason) so a backend log line\n    // says exactly which code path emitted it — disambiguates cases that share\n    // event+figure, e.g. contextLost(workpad) fires from both workpad.ts and\n    // workpad_new/workpad.ts.\n    // `extra` is merged into the report, e.g. { error: { msg, stack } } for a\n    // workpad whose build failed.\n    function trackContextEvent(event, figureName, source, extra) {\n        var _a;\n        if (extra === void 0) { extra = {}; }\n        contextState.events.push({ figure: figureName, event: event, time: performance.now() });\n        if (contextState.events.length > 20) {\n            contextState.events.shift();\n        }\n        // Per question: the server logs one line per question for each figure\n        // and event, so a page-wide key would hold back a later question's event.\n        var questionId = (_a = window.grokkoli_question_id) !== null && _a !== void 0 ? _a : null;\n        var key = \"\".concat(figureName, \":\").concat(event, \":\").concat(questionId);\n        if (!contextState.reportTracker[key]) {\n            contextState.reportTracker[key] = { count: 0, reportsSent: 0, lastReportTime: 0 };\n        }\n        var tracker = contextState.reportTracker[key];\n        tracker.count++;\n        var body = __assign({ event: event, figure: figureName, source: source, question_id: questionId, count: tracker.count, timing: getTimingInfo(), device: deviceInfo, snapshot: getWebGLSnapshot(), history: getWebGLHistory(), zoom: getSceneZoomTelemetry() }, extra);\n        if (tracker.reportsSent === 0) {\n            tracker.lastReportTime = Date.now();\n            tracker.reportsSent++;\n            request('POST', 'webgl_context_event/', body, function () { });\n            return;\n        }\n        if (tracker.reportsSent > CONTEXT_COOLDOWNS.length)\n            return;\n        var now = Date.now();\n        if (now - tracker.lastReportTime < CONTEXT_COOLDOWNS[tracker.reportsSent - 1])\n            return;\n        tracker.lastReportTime = now;\n        tracker.reportsSent++;\n        request('POST', 'webgl_context_event/', body, function () { });\n    }\n    window.grokkoliTrackContextEvent = trackContextEvent;\n    // Builds the \"Your browser ran low on resources…\" overlay on top of\n    // the figure canvas. Shared between the post-construct webgl-\n    // unavailable check, the contextLost notification, and the debug\n    // helpers. Declared as `function` so it's hoisted — the unavailable\n    // check above runs synchronously right after `new Figure(...)`.\n    function showContextLossOverlay(heading, detail, showButton, showSpinner) {\n        // When WebGL is refused, 'ready' never fires, and the slow-load indicator\n        // would otherwise show its \"Loading...\" text over this overlay's message\n        removePageLoading();\n        var msg = fig.lostContextMessage;\n        if (!msg)\n            return;\n        msg.style.cssText = 'display:flex;align-items:center;justify-content:center;width:100%;height:100%;position:absolute;background:rgba(246,247,247,0.95);z-index:1000;pointer-events:auto;';\n        msg.innerHTML = '';\n        if (showSpinner && !document.getElementById('grokkoli-spinner-style')) {\n            var style = document.createElement('style');\n            style.id = 'grokkoli-spinner-style';\n            style.textContent = '@keyframes grokkoli-spin{to{transform:rotate(360deg)}}';\n            document.head.appendChild(style);\n        }\n        var box = document.createElement('div');\n        box.style.cssText = 'text-align:center;padding:2em;max-width:20em;font-family:inherit;color:#555;';\n        var headingEl = document.createElement('p');\n        headingEl.textContent = heading;\n        headingEl.style.cssText = 'margin:0 0 0.5em;font-size:1.05em;font-weight:500;color:#333;';\n        var detailEl = document.createElement('p');\n        detailEl.textContent = detail;\n        detailEl.style.cssText = 'margin:0 0 1.2em;font-size:0.9em;color:#777;';\n        box.appendChild(headingEl);\n        box.appendChild(detailEl);\n        if (showSpinner) {\n            var spinner = document.createElement('div');\n            spinner.style.cssText = 'width:2em;height:2em;margin:0 auto 1em;border:3px solid #ddd;border-top-color:#888;border-radius:50%;animation:grokkoli-spin 0.8s linear infinite;';\n            box.appendChild(spinner);\n        }\n        if (showButton) {\n            var btn_1 = document.createElement('button');\n            btn_1.textContent = 'Reload now';\n            btn_1.style.cssText = 'padding:0.55em 1.8em;font-size:0.95em;cursor:pointer;border:1px solid #ccc;background:#fff;color:#333;border-radius:6px;transition:background 0.15s;';\n            btn_1.addEventListener('mouseenter', function () { btn_1.style.background = '#f0f0f0'; });\n            btn_1.addEventListener('mouseleave', function () { btn_1.style.background = '#fff'; });\n            btn_1.addEventListener('click', function () { window.location.reload(); });\n            box.appendChild(btn_1);\n        }\n        msg.appendChild(box);\n    }\n    // Watchdog for the \"waiting for restore\" spinner. The spinner is honest only\n    // while a restore is plausibly pending; on some wedged GPUs (notably macOS\n    // when the system GPU process is stuck) contextRestored NEVER fires and the\n    // spinner would spin forever, implying a recovery that isn't coming. After a\n    // grace window with no restore we escalate to actionable guidance. Stored on\n    // fig (core scope, page lifetime) so it's cleared on restore and re-armed on\n    // a subsequent loss. Self-clears on fire; dies with the page on navigation,\n    // so it needs no teardownQuestion hook (createFigure runs once per page).\n    var CONTEXT_RESTORE_GRACE_MS = 10000;\n    function clearContextRestoreWatchdog() {\n        if (fig._contextRestoreWatchdog != null) {\n            clearTimeout(fig._contextRestoreWatchdog);\n            fig._contextRestoreWatchdog = null;\n        }\n    }\n    fig.notifications.add('contextLost', function () {\n        trackContextEvent('contextLost', 'main', 'createFigure:contextLost');\n        // Hopeful state: FigureOne (graceful-unavailability release) keeps the\n        // figure usable during the loss and resumes rendering automatically if the\n        // browser restores the context. The contextRestored handler hides the\n        // overlay. The spinner is honest for now \\u2014 a restore may be pending.\n        showContextLossOverlay('Your browser ran low on resources.', 'Waiting for the browser to free up resources\\u2026', true, true);\n        // Re-arm the watchdog (clear any prior timer first so repeated losses don't\n        // stack). If no contextRestored arrives within the grace window, swap the\n        // dead-end spinner for guidance pointing at the real fix.\n        clearContextRestoreWatchdog();\n        fig._contextRestoreWatchdog = setTimeout(function () {\n            fig._contextRestoreWatchdog = null;\n            // Telemetry: a loss that never recovered. Lets us measure in production\n            // how often a context loss is terminal vs transient (e.g. user 715's\n            // device, where contextRestored never fires).\n            trackContextEvent('contextLostUnrecovered', 'main', 'createFigure:watchdogUnrecovered');\n            showContextLossOverlay(UNRECOVERED_HEADING, UNRECOVERED_DETAIL, true, false);\n        }, CONTEXT_RESTORE_GRACE_MS);\n    });\n    fig.notifications.add('contextRestored', function () {\n        clearContextRestoreWatchdog();\n        trackContextEvent('contextRestored', 'main', 'createFigure:contextRestored');\n        // FigureOne hides the overlay on restore, but reset our custom content too\n        var msg = fig.lostContextMessage;\n        if (msg) {\n            msg.style.display = 'none';\n            msg.innerHTML = '';\n        }\n    });\n    // Debug helpers for exercising the context-loss flow from the browser\n    // console. Harmless in production — they only fire when invoked.\n    //\n    //   figure.debugLoseContext()  — triggers a real webglcontextlost\n    //     event. Our contextLost handler shows the overlay.\n    //\n    //   figure.debugRestoreContext()  — triggers a real webglcontextrestored\n    //     event. The contextRestored handler hides the overlay; the user\n    //     continues with their question state intact.\n    fig.debugLoseContext = function () {\n        if (typeof fig.loseContext === 'function') {\n            fig.loseContext();\n        }\n    };\n    fig.debugRestoreContext = function () {\n        if (typeof fig.restoreContext === 'function') {\n            fig.restoreContext();\n        }\n    };\n    //   figure.debugShowWebGLUnavailable()  — renders the overlay that will\n    //     show when the graceful-unavailability FigureOne release calls\n    //     onWebGLUnavailable. Reproducing the real condition (browser\n    //     refusing a WebGL context) is awkward, so this just draws the\n    //     overlay directly with the same text and button.\n    fig.debugShowWebGLUnavailable = function () {\n        showContextLossOverlay('Your browser is running low on resources.', 'Try reloading the page, closing other tabs, or switching browsers.', true, false);\n    };\n    //   figure.debugShowBornDead()  — renders the overlay shown when the GL\n    //     context is non-functional at construction (MAX_TEXTURE_SIZE empty),\n    //     seen cross-browser on wedged macOS GPUs.\n    fig.debugShowBornDead = function () {\n        showContextLossOverlay(BORN_DEAD_HEADING, BORN_DEAD_DETAIL, true, false);\n    };\n    //   figure.debugShowContextLostUnrecovered()  — renders the escalated\n    //     overlay shown when a contextLost is not followed by contextRestored\n    //     within the grace window (the dead-end-spinner replacement).\n    fig.debugShowContextLostUnrecovered = function () {\n        showContextLossOverlay(UNRECOVERED_HEADING, UNRECOVERED_DETAIL, true, false);\n    };\n    // The figure can draw the question before its setup publishes 'ready'.\n    // Clear the page indicator once a frame contains a visible question form.\n    var firstContentDrawId = fig.notifications.add('afterDraw', function () {\n        var content = ['expression', 'instruction', 'message'];\n        if (content.some(function (name) {\n            var _a;\n            var element = fig.get(name);\n            return (element === null || element === void 0 ? void 0 : element.isShown) && Boolean((_a = element.eqn) === null || _a === void 0 ? void 0 : _a.currentForm);\n        })) {\n            removePageLoading();\n            fig.notifications.remove('afterDraw', firstContentDrawId);\n        }\n    });\n    fig.notifications.add('ready', function () {\n        window.__figure_ready = new Date().getTime();\n        // Backstop for questions whose first content draw was not detected.\n        removePageLoading();\n        fig.notifications.remove('afterDraw', firstContentDrawId);\n        var elem = fig.get('expression');\n        if (elem) {\n            elem.jiggleManipulativesIcon = function () {\n                var manipulativesIcon = document.getElementById('workPad_container');\n                if (manipulativesIcon) {\n                    manipulativesIcon.classList.remove('manipulatives_icon_pulse');\n                    manipulativesIcon.offsetWidth;\n                    manipulativesIcon.classList.add('manipulatives_icon_pulse');\n                }\n            };\n        }\n    });\n    fig.answerChanged = function (params) {\n        if (fig.helper) {\n            fig.helper.answerChanged(params);\n        }\n    };\n    fig.custom.keyboard = 'enabled';\n    // Background setup\n    if (config.backgroundType === 'msg') {\n        var container = document.getElementById('figureOneContainer');\n        if (container) {\n            container.style.background = 'none';\n        }\n        var mainElement = document.getElementById('main');\n        if (mainElement != null) {\n            mainElement.classList.add('interstitial_message_background');\n        }\n    }\n    else {\n        var container = document.getElementById('figureOneContainer');\n        if (container) {\n            // var() so the brand's stylesheet owns the colour: heliomath_tokens.css\n            // defines --figure-surface, and any brand without it falls back to the\n            // literal below, so Grokkoli is unchanged. Set inline because that is\n            // what the interstitial branch toggles against.\n            container.style.background = 'var(--figure-surface, #f6f7f7)';\n        }\n    }\n    window.stopHelper = function () { };\n    fig.custom.reload = function () {\n        // A redirect (e.g. a tutorial \"Try it\" returning to its tutorial) is a full page\n        // load, so it wins over forceReload, which would otherwise reload /question/.\n        // Servers send it with or without a leading slash ('/instruction_mode/').\n        if (fig.custom.reloadRedirect != null) {\n            window.location.href = \"\".concat(window.location.origin, \"/\").concat(fig.custom.reloadRedirect.replace(/^\\/+/, ''));\n        }\n        else if (fig.custom.forceReload) {\n            window.location.reload();\n        }\n        else {\n            window.FigTools.transitionToNextQuestion();\n        }\n    };\n    fig.custom.helpers = {\n        unsnapAllTiles: window.FigTools.unsnapAllTiles,\n        showElement: window.FigTools.showElement,\n        hideElement: window.FigTools.hideElement,\n    };\n    fig.custom.cancelFontLoading = function () {\n        if (fig.fonts.checkTimer != null) {\n            clearTimeout(fig.fonts.checkTimer);\n            fig.fonts.checkTimer = null;\n        }\n    };\n    fig.custom.throwException = function () {\n        var excepter = fig.add({\n            name: 'excepter',\n            make: 'rectangle',\n            width: 0.1,\n            height: 0.1,\n            color: [1, 0, 0, 1],\n        });\n        excepter.setTouchable();\n        excepter.notifications.add('onClick', function () {\n            throw new Error('Manual exception thrown');\n        });\n    };\n    fig.custom.backgroundGesture = fig.add({\n        make: 'rectangle',\n        width: fig.getScene().widthNear,\n        height: fig.getScene().heightNear,\n        color: [0, 0, 0, 0],\n    });\n    fig.custom.backgroundGestureCallback = null;\n    fig.custom.backgroundGesture.notifications.add('onClick', function () {\n        if (fig.custom.backgroundGestureCallback) {\n            fig.custom.backgroundGestureCallback();\n        }\n    });\n    fig.custom.backgroundGesture.hide();\n    fig.custom.getSpeechStats = function () {\n        var playCount = 0;\n        var playDuration = 0;\n        var completeCount = 0;\n        if (fig.speechManager != null && fig.speechManager.startCount > 0) {\n            playCount = fig.speechManager.startCount;\n            completeCount = fig.speechManager.completeCount;\n            playDuration = round(fig.speechManager.getPlayDuration(), 1);\n        }\n        else if (fig.speech != null && fig.speech.startCount > 0) {\n            playCount = fig.speech.startCount;\n            completeCount = fig.speech.completeCount;\n            playDuration = round(fig.speech.getPlayDuration(), 1);\n        }\n        return [playCount, completeCount, playDuration];\n    };\n    fig.custom.dullBrain = function () {\n        var brain = document.getElementById('ghelp_grokkoli');\n        if (brain) {\n            brain.style.opacity = '0.5';\n        }\n    };\n    fig.custom.undullBrain = function () {\n        var brain = document.getElementById('ghelp_grokkoli');\n        if (brain) {\n            brain.style.opacity = '1';\n        }\n    };\n    fig.custom.dullHelp = function () {\n        var helpIcons = document.getElementsByClassName('ghelp_icon_container');\n        for (var i = 0; i < helpIcons.length; i += 1) {\n            helpIcons[i].style.opacity = '0.5';\n        }\n        var helpLine = document.getElementById('ghelp_menu_line');\n        if (helpLine) {\n            helpLine.style.opacity = '0.25';\n        }\n    };\n    fig.custom.undullHelp = function () {\n        var helpIcons = document.getElementsByClassName('ghelp_icon_container');\n        for (var i = 0; i < helpIcons.length; i += 1) {\n            helpIcons[i].style.opacity = '1';\n        }\n        var helpLine = document.getElementById('ghelp_menu_line');\n        if (helpLine) {\n            helpLine.style.opacity = '1';\n        }\n    };\n    fig.custom.getTileSeparation = function () {\n        var bottomY = 1.5;\n        Object.keys(expression.elements).forEach(function (key) {\n            var tile = expression.elements[key];\n            if (tile.custom.arrangeTile\n                || tile.custom.manipulativeType === 'manipulative_tile'\n                || tile.custom.manipulativeType === 'simple_block'\n                || tile.custom.manipulativeType === 'linear_blocks') {\n                bottomY = Math.min(bottomY, tile.getBoundingRect('figure').bottom);\n            }\n        });\n        var ai = fig.elements._answer_input_arrange;\n        ai.showAll();\n        var topAnswerInput = ai.getBoundingRect('figure').top;\n        var delta = bottomY - topAnswerInput;\n        return delta;\n    };\n    fig.custom.flashDisabled = function () {\n        var mainElement = document.getElementById('main');\n        if (mainElement != null) {\n            mainElement.classList.contains('interstitial_message_background');\n            return;\n        }\n        var figureOneContainer = document.getElementById('figureOneContainer');\n        if (figureOneContainer) {\n            figureOneContainer.classList.remove('flash-disabled');\n            figureOneContainer.offsetWidth;\n            figureOneContainer.classList.add('flash-disabled');\n        }\n        var mainContainer = document.getElementById('main');\n        if (mainContainer) {\n            mainContainer.classList.remove('flash-disabled');\n            mainContainer.offsetWidth;\n            mainContainer.classList.add('flash-disabled');\n        }\n    };\n    fig.custom.disableInteractionCallbacks = [];\n    fig.custom.enableInteractionCallbacks = [];\n    fig.custom.disableInteraction = function (callback) {\n        if (callback === void 0) { callback = null; }\n        if (fig.custom.disabled) {\n            return;\n        }\n        if (window._grokkoli_silent_log) {\n            window._grokkoli_silent_log('disable');\n        }\n        else {\n            console.log('disable');\n        }\n        fig.custom.backgroundGesture.show();\n        fig.custom.backgroundGestureCallback = function () {\n            fig.custom.flashDisabled();\n            if (callback) {\n                callback();\n            }\n        };\n        fig.custom.disabled = true;\n        var elements = fig.elements.getAllElements();\n        for (var i = 0; i < elements.length; i += 1) {\n            if (!elements[i].isShown) {\n                continue;\n            }\n            elements[i].custom.wasDisabled = {\n                isTouchable: elements[i].isTouchable,\n                isMovable: elements[i].isMovable,\n                disabled: true,\n            };\n            if (elements[i].custom.canBeDisabled == null\n                || elements[i].custom.canBeDisabled === true) {\n                if (elements[i].isTouchable) {\n                    elements[i].isTouchable = false;\n                }\n                if (elements[i].isMovable) {\n                    elements[i].isMovable = false;\n                }\n                if (elements[i].custom.disabled !== true && elements[i].custom.disableInteraction) {\n                    elements[i].custom.disabled = true;\n                    elements[i].custom.disableInteraction();\n                }\n            }\n        }\n        fig.custom.backgroundGesture.isTouchable = true;\n        for (var i = 0; i < fig.custom.disableInteractionCallbacks.length; i += 1) {\n            fig.custom.disableInteractionCallbacks[i]();\n        }\n    };\n    fig.fonts.notifications.add('fontsLoaded', function () {\n        contextState.lastFontsLoadedAt = performance.now();\n        if (fig.custom.willBeEnabled) {\n            // console.log('will be enabled');\n        }\n        else if (fig.custom.disabled) {\n            fig.custom.enableInteraction();\n            fig.custom.disableInteraction();\n        }\n    });\n    fig.custom.enableInteraction = function () {\n        if (window._grokkoli_silent_log) {\n            window._grokkoli_silent_log('enable');\n        }\n        else {\n            console.log('enable');\n        }\n        fig.elements.setOpacity(1);\n        fig.custom.undullBrain();\n        fig.custom.undullHelp();\n        fig.custom.disabled = false;\n        var elements = fig.elements.getAllElements();\n        for (var i = 0; i < elements.length; i += 1) {\n            if (elements[i].custom.wasDisabled != null) {\n                elements[i].isTouchable = elements[i].custom.wasDisabled.isTouchable;\n                elements[i].isMovable = elements[i].custom.wasDisabled.isMovable;\n                if (elements[i].custom.disabled && elements[i].custom.enableInteraction) {\n                    elements[i].custom.disabled = false;\n                    elements[i].custom.enableInteraction();\n                }\n            }\n        }\n        for (var i = 0; i < fig.custom.enableInteractionCallbacks.length; i += 1) {\n            fig.custom.enableInteractionCallbacks[i]();\n        }\n        fig.custom.backgroundGestureCallback = null;\n        fig.custom.backgroundGesture.hide();\n        fig.custom.backgroundGesture.isTouchable = false;\n    };\n    fig.custom.disableBackgroundGesture = function () {\n        fig.custom.backgroundGestureCallback = null;\n        fig.custom.backgroundGesture.hide();\n        fig.custom.backgroundGesture.isTouchable = false;\n    };\n    fig.custom.jiggleGrokkoli = function () {\n        var grokkoliElement = document.getElementById('ghelp_grokkoli');\n        if (grokkoliElement) {\n            grokkoliElement.classList.remove('speaker_pulse');\n            grokkoliElement.offsetWidth;\n            grokkoliElement.classList.add('speaker_pulse');\n        }\n    };\n    window.addEventListener('focus', function () {\n        setTimeout(function () {\n            fig.elements.clear();\n            fig.animateNextFrame();\n        }, 10);\n    });\n    // Global aliases for functions called from YAML\n    window.createBadge = window.FigTools.createBadge;\n    window.createHoningBadges = window.FigTools.createHoningBadges;\n    window.createSessionSummary = window.FigTools.createSessionSummary;\n    window.showKeyboard = window.FigTools.showKeyboard;\n}\n","/**\n * Touch-style cursor for recording tutorial clips (dev only).\n *\n * Replaces the native mouse pointer with a translucent circle that follows the\n * mouse and gets smaller and darker while the button is held, so a screen recording of a\n * question shows a \"finger tap\" like the one learners make on a tablet rather\n * than an arrow. Used for the animated clips on /tutorials/answer_mechanics.\n *\n *   cursor()          toggle\n *   cursor(true)      on;  cursor(false) off\n *   cursor(60)        on, with a 60px diameter (default 44)\n *   ?touch_cursor=1   on for this browser (=0 off), on any question page URL\n *\n * The choice and size are kept in localStorage so they survive reloads, question\n * transitions and the Try-it redirect from /tutorials/ (which lands on\n * /question/ with no query string). Only available when the server reports a\n * local environment (window.__isLocal, set in alpha_base.html); anywhere else\n * every entry point is a no-op and nothing is added to the page.\n */\nexport var STORAGE_KEY = '_grokkoli_touch_cursor';\nexport var SIZE_KEY = '_grokkoli_touch_cursor_size';\nexport var QUERY_PARAM = 'touch_cursor';\nexport var CURSOR_ID = 'touch-cursor';\nvar STYLE_ID = 'touch-cursor-style';\nvar ROOT_CLASS = 'touch-cursor';\nexport var DEFAULT_SIZE = 44;\nvar CSS = \"\\nhtml.\".concat(ROOT_CLASS, \", html.\").concat(ROOT_CLASS, \" * { cursor: none !important; }\\n#\").concat(CURSOR_ID, \" {\\n  position: fixed;\\n  left: 0;\\n  top: 0;\\n  transform: translate(-50%, -50%);\\n  border-radius: 50%;\\n  background: rgba(40, 40, 40, 0.75);\\n  pointer-events: none;\\n  z-index: 2147483647;\\n  visibility: hidden;\\n  transition: transform 80ms ease-out, background-color 80ms ease-out;\\n}\\n#\").concat(CURSOR_ID, \".visible { visibility: visible; }\\n#\").concat(CURSOR_ID, \".pressed {\\n  transform: translate(-50%, -50%) scale(0.7);\\n  background: rgba(40, 40, 40, 0.9);\\n}\\n\");\nvar listeners = [];\nfunction cursorElement() {\n    return document.getElementById(CURSOR_ID);\n}\nexport function isLocalEnvironment() {\n    return window.__isLocal === true;\n}\nfunction readStored() {\n    try {\n        return localStorage.getItem(STORAGE_KEY) === '1';\n    }\n    catch (_a) {\n        return false;\n    }\n}\nfunction writeStored(on) {\n    try {\n        if (on) {\n            localStorage.setItem(STORAGE_KEY, '1');\n        }\n        else {\n            localStorage.removeItem(STORAGE_KEY);\n        }\n    }\n    catch (_a) {\n        /* localStorage unavailable - applies to this page only */\n    }\n}\nfunction readSize() {\n    try {\n        var size = Number(localStorage.getItem(SIZE_KEY));\n        return size > 0 ? size : DEFAULT_SIZE;\n    }\n    catch (_a) {\n        return DEFAULT_SIZE;\n    }\n}\nfunction writeSize(size) {\n    try {\n        localStorage.setItem(SIZE_KEY, String(size));\n    }\n    catch (_a) {\n        /* localStorage unavailable - applies to this page only */\n    }\n}\nfunction applySize(el, size) {\n    el.style.width = \"\".concat(size, \"px\");\n    el.style.height = \"\".concat(size, \"px\");\n}\n// Capture phase: the on-screen keyboard (answerInputs/keyboard.ts,\n// equationInput.ts) stops propagation of mousedown on its keys, which would\n// otherwise never reach a bubbling listener on document.\nvar LISTEN_OPTIONS = { capture: true, passive: true };\nfunction listen(event, handler) {\n    document.addEventListener(event, handler, LISTEN_OPTIONS);\n    listeners.push([event, handler]);\n}\nfunction enable() {\n    if (cursorElement())\n        return;\n    var style = document.createElement('style');\n    style.id = STYLE_ID;\n    style.textContent = CSS;\n    document.head.appendChild(style);\n    var el = document.createElement('div');\n    el.id = CURSOR_ID;\n    el.setAttribute('aria-hidden', 'true');\n    applySize(el, readSize());\n    document.body.appendChild(el);\n    document.documentElement.classList.add(ROOT_CLASS);\n    listen('mousemove', function (e) {\n        var _a = e, clientX = _a.clientX, clientY = _a.clientY;\n        el.style.left = \"\".concat(clientX, \"px\");\n        el.style.top = \"\".concat(clientY, \"px\");\n        el.classList.add('visible');\n    });\n    listen('mousedown', function () { return el.classList.add('pressed'); });\n    listen('mouseup', function () { return el.classList.remove('pressed'); });\n    // Leaving the browser window: mouseout with no relatedTarget.\n    listen('mouseout', function (e) {\n        if (e.relatedTarget == null) {\n            el.classList.remove('visible', 'pressed');\n        }\n    });\n}\nfunction disable() {\n    listeners.forEach(function (_a) {\n        var event = _a[0], handler = _a[1];\n        return document.removeEventListener(event, handler, LISTEN_OPTIONS);\n    });\n    listeners = [];\n    document.documentElement.classList.remove(ROOT_CLASS);\n    var el = cursorElement();\n    if (el)\n        el.remove();\n    var style = document.getElementById(STYLE_ID);\n    if (style)\n        style.remove();\n}\nexport function isTouchCursorOn() {\n    return cursorElement() != null;\n}\n/** Current diameter in px (the remembered size, whether or not the cursor is on). */\nexport function getTouchCursorSize() {\n    return readSize();\n}\n/** Set the diameter in px and remember it; applies at once if the cursor is on. */\nexport function setTouchCursorSize(size) {\n    if (!isLocalEnvironment() || !(size > 0))\n        return readSize();\n    writeSize(size);\n    var el = cursorElement();\n    if (el)\n        applySize(el, size);\n    return size;\n}\n/** Turn the touch cursor on or off and remember the choice. Returns the new state. */\nexport function setTouchCursor(on) {\n    if (!isLocalEnvironment())\n        return false;\n    writeStored(on);\n    if (on) {\n        enable();\n    }\n    else {\n        disable();\n    }\n    return on;\n}\n/**\n * Page-level setup, run once when the page's figure is created. Applies a\n * ?touch_cursor=1|0 query param (then strips it from the URL, like\n * ?disable_webgl in createFigure.ts) and restores the remembered state.\n */\nexport function setupTouchCursor() {\n    if (!isLocalEnvironment())\n        return;\n    var params = new URLSearchParams(window.location.search);\n    var fromQuery = params.get(QUERY_PARAM);\n    if (fromQuery === '1' || fromQuery === '0') {\n        writeStored(fromQuery === '1');\n        params.delete(QUERY_PARAM);\n        var qs = params.toString();\n        var newUrl = window.location.pathname + (qs ? \"?\".concat(qs) : '') + window.location.hash;\n        window.history.replaceState(null, '', newUrl);\n    }\n    if (readStored()) {\n        enable();\n    }\n    else {\n        disable();\n    }\n}\n/**\n * Register the cursor() console helper (dev only).\n *   cursor()        toggle;  cursor(true | false)  on / off\n *   cursor(60)      on, with a 60px diameter\n */\nexport function installCursorHelper() {\n    if (!isLocalEnvironment())\n        return;\n    window.cursor = function (arg) {\n        var next;\n        if (typeof arg === 'number') {\n            if (!(arg > 0)) {\n                // eslint-disable-next-line no-console\n                console.log(\"cursor(size): size must be a positive number of pixels (currently \".concat(readSize(), \"px)\"));\n                return isTouchCursorOn();\n            }\n            setTouchCursorSize(arg);\n            next = setTouchCursor(true);\n        }\n        else {\n            next = setTouchCursor(arg === undefined ? !isTouchCursorOn() : !!arg);\n        }\n        // eslint-disable-next-line no-console\n        console.log(\"touch cursor \".concat(next ? \"on, \".concat(readSize(), \"px\") : 'off', \" (remembered for this browser; cursor(false) turns it off, cursor(60) sets the size)\"));\n        return next;\n    };\n}\n","/**\n * Console helpers for manually exercising failure modes in the browser.\n *\n *   ba(mode, target?)  break audio: speech mp3 / marks / speech_urls fetches\n *   bw(mode?)          break workpad: make the workpad figure fail to build\n *\n * Run `ba('help')` for the list of modes. A `ba` mode persists across page\n * reloads (sessionStorage) so first-load failures such as the pre-guide can\n * be reproduced; `ba('off')` clears it.\n *\n * Harmless in production: nothing changes until one of these is called.\n */\nvar STORAGE_KEY = 'grokkoli_break_audio';\nvar MODES = {\n    off: 'restore normal fetching',\n    hang: 'every attempt hangs until its timeout -> \"Speech fetch hung\"',\n    network: 'every attempt fails at once (TypeError) -> \"exhausted [network, ...]\"',\n    mixed: 'hang, network, hang... (the 2026-09-28 production pattern) -> \"exhausted [timeout, network, timeout]\"',\n    500: 'server error on every attempt (retried) -> \"exhausted [status_500, ...]\"',\n    404: 'not found (not retried) -> \"exhausted [status_404]\" after one attempt',\n    body: 'headers arrive, then the body stream fails -> \"exhausted [body, ...]\"',\n    garbage: '200 with junk bytes -> audio decode error / marks parse error',\n    once: 'first attempt fails (network), the retry succeeds -> succeeded_on_attempt_2',\n    slow: 'each response is delayed 6s (past the 3s first-attempt cap) then succeeds',\n    flaky: 'each attempt fails (network) with 50% probability',\n};\nvar TARGETS = {\n    both: 'mp3 and marks files (default)',\n    audio: 'mp3 files only',\n    marks: 'marks files only',\n    urls: 'the /speech_urls/ POST (goes through request(): retries, loading screen, timeout overlay)',\n};\nvar state = null;\nvar originalFetch = null;\nvar onceSeen = new Set();\nvar mixedCount = 0;\nfunction readStored() {\n    try {\n        var raw = window.sessionStorage.getItem(STORAGE_KEY);\n        return raw ? JSON.parse(raw) : null;\n    }\n    catch (_a) {\n        return null;\n    }\n}\nfunction store(s) {\n    try {\n        if (s == null) {\n            window.sessionStorage.removeItem(STORAGE_KEY);\n        }\n        else {\n            window.sessionStorage.setItem(STORAGE_KEY, JSON.stringify(s));\n        }\n    }\n    catch (_a) {\n        // Private mode / blocked storage: the mode still applies to this page.\n    }\n}\nfunction urlOf(input) {\n    if (typeof input === 'string')\n        return input;\n    if (input instanceof URL)\n        return input.href;\n    return input.url;\n}\nfunction matches(url, target) {\n    var path = url;\n    try {\n        path = new URL(url, window.location.href).pathname;\n    }\n    catch (_a) {\n        // Use the raw string.\n    }\n    var isAudio = /\\.mp3$/i.test(path);\n    var isMarks = /\\.marks$/i.test(path);\n    switch (target) {\n        case 'audio': return isAudio;\n        case 'marks': return isMarks;\n        case 'urls': return path.indexOf('/speech_urls/') >= 0;\n        default: return isAudio || isMarks;\n    }\n}\nfunction networkError() {\n    return Promise.reject(new TypeError('Failed to fetch (simulated by ba())'));\n}\n// Never settles on its own; rejects like a real fetch when its signal aborts.\nfunction hang(init) {\n    return new Promise(function (_resolve, reject) {\n        var signal = init === null || init === void 0 ? void 0 : init.signal;\n        if (signal == null)\n            return;\n        var abort = function () {\n            var err = new Error('signal is aborted without reason');\n            err.name = 'AbortError';\n            reject(err);\n        };\n        if (signal.aborted)\n            abort();\n        else\n            signal.addEventListener('abort', abort);\n    });\n}\nfunction status(code) {\n    return Promise.resolve(new Response('', {\n        status: code,\n        statusText: code === 404 ? 'Not Found' : 'Internal Server Error',\n    }));\n}\nfunction brokenBody() {\n    if (typeof ReadableStream === 'undefined')\n        return networkError();\n    var stream = new ReadableStream({\n        start: function (controller) {\n            controller.error(new TypeError('network error (simulated by ba())'));\n        },\n    });\n    return Promise.resolve(new Response(stream, { status: 200 }));\n}\nfunction breakFetch(input, init, real) {\n    var s = state;\n    var url = urlOf(input);\n    switch (s.mode) {\n        case 'hang': return hang(init);\n        case 'network': return networkError();\n        case 'mixed':\n            mixedCount += 1;\n            return mixedCount % 2 === 1 ? hang(init) : networkError();\n        case '500': return status(500);\n        case '404': return status(404);\n        case 'body': return brokenBody();\n        case 'garbage':\n            return Promise.resolve(new Response('not audio, not marks', { status: 200 }));\n        case 'once':\n            if (onceSeen.has(url))\n                return real(input, init);\n            onceSeen.add(url);\n            return networkError();\n        case 'slow':\n            return new Promise(function (resolve, reject) {\n                var _a;\n                var timer = setTimeout(function () { return real(input, init).then(resolve, reject); }, 6000);\n                (_a = init === null || init === void 0 ? void 0 : init.signal) === null || _a === void 0 ? void 0 : _a.addEventListener('abort', function () {\n                    clearTimeout(timer);\n                    var err = new Error('signal is aborted without reason');\n                    err.name = 'AbortError';\n                    reject(err);\n                });\n            });\n        case 'flaky':\n            return Math.random() < 0.5 ? networkError() : real(input, init);\n        default:\n            return real(input, init);\n    }\n}\nfunction installFetchWrapper() {\n    if (originalFetch != null)\n        return;\n    originalFetch = window.fetch.bind(window);\n    var real = originalFetch;\n    window.fetch = (function (input, init) {\n        if (state != null && matches(urlOf(input), state.target)) {\n            return breakFetch(input, init, real);\n        }\n        return real(input, init);\n    });\n}\nfunction printHelp() {\n    // One block, every mode x target spelled out, so any line can be copied\n    // straight into the console.\n    var targets = Object.keys(TARGETS);\n    var lines = ['ba(mode, target) - break speech fetching', ''];\n    lines.push('Targets:');\n    targets.forEach(function (t) { return lines.push(\"  '\".concat(t, \"'\").concat(' '.repeat(7 - t.length)).concat(TARGETS[t])); });\n    lines.push('  (no target = \\'both\\')', '');\n    Object.keys(MODES).filter(function (m) { return m !== 'off'; }).forEach(function (m) {\n        lines.push(\"\".concat(m, \": \").concat(MODES[m]));\n        lines.push(\"  ba('\".concat(m, \"')\"));\n        targets.forEach(function (t) { return lines.push(\"  ba('\".concat(m, \"', '\").concat(t, \"')\")); });\n        lines.push('');\n    });\n    lines.push('ba(\\'off\\')  restore normal fetching');\n    lines.push('ba(\\'help\\') or ba()  show this list', '');\n    lines.push('A mode persists across reloads until ba(\\'off\\'). Speech already loaded for');\n    lines.push('the current question is not refetched - open a new question (or reload).', '');\n    lines.push('bw()          the next workpad build fails');\n    lines.push('bw(\\'always\\')  every workpad build fails');\n    lines.push('bw(\\'off\\')     workpad builds work again', '');\n    lines.push(\"Current: \".concat(state ? \"ba('\".concat(state.mode, \"', '\").concat(state.target, \"')\") : 'off'));\n    // eslint-disable-next-line no-console\n    console.log(lines.join('\\n'));\n}\nfunction ba(mode, target) {\n    if (target === void 0) { target = 'both'; }\n    /* eslint-disable no-console */\n    if (mode == null || mode === 'help') {\n        printHelp();\n        return;\n    }\n    var m = String(mode);\n    if (m === 'off') {\n        state = null;\n        store(null);\n        console.log('ba: speech fetching restored');\n        return;\n    }\n    if (MODES[m] == null) {\n        console.log(\"ba: unknown mode '\".concat(m, \"'\"));\n        printHelp();\n        return;\n    }\n    if (TARGETS[target] == null) {\n        console.log(\"ba: unknown target '\".concat(target, \"'\"));\n        printHelp();\n        return;\n    }\n    installFetchWrapper();\n    state = { mode: m, target: target };\n    onceSeen.clear();\n    mixedCount = 0;\n    store(state);\n    console.log(\"ba: \".concat(target, \" -> \").concat(MODES[m], \" (persists across reloads; ba('off') to restore)\"));\n    /* eslint-enable no-console */\n}\nfunction bw(mode) {\n    if (mode === void 0) { mode = 'once'; }\n    /* eslint-disable no-console */\n    if (mode === 'off') {\n        window.__grokkoliBreakWorkPad = null;\n        console.log('bw: workpad builds restored');\n        return;\n    }\n    window.__grokkoliBreakWorkPad = mode;\n    console.log(mode === 'always'\n        ? 'bw: every workpad build will fail'\n        : 'bw: the next workpad build will fail - open the workpad (or load a question with one)');\n    /* eslint-enable no-console */\n}\n/** Register `ba` / `bw` on window and re-apply a persisted `ba` mode. */\nfunction installBreakTools() {\n    if (window.ba === ba)\n        return;\n    window.ba = ba;\n    window.bw = bw;\n    var stored = readStored();\n    if (stored != null && MODES[stored.mode] != null && stored.mode !== 'off') {\n        installFetchWrapper();\n        state = stored;\n        // eslint-disable-next-line no-console\n        console.log(\"ba: '\".concat(stored.mode, \"' on \").concat(stored.target, \" is active (from an earlier ba() call) - ba('off') to restore\"));\n    }\n}\nexport { installBreakTools, ba, bw };\n","var __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nvar __generator = (this && this.__generator) || function (thisArg, body) {\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === \"function\" ? Iterator : Object).prototype);\n    return g.next = verb(0), g[\"throw\"] = verb(1), g[\"return\"] = verb(2), typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n    function verb(n) { return function (v) { return step([n, v]); }; }\n    function step(op) {\n        if (f) throw new TypeError(\"Generator is already executing.\");\n        while (g && (g = 0, op[0] && (_ = 0)), _) try {\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n            if (y = 0, t) op = [op[0] & 2, t.value];\n            switch (op[0]) {\n                case 0: case 1: t = op; break;\n                case 4: _.label++; return { value: op[1], done: false };\n                case 5: _.label++; y = op[1]; op = [0]; continue;\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\n                default:\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                    if (t[2]) _.ops.pop();\n                    _.trys.pop(); continue;\n            }\n            op = body.call(thisArg, _);\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n    }\n};\nimport createFigure from './createFigure';\nimport { setSpeechToken } from '../tools/speech_token';\nimport { stampInlineSpeechConfig } from '../tools/inlineSpeech';\nimport { resetKeyboardViewport } from './keyboardViewport';\nimport { createDontKnowController } from './helper/dontKnowController';\nimport createEquation from './createEquation';\nimport setupAutoCenter from './autoCenter';\nimport { questionMain } from './main/questionMain';\nimport { joinObjects } from './tools/joinObjects';\nimport finalizeQuestion from './finalizeQuestion';\nimport { teardownNearTouch } from './manipulatives/addManipulative';\nimport { getAnyAnswerInput, showAnswerInput } from './tools/getAnswerInput';\nimport continueFadeIn from './continueFadeIn';\nimport { clearAllTimers } from './timer';\nimport { flushAllTimeouts } from './tools/flushTimeouts';\nimport clearTextCanvas from './tools/clearTextCanvas';\nimport { incrementQuestionsSinceLoad, setTeardownTime, setBringupTime } from './answer/getPerformance';\nimport { recordWebGLBreadcrumb } from './request/webglDiagnostics';\nimport { resetQuestionZoomTelemetry } from './tools/sceneZoomTelemetry';\nimport request, { logError } from './request/request';\nimport { destroyWorkPadFigure } from './workpad_new/safeWorkPad';\nimport { installBreakTools } from './debug/breakTools';\nimport { removeConsoleHelpers } from './debug/consoleHelpers';\nimport { flushSync } from 'react-dom';\nimport { getPointerType } from '../tools/pointerType';\nimport { createTapFinger } from './tools/tapFinger';\nimport { audioRuns, lockInteraction, releaseTraining, removeTrainingPlay, waitForTrainingPlay, } from './tools/trainingPlay';\n// Managed timeout registry.  Content JS (YAML `js` blocks) calls\n// gSetTimeout(key, fn, delay) instead of raw setTimeout.  Teardown\n// clears every entry, so stale callbacks never fire after a question\n// transition.\nvar _gTimeouts = {};\nwindow.gSetTimeout = function (key, fn, delay) {\n    if (key in _gTimeouts)\n        clearTimeout(_gTimeouts[key]);\n    var id = setTimeout(fn, delay);\n    _gTimeouts[key] = id;\n    return id;\n};\nwindow.gClearTimeout = function (key) {\n    if (key in _gTimeouts) {\n        clearTimeout(_gTimeouts[key]);\n        delete _gTimeouts[key];\n    }\n};\nexport var POLL_MS = 500;\n// Ticks to wait for playback to start before declaring a no-start.\n//\n// This is a BACKSTOP, not a measure of how long a load should take.\n// speech.ts's play() arms a stall watchdog (INITIAL_LOAD_THRESHOLD_MS =\n// 10s) that already owns the hung-load case: it aborts the load, calls\n// playFinished() — which fires our callback3 and resolves us — and logs a\n// diagnostic carrying the chunk index and threshold this poll can't see.\n// So the deadline here sits past the watchdog, and only fires if the\n// watchdog never armed.\n//\n// It must stay well clear of normal load time.  The pipeline behind\n// isPlaying is speech_urls + S3 mp3 fetch + decode + playChunk; production\n// telemetry has a ~1.5s median and a ~3.3s p90 on tablets.  The previous\n// 4-tick (2s) deadline sat below the p73, so roughly a quarter of healthy\n// pre-guides were reported as failures — and firing here is destructive,\n// not just noisy: resolving lets the caller move on and call play() for the\n// next speech, and play() calls stop(), killing the audio that was about to\n// start.\nexport var NO_START_TICKS = 24; // 12s\n/**\n * Best-effort description of where a speech's audio is stuck, for the\n * no-start diagnostic.  Mirrors the chunk/audio shape speech.ts builds.\n */\nfunction speechLoadState(fig, speechId) {\n    var _a, _b, _c, _d, _e;\n    var chunks = (_a = fig.chunkedSpeech) === null || _a === void 0 ? void 0 : _a[speechId];\n    if (!Array.isArray(chunks) || chunks.length === 0)\n        return 'no-chunks';\n    var chunk = (_d = chunks[(_c = (_b = fig.speechManager) === null || _b === void 0 ? void 0 : _b.chunkIndex) !== null && _c !== void 0 ? _c : 0]) !== null && _d !== void 0 ? _d : chunks[0];\n    if ((chunk === null || chunk === void 0 ? void 0 : chunk.audio) == null)\n        return 'no-audio';\n    return (_e = chunk.audio.state) !== null && _e !== void 0 ? _e : 'unknown';\n}\nexport function playSpeechAndWait(fig, speechId, onStarted) {\n    return new Promise(function (resolve) {\n        var _a, _b, _c;\n        if (!((_a = fig.chunkedSpeech) === null || _a === void 0 ? void 0 : _a[speechId])) {\n            resolve('failed');\n            return;\n        }\n        // isPlaying is set while a chunk waits on its delay or its download, so\n        // the audio has started only once playChunk says this speech's has. A\n        // speech that replaced it (e.g. the learner pressed the speaker while it\n        // downloaded) starting isn't this one starting.\n        var started = false;\n        var start = function () {\n            if (started)\n                return;\n            started = true;\n            onStarted === null || onStarted === void 0 ? void 0 : onStarted();\n        };\n        var startSub = (_c = (_b = fig.notifications) === null || _b === void 0 ? void 0 : _b.add) === null || _c === void 0 ? void 0 : _c.call(_b, 'speechAudioStarted', function (id) {\n            if (id === speechId)\n                start();\n        });\n        var resolved = false;\n        var done = function (outcome) {\n            if (resolved)\n                return;\n            resolved = true;\n            clearInterval(poll);\n            if (startSub != null)\n                fig.notifications.remove('speechAudioStarted', startSub);\n            if (outcome === 'completed')\n                start();\n            fig.speechManager.playFinishedCallback3 = null;\n            resolve(outcome);\n        };\n        // play() doesn't clear callback3 when superseding, so a different speech\n        // finishing can fire this; only count it as completed if it was ours.\n        fig.speechManager.playFinishedCallback3 = function () { return done(fig.speechId === speechId ? 'completed' : 'interrupted'); };\n        // Poll: if isPlaying never becomes true or reverts to false without\n        // the callback firing (crash, missing audio, context failure), resolve.\n        // The \"pre-guide\" substring in `at` prevents js_error_report from\n        // triggering exception_fallback.\n        var startedPlaying = false;\n        var ticksSinceCall = 0;\n        var poll = setInterval(function () {\n            var _a, _b, _c, _d, _e;\n            ticksSinceCall += 1;\n            // If another play() has replaced our speech (e.g. learner answered\n            // mid pre-guide and the response triggered a guide speech), our\n            // speech has been superseded.  Resolve silently so the new speech's\n            // playFinished doesn't fire our stale callback.\n            //\n            // Caveat: there's a <500ms window between the superseding play()\n            // and the next poll tick.  If the new speech is cached and finishes\n            // in that window, its playFinished fires our stale done_A, and the\n            // promise resolves based on the wrong speech's completion.\n            // Harmless for playQuestionSpeech (the orchestration just moves on),\n            // but the real fix is to have play()/interruptPlay() null out the\n            // previous callback3 when superseding.  interruptPlay already does\n            // (speech.ts:2665); play() does not.\n            if (fig.speechId !== speechId) {\n                done('interrupted');\n                return;\n            }\n            if (fig.speechManager.isPlaying) {\n                startedPlaying = true;\n            }\n            else if (startedPlaying) {\n                // speechManager.freeze is non-null only when pause() was called\n                // (e.g. submitAnswer pauses speech when the learner answers\n                // mid-preguide).  That's not an error — resolve silently.\n                if (fig.speechManager.freeze != null) {\n                    done('interrupted');\n                    return;\n                }\n                logError({ msg: \"pre-guide speech ended without callback for \\\"\".concat(speechId, \"\\\"\"), recovered: true }, \"pre-guide poll (post-play)\");\n                done('failed');\n            }\n            else if (ticksSinceCall >= NO_START_TICKS) {\n                // Past the stall watchdog's own threshold, so it either never armed\n                // or never fired.  Report the audio/context state with it: a\n                // suspended ctx and a still-'loading' chunk are different failures.\n                logError({ msg: \"pre-guide speech never started for \\\"\".concat(speechId, \"\\\"\"), recovered: true }, \"pre-guide poll (no-start after \".concat(NO_START_TICKS * POLL_MS, \"ms, \")\n                    + \"audio=\".concat(speechLoadState(fig, speechId), \", \")\n                    + \"ctx=\".concat((_c = (_b = (_a = fig.speechManager) === null || _a === void 0 ? void 0 : _a.ctx) === null || _b === void 0 ? void 0 : _b.state) !== null && _c !== void 0 ? _c : 'none', \")\"));\n                // The question carries on without the pre-guide; point the learner\n                // at the speaker so they can try the audio again.\n                try {\n                    (_e = (_d = fig.helper) === null || _d === void 0 ? void 0 : _d.audioFailed) === null || _e === void 0 ? void 0 : _e.call(_d, true);\n                }\n                catch (_f) {\n                    // Best-effort hint only.\n                }\n                done('failed');\n            }\n        }, POLL_MS);\n        try {\n            fig.speechManager.play(speechId);\n        }\n        catch (e) {\n            logError({ msg: e.message || String(e), stack: e.stack, recovered: true }, \"pre-guide play() threw for \\\"\".concat(speechId, \"\\\"\"));\n            done('failed');\n        }\n    });\n}\n/**\n * Synchronous predicate: will auto-speak start when speech is kicked off?\n * Requires autoSpeakQuestion enabled, chunks present, the load to be within\n * the transition timeout (or forceAutoSpeak), and a running audio context.\n * The audio-ctx check is the cold-start gate: without a prior user gesture\n * the ctx is suspended here, so this returns false even though\n * playQuestionSpeech may later create one and play anyway.\n */\nfunction willAutoSpeak(config) {\n    var _a, _b, _c, _d, _e, _f;\n    var fig = window.figure;\n    if (!fig)\n        return false;\n    var isFirstLoad = loadedFirst(config);\n    var shouldAutoSpeak = isFirstLoad || !!((_a = config.learner) === null || _a === void 0 ? void 0 : _a.forceAutoSpeak);\n    var hasUsableAudioCtx = ((_c = (_b = fig.speechManager) === null || _b === void 0 ? void 0 : _b.ctx) === null || _c === void 0 ? void 0 : _c.state) === 'running';\n    var autoSpeechId = ((_d = fig.chunkedSpeech) === null || _d === void 0 ? void 0 : _d[AUTO_SPEECH_ID]) ? AUTO_SPEECH_ID : 'default';\n    return !!(((_e = config.learner) === null || _e === void 0 ? void 0 : _e.autoSpeakQuestion)\n        && ((_f = fig.chunkedSpeech) === null || _f === void 0 ? void 0 : _f[autoSpeechId])\n        && shouldAutoSpeak\n        && hasUsableAudioCtx);\n}\n/**\n * Set up the startAutoSpeak notification.  Runs synchronously after the\n * question's js block has registered its subscribers, and BEFORE\n * playQuestionSpeech (which may return early or never fire if transitions\n * don't invoke their callback).  Guarantees exactly one publish per load:\n *   - if autospeak will run, playInner consumes _pendingAutoSpeakNotification\n *     and publishes after its teardown;\n *   - otherwise (autospeak disabled / no chunks / not first load), publish\n *     immediately;\n *   - a 1s fallback timer covers the case where playInner never runs\n *     (blocked audio ctx, empty chunks, slow transitions, etc.).\n */\nfunction setupAutoSpeakNotification(config) {\n    var fig = window.figure;\n    if (!(fig === null || fig === void 0 ? void 0 : fig.notifications))\n        return;\n    var autoSpeakWillRun = willAutoSpeak(config);\n    if (autoSpeakWillRun) {\n        fig._pendingAutoSpeakNotification = true;\n        // Kept off window.__timeouts so the speech `clearTimeouts` action\n        // can't cancel the fallback before playInner consumes the pending\n        // flag.  Cleared explicitly in teardownQuestion.\n        fig._autoSpeakFallbackId = setTimeout(function () {\n            fig._autoSpeakFallbackId = null;\n            if (fig._pendingAutoSpeakNotification) {\n                fig._pendingAutoSpeakNotification = false;\n                // Fallback fired: playInner never consumed the flag, so speech\n                // never started.\n                fig.notifications.publish('startAutoSpeak', false);\n            }\n        }, 1000);\n    }\n    else {\n        // Autospeak won't run (disabled / no chunks / not first load /\n        // audio ctx not usable), so speech is not playing.\n        fig.notifications.publish('startAutoSpeak', false);\n    }\n}\n/**\n * The tap finger a guide training's speech demonstrates with (`training_id:\n * {id, speech}`), unless the question's own js made one.\n *\n * Its tapSelectables(selected) taps each of the select_submit answers the\n * training demonstrates on (answer_input_selector's getDemoSelectors),\n * selecting or unselecting each as it's tapped. The steps are queued when it's\n * called, so speech calls it directly: |e:tap_finger,tapSelectables,True|\n */\nfunction createTrainingFinger(config) {\n    var _a;\n    var tapFinger = (_a = config.learner) === null || _a === void 0 ? void 0 : _a.tapFinger;\n    var fig = window.figure;\n    if (tapFinger == null || fig == null || fig.get('tap_finger') != null) {\n        return;\n    }\n    var finger = createTapFinger({ pointer: tapFinger.pointer === 'mouse' ? 'mouse' : 'touch' });\n    finger.tapSelectables = function (selected) {\n        var selector = fig.get('answer_input_selector');\n        if (selector == null || selector.custom.getDemoSelectors == null) {\n            return;\n        }\n        var elements = selector.custom.getDemoSelectors();\n        for (var i = 0; i < elements.length; i += 1) {\n            finger.moveTo(elements[i]);\n            finger.tap({ targetScale: 1 });\n            finger.exec('answer_input_selector', 'animateSelections', [elements[i].name], selected, 0.2);\n            finger.wait(0.3);\n        }\n    };\n}\n/** Whether this load is within the transition timeout of the question's\n * creation, rather than a reload. */\nfunction loadedFirst(config) {\n    var _a, _b, _c, _d;\n    return ((_b = (_a = config.learner) === null || _a === void 0 ? void 0 : _a.secondsAfterCreation) !== null && _b !== void 0 ? _b : Infinity)\n        <= ((_d = (_c = config.learner) === null || _c === void 0 ? void 0 : _c.transitionTimeout) !== null && _d !== void 0 ? _d : 10);\n}\n/** Whether this load plays the guide training (as playQuestionSpeech). */\nfunction playsGuideTraining(config) {\n    var _a;\n    var training = (_a = config.preGuides) === null || _a === void 0 ? void 0 : _a.training;\n    var isFirstLoad = loadedFirst(config);\n    return training != null && (training.everyLoad || isFirstLoad);\n}\n/**\n * Whether this load plays a training step's question's speech (Learner.train,\n * learner.trainingQuestion): its demonstration, whatever the auto-speak\n * setting, when the question would be spoken.\n */\nfunction playsTrainingQuestion(config) {\n    var _a, _b, _c, _d;\n    var fig = window.figure;\n    var isFirstLoad = loadedFirst(config);\n    var autoSpeechId = ((_a = fig === null || fig === void 0 ? void 0 : fig.chunkedSpeech) === null || _a === void 0 ? void 0 : _a[AUTO_SPEECH_ID]) ? AUTO_SPEECH_ID : 'default';\n    return !!(((_b = config.learner) === null || _b === void 0 ? void 0 : _b.trainingQuestion)\n        && (isFirstLoad || ((_c = config.learner) === null || _c === void 0 ? void 0 : _c.forceAutoSpeak))\n        && ((_d = fig === null || fig === void 0 ? void 0 : fig.chunkedSpeech) === null || _d === void 0 ? void 0 : _d[autoSpeechId]));\n}\n/** Lock the question from load while it plays a training (trainingPlay.ts). */\nfunction lockForTraining(config) {\n    if (playsGuideTraining(config) || playsTrainingQuestion(config)) {\n        lockInteraction(window.figure);\n    }\n}\n/**\n * Orchestrates pre-guides (training/before/after) and auto-speak on question\n * load. The training and before_speech guides play regardless of auto-speak,\n * the training first; after_speech only when auto-speak is enabled. All\n * respect everyLoad / isFirstLoad gating.\n * Keep these playback gates in sync with question_speech_urls in\n * alpha/models/speech/inline_urls.py, which selects chunks for cached URL hints.\n */\nexport function playQuestionSpeech(config) {\n    return __awaiter(this, void 0, void 0, function () {\n        var fig, custom;\n        return __generator(this, function (_a) {\n            switch (_a.label) {\n                case 0:\n                    fig = window.figure;\n                    custom = fig === null || fig === void 0 ? void 0 : fig.custom;\n                    _a.label = 1;\n                case 1:\n                    _a.trys.push([1, , 3, 4]);\n                    return [4 /*yield*/, playSpeeches(fig, custom, config)];\n                case 2:\n                    _a.sent();\n                    return [3 /*break*/, 4];\n                case 3:\n                    // Whichever way the speeches end, a training's lock (lockForTraining)\n                    // and its time (submitAnswer) end with them. Does nothing once released.\n                    if ((custom === null || custom === void 0 ? void 0 : custom.trainingTime) != null && custom.trainingTime.stop == null) {\n                        custom.trainingTime.stop = performance.now();\n                    }\n                    if ((custom === null || custom === void 0 ? void 0 : custom.dontKnowIntroTime) != null && custom.dontKnowIntroTime.stop == null) {\n                        custom.dontKnowIntroTime.stop = performance.now();\n                    }\n                    releaseTraining(custom);\n                    return [7 /*endfinally*/];\n                case 4: return [2 /*return*/];\n            }\n        });\n    });\n}\nfunction playSpeeches(fig, custom, config) {\n    return __awaiter(this, void 0, void 0, function () {\n        var preGuides, isFirstLoad, shouldAutoSpeak, trainingTime, training, trainingQuestion, AC, ctx, e_1, chunked, questionId_1, played, chunked, introTime, played, hasAfterSpeech, autoSpeechId, autoSpeechCompleted, autoSpeakWillRun, replacesAutoSpeech, subId_1, chunked;\n        var _a, _b, _c, _d, _e, _f;\n        return __generator(this, function (_g) {\n            switch (_g.label) {\n                case 0:\n                    if (!(fig === null || fig === void 0 ? void 0 : fig.speechManager))\n                        return [2 /*return*/];\n                    preGuides = config.preGuides;\n                    isFirstLoad = loadedFirst(config);\n                    shouldAutoSpeak = isFirstLoad || !!((_a = config.learner) === null || _a === void 0 ? void 0 : _a.forceAutoSpeak);\n                    trainingTime = { start: performance.now(), stop: null };\n                    training = playsGuideTraining(config) ? preGuides.training : null;\n                    trainingQuestion = playsTrainingQuestion(config);\n                    if (!(training != null || trainingQuestion)) return [3 /*break*/, 4];\n                    custom.trainingTime = trainingTime;\n                    return [4 /*yield*/, audioRuns(fig)];\n                case 1:\n                    if (!!(_g.sent())) return [3 /*break*/, 3];\n                    if (fig.custom !== custom)\n                        return [2 /*return*/];\n                    return [4 /*yield*/, waitForTrainingPlay(fig)];\n                case 2:\n                    _g.sent();\n                    _g.label = 3;\n                case 3:\n                    if (fig.custom !== custom)\n                        return [2 /*return*/];\n                    _g.label = 4;\n                case 4:\n                    if (!!fig.speechManager.ctx) return [3 /*break*/, 8];\n                    _g.label = 5;\n                case 5:\n                    _g.trys.push([5, 7, , 8]);\n                    AC = window.AudioContext || window.webkitAudioContext;\n                    ctx = new AC();\n                    return [4 /*yield*/, ctx.resume()];\n                case 6:\n                    _g.sent();\n                    if (ctx.state !== 'running') {\n                        ctx.close();\n                        return [2 /*return*/];\n                    }\n                    fig.speechManager.ctx = ctx;\n                    return [3 /*break*/, 8];\n                case 7:\n                    e_1 = _g.sent();\n                    return [2 /*return*/];\n                case 8:\n                    if (!(training != null)) return [3 /*break*/, 13];\n                    chunked = typeof training.chunked === 'string'\n                        ? JSON.parse(training.chunked) : training.chunked;\n                    fig.chunkedSpeech[training.hash] = chunked;\n                    questionId_1 = fig.question_id;\n                    played = void 0;\n                    _g.label = 9;\n                case 9:\n                    _g.trys.push([9, , 11, 12]);\n                    return [4 /*yield*/, playSpeechAndWait(fig, training.hash, function () {\n                            request('POST', 'training_played/', { id: questionId_1 }, function () { });\n                        })];\n                case 10:\n                    played = _g.sent();\n                    return [3 /*break*/, 12];\n                case 11:\n                    trainingTime.stop = performance.now();\n                    releaseTraining(custom);\n                    return [7 /*endfinally*/];\n                case 12:\n                    // As for the before-speech guide below\n                    if (played === 'interrupted')\n                        return [2 /*return*/];\n                    _g.label = 13;\n                case 13:\n                    if (!((preGuides === null || preGuides === void 0 ? void 0 : preGuides.beforeSpeech) && (preGuides.beforeSpeech.everyLoad || isFirstLoad))) return [3 /*break*/, 18];\n                    chunked = typeof preGuides.beforeSpeech.chunked === 'string'\n                        ? JSON.parse(preGuides.beforeSpeech.chunked) : preGuides.beforeSpeech.chunked;\n                    fig.chunkedSpeech[preGuides.beforeSpeech.hash] = chunked;\n                    introTime = null;\n                    if (preGuides.beforeSpeech.dontKnowIntro) {\n                        introTime = { start: performance.now(), stop: null };\n                        custom.dontKnowIntroTime = introTime;\n                    }\n                    played = void 0;\n                    _g.label = 14;\n                case 14:\n                    _g.trys.push([14, , 16, 17]);\n                    return [4 /*yield*/, playSpeechAndWait(fig, preGuides.beforeSpeech.hash)];\n                case 15:\n                    played = _g.sent();\n                    return [3 /*break*/, 17];\n                case 16:\n                    if (introTime != null) {\n                        introTime.stop = performance.now();\n                    }\n                    return [7 /*endfinally*/];\n                case 17:\n                    if (played === 'interrupted')\n                        return [2 /*return*/];\n                    _g.label = 18;\n                case 18:\n                    hasAfterSpeech = (preGuides === null || preGuides === void 0 ? void 0 : preGuides.afterSpeech)\n                        && ((_b = config.learner) === null || _b === void 0 ? void 0 : _b.autoSpeakQuestion)\n                        && (preGuides.afterSpeech.everyLoad || shouldAutoSpeak);\n                    autoSpeechId = ((_c = fig === null || fig === void 0 ? void 0 : fig.chunkedSpeech) === null || _c === void 0 ? void 0 : _c[AUTO_SPEECH_ID]) ? AUTO_SPEECH_ID : 'default';\n                    autoSpeechCompleted = true;\n                    autoSpeakWillRun = trainingQuestion || (((_d = config.learner) === null || _d === void 0 ? void 0 : _d.autoSpeakQuestion)\n                        && ((_e = fig === null || fig === void 0 ? void 0 : fig.chunkedSpeech) === null || _e === void 0 ? void 0 : _e[autoSpeechId])\n                        && shouldAutoSpeak);\n                    replacesAutoSpeech = !!(autoSpeakWillRun && hasAfterSpeech && shouldAutoSpeak\n                        && !trainingQuestion && preGuides.afterSpeech.replaceSpeech);\n                    if (!autoSpeakWillRun) return [3 /*break*/, 27];\n                    // If transitionsAutospeak hid the answer input / disabled interaction,\n                    // restore them on the first speechComplete (the autospeak finishing).\n                    // Idempotent: only re-shows / re-enables if currently hidden / disabled.\n                    if ((_f = fig.custom) === null || _f === void 0 ? void 0 : _f._autospeakRestorePending) {\n                        subId_1 = fig.notifications.add('speechComplete', function () {\n                            var _a;\n                            fig.notifications.remove('speechComplete', subId_1);\n                            if (!((_a = fig.custom) === null || _a === void 0 ? void 0 : _a._autospeakRestorePending))\n                                return;\n                            fig.custom._autospeakRestorePending = false;\n                            var ai = getAnyAnswerInput();\n                            if (ai != null) {\n                                showAnswerInput(ai);\n                            }\n                            if (fig.custom.disabled && fig.custom.enableInteraction) {\n                                fig.custom.enableInteraction();\n                            }\n                            // transitionsAutospeak stopped the original continueFadeIn and did\n                            // not restart it (to keep the continue button hidden during speech).\n                            // Now that speech is done, kick off the fade-in with zero delay —\n                            // the speech itself served as the \"wait before continue\", so the\n                            // configured continue_delay would just feel like dead time.\n                            continueFadeIn(0);\n                        });\n                    }\n                    if (!trainingQuestion) return [3 /*break*/, 23];\n                    _g.label = 19;\n                case 19:\n                    _g.trys.push([19, , 21, 22]);\n                    return [4 /*yield*/, playSpeechAndWait(fig, autoSpeechId)];\n                case 20:\n                    autoSpeechCompleted = (_g.sent()) === 'completed';\n                    return [3 /*break*/, 22];\n                case 21:\n                    trainingTime.stop = performance.now();\n                    releaseTraining(custom);\n                    return [7 /*endfinally*/];\n                case 22: return [3 /*break*/, 27];\n                case 23:\n                    if (!replacesAutoSpeech) return [3 /*break*/, 24];\n                    return [3 /*break*/, 27];\n                case 24:\n                    if (!hasAfterSpeech) return [3 /*break*/, 26];\n                    return [4 /*yield*/, playSpeechAndWait(fig, autoSpeechId)];\n                case 25:\n                    autoSpeechCompleted = (_g.sent()) === 'completed';\n                    return [3 /*break*/, 27];\n                case 26:\n                    fig.speechManager.play(autoSpeechId);\n                    _g.label = 27;\n                case 27:\n                    if (!(hasAfterSpeech && autoSpeechCompleted)) return [3 /*break*/, 29];\n                    chunked = typeof preGuides.afterSpeech.chunked === 'string'\n                        ? JSON.parse(preGuides.afterSpeech.chunked) : preGuides.afterSpeech.chunked;\n                    fig.chunkedSpeech[preGuides.afterSpeech.hash] = chunked;\n                    return [4 /*yield*/, playSpeechAndWait(fig, preGuides.afterSpeech.hash)];\n                case 28:\n                    _g.sent();\n                    _g.label = 29;\n                case 29: return [2 /*return*/];\n            }\n        });\n    });\n}\nfunction processHint(config) {\n    var fig = window.figure;\n    window.hint = fig.add({\n        make: 'collection',\n        name: 'hnt',\n        elements: [\n            {\n                name: 'box',\n                make: 'collections.rectangle',\n                fill: [1, 1, 1, 1],\n                corner: { radius: 0.05, sides: 10 },\n                line: {\n                    width: 0.003,\n                    color: [0.7, 0.7, 0.7, 1],\n                },\n            },\n            {\n                name: 'hint',\n                make: 'equation',\n                scale: config.scale,\n                font: config.font,\n                textFont: config.textFont,\n                formDefaults: config.formDefaults,\n                color: [0, 0.69, 0.18, 1],\n            },\n        ],\n        position: config.position,\n    });\n    var hint = window.hint;\n    hint._hint.collections = fig.collections;\n    hint._hint.addElements({ sub_answer: { text: '' } });\n    if (config.buttonEnabled) {\n        var scene = fig.getScene();\n        var hintButtonSide = scene.widthNear / 20;\n        var hintButton = fig.add({\n            name: 'hintButton',\n            make: 'collections.button',\n            options: {\n                label: '?',\n                width: hintButtonSide,\n                height: hintButtonSide,\n                corner: {\n                    radius: hintButtonSide / 2,\n                    sides: 10,\n                },\n                colorFill: [1, 0, 0, 1],\n                colorLabel: [1, 1, 1, 1],\n                line: null,\n                position: [\n                    scene.right - hintButtonSide * 1.5,\n                    scene.bottom + hintButtonSide * 1.5,\n                ],\n            },\n        });\n        hintButton.notifications.add('touch', function () {\n            window.request('GET', 'alpha_hint', {}, function (response) {\n                window.FigTools.processResponse(response);\n            });\n        });\n    }\n}\nexport var MANUAL_SPEECH_ID = 'default_manual';\nexport var AUTO_SPEECH_ID = 'default_auto';\nfunction processSpeech(config) {\n    var fig = window.figure;\n    fig.speechMessage = config.message;\n    fig.chunkedSpeech = { default: config.chunkedSpeech };\n    if (config.chunkedAutoSpeech) {\n        fig.chunkedSpeech[AUTO_SPEECH_ID] = config.chunkedAutoSpeech;\n    }\n    if (config.chunkedManualSpeech) {\n        fig.chunkedSpeech[MANUAL_SPEECH_ID] = config.chunkedManualSpeech;\n    }\n    fig.speechOptions = {};\n    fig.speechId = 'default';\n    if (config.speechClass) {\n        fig.speechClass = config.speechClass;\n    }\n    // Recreate speech managers on each question load.  Teardown replaces all\n    // closures with no-ops (for GC) and removes the captions div, so the\n    // manager must be rebuilt with fresh closures.  The AudioContext is\n    // preserved to avoid needing a user gesture.\n    window.makeSpeechManager();\n    if (fig.speechManager && window.__preservedAudioCtx) {\n        fig.speechManager.ctx = window.__preservedAudioCtx;\n        window.__preservedAudioCtx = null;\n    }\n    window.makeOfflineSpeech();\n    if (config.captions) {\n        if (fig.speech) {\n            fig.speech.useCaptions = true;\n        }\n        if (fig.speechManager) {\n            fig.speechManager.useCaptions = true;\n        }\n    }\n}\nfunction processHelper(config) {\n    var fig = window.figure;\n    if (config.helperTimeout != null) {\n        fig.helperTimeout = config.helperTimeout;\n    }\n    if (!config.showHelp) {\n        fig.custom.showHelp = false;\n    }\n    // Gate the calculator toggle icon on the question's `calculator: True` flag.\n    // Set unconditionally so it resets to hidden on questions without the flag.\n    fig.custom.showCalculator = config.showCalculator === true;\n    // The learner's remembered 1x/2x zoom, applied when the panel is created.\n    fig.custom.calculatorZoomed = config.calculatorZoomed === true;\n    // \"Don't know\" pill (helper/dontKnowButton.tsx). Question JS drives it via\n    // figure.custom.dontKnow, so the controller must exist before remainingJs.\n    fig.custom.dontKnow = createDontKnowController(fig, config.dontKnow === true);\n}\nfunction processZoomAvailability(config) {\n    var fig = window.figure;\n    fig.custom.showZoom = (config === null || config === void 0 ? void 0 : config.showZoom) === true;\n    fig.custom.zoomIconForbidden = (config === null || config === void 0 ? void 0 : config.zoomIconForbidden) === true;\n}\nfunction processAnswerInputs(configs) {\n    var FT = window.FigTools;\n    for (var _i = 0, configs_1 = configs; _i < configs_1.length; _i++) {\n        var config = configs_1[_i];\n        var p = config.params;\n        switch (config.type) {\n            case 'multipleChoice':\n                FT.createMultipleChoice(p);\n                break;\n            case 'input': {\n                var params = __assign({}, p);\n                if (params.addTo && typeof params.addTo === 'string') {\n                    params.addTo = window[params.addTo];\n                }\n                FT.createInput(params);\n                break;\n            }\n            case 'selector':\n                FT.createSelector(p.correctAnswer, p.position, p.scenarios, p.singleElement, p.honing);\n                break;\n            case 'selectAuto':\n                FT.createSelectAuto(p.correctAnswer, p.position, p.scenarios, p.singleElement, p.correctElements, p.incorrectLimit, p.honing);\n                break;\n            case 'arrangeAuto':\n                FT.createArrangeAuto(p.slotTiles, p.position, p.scenarios, p.incorrectLimit, p.honing);\n                break;\n            case 'arrangeSubmit':\n                FT.createArrangeSubmit(p.slotTiles, p.position, p.scenarios, p.honing, p.submitWidth);\n                break;\n            case 'continueButton':\n                FT.createContinueButton(p.position, p.label, p.width, p.scenarios, p.fadeIn);\n                break;\n            case 'msgContinueButton':\n                FT.createMsgContinueButton(p.position, p.button, p.width, p.scenarios, p.height, p.fadeIn);\n                break;\n            case 'continueSlideButton':\n                FT.createContinueSlideButton(p.position, p.scenarios);\n                break;\n            case 'guessInput':\n                window.shown_answer = FT.createGuessInput(p.position, p.scenarios, p.showSeeAnotherExample);\n                break;\n            case 'goodOrRepeat':\n                FT.createGoodOrRepeat(p.position, p.scenarios, p.goto, p.fadeIn, p.showSeeAnotherExample, p.reloadFadeIn);\n                break;\n            case 'goodRepeatExplain':\n                FT.createGoodRepeatExplain(p.position, p.scenarios, p.goto, p.fadeIn);\n                break;\n            case 'understood':\n                FT.createUnderstood(p.position, p.options, p.scenarios);\n                break;\n            case 'playInput':\n                FT.createPlayInput(p.position, p.options, p.scenarios);\n                break;\n            case 'simplePlayInput':\n                FT.createSimplePlayInput(p.position, p.options, p.scenarios);\n                break;\n            case 'backButtonSlide':\n                FT.createBackButtonSlide(p.position);\n                break;\n            case 'backButtonSubmit':\n                FT.createBackButtonSubmit(p.position, p.color);\n                break;\n            case 'manipulativeAnswerInput':\n                FT.createManipulativeAnswerInput(p.position, p.options);\n                break;\n            case 'manipulativeSlotAnswerInput':\n                FT.createManipulativeSlotAnswerInput(p.position, p.options);\n                break;\n            case 'workPad':\n                FT.createWorkPad(p.options);\n                break;\n            case 'workPadNew':\n                FT.createWorkPadNew(p.options);\n                break;\n            case 'decision':\n                FT.createDecision(p.decisions, p.grid, p.width, p.height, p.space, p.position, p.msg);\n                break;\n            case 'bubble':\n                FT.createBubble();\n                break;\n            default:\n                console.warn(\"Unknown answer input type: \".concat(config.type));\n        }\n    }\n}\nexport function resolveEqnTarget(target) {\n    var parts = target.split('.');\n    var obj = window;\n    for (var _i = 0, parts_1 = parts; _i < parts_1.length; _i++) {\n        var part = parts_1[_i];\n        obj = obj === null || obj === void 0 ? void 0 : obj[part];\n    }\n    return obj;\n}\nfunction processEquationsData(config) {\n    var _a;\n    window.elements = config.elements;\n    for (var _i = 0, _b = config.equations; _i < _b.length; _i++) {\n        var eqData = _b[_i];\n        var eqn = resolveEqnTarget(eqData.eqnTarget);\n        if (!eqn)\n            continue;\n        if (Object.keys(eqData.addElements).length > 0) {\n            eqn.addElements(eqData.addElements);\n        }\n        for (var _c = 0, _d = Object.entries(eqData.addPhrases); _c < _d.length; _c++) {\n            var _e = _d[_c], name_1 = _e[0], phrase = _e[1];\n            eqn.addPhrases((_a = {}, _a[name_1] = phrase, _a));\n        }\n        var scenarioObj = resolveEqnTarget(eqData.scenarioTarget);\n        if (scenarioObj && Object.keys(eqData.scenarios).length > 0) {\n            joinObjects(scenarioObj.scenarios, eqData.scenarios);\n        }\n    }\n}\nexport default function loadQuestion(config) {\n    var _a, _b, _c, _d, _e;\n    resetQuestionZoomTelemetry();\n    stampInlineSpeechConfig(config);\n    var bringupStart = performance.now();\n    // Every question config carries a fresh signed token; storing it here covers the\n    // first render and every SPA transition, because both land in loadQuestion.\n    setSpeechToken(config.speech_token);\n    // Foundation: create figure, equations, auto-center\n    if (config.foundation) {\n        try {\n            createFigure(config.foundation.figure);\n        }\n        catch (e) {\n            // WebGL was refused by the browser. createFigure has rendered an\n            // overlay explaining the situation; abort the rest of question\n            // setup so we don't crash on figure.add() with a stub gl.\n            // Use name check instead of instanceof — robust against webpack\n            // chunk-deduplication producing two class identities.\n            if ((e === null || e === void 0 ? void 0 : e.name) === 'WebGLUnavailableError')\n                return;\n            throw e;\n        }\n        window.figure.instanceType = config.foundation.instanceType;\n        processZoomAvailability(config.helper);\n        questionMain(window.figure);\n        for (var _i = 0, _f = config.foundation.equations; _i < _f.length; _i++) {\n            var eqConfig = _f[_i];\n            createEquation(eqConfig);\n        }\n        if (config.foundation.autoCenter && config.foundation.autoCenter !== false) {\n            setupAutoCenter(config.foundation.autoCenter);\n        }\n        else if (config.foundation.autoCenter === false) {\n            window.autoCenter = function () { };\n        }\n    }\n    // Answer inputs\n    if (config.answerInputs) {\n        processAnswerInputs(config.answerInputs);\n    }\n    // Hint element + button\n    if (config.hint) {\n        processHint(config.hint);\n    }\n    // Speech globals + managers\n    if (config.speech) {\n        processSpeech(config.speech);\n    }\n    // Helper / DontKnow\n    if (config.helper) {\n        processHelper(config.helper);\n    }\n    // Equations data: elements, phrases, scenarios (forms deferred)\n    if (config.equationsData) {\n        processEquationsData(config.equationsData);\n    }\n    // Store config for deferred access (applyEquationForms)\n    window._qc = config;\n    // Learner data: globals, colors, question ID\n    if (config.learner) {\n        var l = config.learner;\n        window.initParams = {};\n        window._secondsAfterCreation = l.secondsAfterCreation;\n        window._guid = l.guid;\n        if (l.inHoning) {\n            window._grokkoli_in_honing = true;\n        }\n        if (l.catchJsErrors) {\n            window._grokkoli_catch_js_errors = true;\n        }\n        if (l.questionId) {\n            window.figure.question_id = l.questionId;\n            window.grokkoli_question_id = l.questionId;\n        }\n        if (l.colors) {\n            for (var _g = 0, _h = Object.entries(l.colors); _g < _h.length; _g++) {\n                var _j = _h[_g], key = _j[0], value = _j[1];\n                window.figure.custom[key] = value;\n            }\n        }\n        if (l.transitionTimeout != null) {\n            window._transitionTimeout = l.transitionTimeout;\n        }\n    }\n    // Console failure-mode helpers ba() / bw() (idempotent).\n    installBreakTools();\n    // Error handler — only register once (persists across SPA transitions)\n    if (((_a = config.learner) === null || _a === void 0 ? void 0 : _a.catchJsErrors) && !window._errorHandlerRegistered) {\n        window._errorHandlerRegistered = true;\n        window.addEventListener('error', function (e) {\n            if (window._error_reported == null) {\n                window._error_reported = 0;\n            }\n            if (window._error_reported < 3) {\n                window.FigTools.logError({\n                    msg: e.message, filename: e.filename, lineno: e.lineno,\n                    colno: e.colno, error: JSON.stringify(e.error, Object.getOwnPropertyNames(e.error)),\n                    srcElement: e.srcElement, target: e.target, timestamp: e.timeStamp,\n                    stack: e.error.stack,\n                }, 'Global');\n                window._error_reported += 1;\n            }\n            return true;\n        });\n    }\n    // Execute remainingJs + finalize in a try/finally so that\n    // setupAutoSpeakNotification always runs — even if a YAML js block\n    // throws after registering a `startAutoSpeak` subscriber.  Without this,\n    // a throwing js block would leave the subscriber waiting forever.\n    try {\n        // Execute remaining JS (init/js/make elements, phrases/forms with js key)\n        if (config.remainingJs) {\n            new Function(config.remainingJs)();\n        }\n        createTrainingFinger(config);\n        // Auto-finalize (replaces inline FigTools.finalizeQuestion() call)\n        if (config.finalize) {\n            var customInit = void 0;\n            if (config.finalize.customInit) {\n                customInit = new Function(config.finalize.customInit);\n            }\n            finalizeQuestion(customInit);\n        }\n    }\n    finally {\n        // Set up startAutoSpeak notification before the transitions/speech block.\n        // Subscribers are already registered by finalize above.  This runs even\n        // when transitions never fires its callback or playQuestionSpeech returns\n        // early, so js-block animations gated on startAutoSpeak always fire.\n        setupAutoSpeakNotification(config);\n        if (!((_b = config.learner) === null || _b === void 0 ? void 0 : _b.consoleDebug))\n            removeConsoleHelpers();\n    }\n    lockForTraining(config);\n    // Execute transitions (questions only) then play speech.\n    // If autospeak will run and the question defines a from_forms_autospeak\n    // sequence, use the lean autospeak transition (synchronous first form +\n    // any exec/delay/form steps, no answer-input/keyboard hide-show roundtrip).\n    // Speech can stage the answer input via |hide_answerinput|/|show_answerinput|.\n    // Cold-start subtlety: willAutoSpeak() requires a running audio ctx at this\n    // synchronous decision point.  On a hard refresh without a prior user\n    // gesture the ctx is suspended, so we fall back to the regular transition\n    // even though playQuestionSpeech may later create a ctx and play autospeak.\n    if (config.learner && ((_c = config.finalize) === null || _c === void 0 ? void 0 : _c.instanceType) === 'question') {\n        var fig = window.figure;\n        var useAutospeak = ((_d = fig === null || fig === void 0 ? void 0 : fig.custom) === null || _d === void 0 ? void 0 : _d.transitionsAutospeak)\n            && willAutoSpeak(config);\n        var transitionFn = useAutospeak\n            ? fig.custom.transitionsAutospeak\n            : (_e = fig === null || fig === void 0 ? void 0 : fig.custom) === null || _e === void 0 ? void 0 : _e.transitions;\n        if (transitionFn) {\n            transitionFn(config.learner.secondsAfterCreation, config.learner.transitionTimeout, function () { return playQuestionSpeech(config); });\n        }\n        else {\n            playQuestionSpeech(config);\n        }\n    }\n    else {\n        playQuestionSpeech(config);\n    }\n    window.figure.questionReady = true;\n    setBringupTime(Math.round(performance.now() - bringupStart));\n}\n/**\n * Tear down the current question for an SPA transition.\n * Preserves the Figure instance, WebGL context, and AudioContext.\n */\nexport function teardownQuestion() {\n    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;\n    resetKeyboardViewport();\n    var fig = window.figure;\n    if (!fig)\n        return;\n    // Disable gesture before any teardown work. FigureOne's moveHandler reads\n    // `this.enable && this.mouseDown` and otherwise falls through to free(),\n    // so flipping enable short-circuits the dangerous path even if a stale\n    // touchmove fires during teardown/rebuild with inconsistent state.\n    // Main figure is re-enabled at the end of _rebuildQuestion; the workpad\n    // figure's listeners are fully removed by wp.destroy() below, so no\n    // re-enable is needed (any new workpad is a fresh instance).\n    if (fig.gesture) {\n        fig.gesture.enable = false;\n    }\n    var wpEarly = window.figureWP || window.figureWPBuilding;\n    if (wpEarly === null || wpEarly === void 0 ? void 0 : wpEarly.gesture) {\n        wpEarly.gesture.enable = false;\n    }\n    var teardownStart = performance.now();\n    incrementQuestionsSinceLoad();\n    // Record a compact GPU/atlas breadcrumb for the question that just\n    // finished — its atlases are all still resident here (teardown of\n    // elements happens further down).  In-memory only; the downsampled\n    // trace is shipped with any later context-loss event so the growth\n    // curve into a crash is visible.\n    recordWebGLBreadcrumb();\n    // Snapshot WeakRefs to all elements BEFORE teardown.  After teardown +\n    // GC, any WeakRef that is still alive proves something retains that\n    // element.  Unlike Runtime.queryObjects, WeakRefs don't pin objects.\n    if (window.__memoryProfileEnabled) {\n        var allEls = fig.elements.getAllElements();\n        var WR = globalThis.WeakRef;\n        var weakRefs = [];\n        for (var _i = 0, allEls_1 = allEls; _i < allEls_1.length; _i++) {\n            var el = allEls_1[_i];\n            if (el === fig.elements)\n                continue;\n            weakRefs.push({\n                name: el.name || '(unnamed)',\n                type: ((_a = el.constructor) === null || _a === void 0 ? void 0 : _a.name) || 'FigureElement',\n                ref: new WR(el),\n            });\n        }\n        window.__elementWeakRefs = weakRefs;\n    }\n    // Remove per-question event listeners on body/document before anything else,\n    // so their closures release references to the old question's elements.\n    if (fig._docListeners) {\n        for (var _p = 0, _q = fig._docListeners; _p < _q.length; _p++) {\n            var _r = _q[_p], target = _r.target, event_1 = _r.event, handler = _r.handler, options = _r.options;\n            target.removeEventListener(event_1, handler, options);\n        }\n        fig._docListeners = [];\n    }\n    // Remove near-touch mousedown/touchstart listeners from canvas elements.\n    teardownNearTouch();\n    // Drop a tap finger's queued demonstration (guide trainings, pre-guides)\n    // before stop('complete') below: completing its current animation would\n    // otherwise run every remaining step at once on the outgoing question\n    // (selecting sides, firing answerChanged...).\n    var tapFinger = (_b = fig.get) === null || _b === void 0 ? void 0 : _b.call(fig, 'tap_finger');\n    if (tapFinger === null || tapFinger === void 0 ? void 0 : tapFinger.cancel)\n        tapFinger.cancel();\n    fig.stop('complete');\n    fig.elements.stop('complete');\n    (_d = (_c = fig.custom).cancelFontLoading) === null || _d === void 0 ? void 0 : _d.call(_c);\n    if (fig.custom._speechFallbackTimer != null) {\n        clearTimeout(fig.custom._speechFallbackTimer);\n        fig.custom._speechFallbackTimer = null;\n    }\n    if (fig._autoSpeakFallbackId != null) {\n        clearTimeout(fig._autoSpeakFallbackId);\n        fig._autoSpeakFallbackId = null;\n    }\n    fig._pendingAutoSpeakNotification = false;\n    removeTrainingPlay();\n    if (fig.custom._hidePlayTimerId1 != null) {\n        clearTimeout(fig.custom._hidePlayTimerId1);\n        fig.custom._hidePlayTimerId1 = null;\n    }\n    if (fig.custom._hidePlayTimerId2 != null) {\n        clearTimeout(fig.custom._hidePlayTimerId2);\n        fig.custom._hidePlayTimerId2 = null;\n    }\n    // Clear all managed timeouts set via gSetTimeout() in content JS.\n    for (var _s = 0, _t = Object.keys(_gTimeouts); _s < _t.length; _s++) {\n        var key = _t[_s];\n        clearTimeout(_gTimeouts[key]);\n        delete _gTimeouts[key];\n    }\n    // The mirror image of the registry above: deferred work that must not be\n    // dropped on a transition (a debounced save whose window is still open) is\n    // run now rather than cleared.  See tools/flushTimeouts.\n    flushAllTimeouts();\n    // Floating calculators live on document.body so scene zoom cannot clip\n    // them. Remove them before clearing FigureOne elements and HTML.\n    (_e = fig.custom._calculatorControllers) === null || _e === void 0 ? void 0 : _e.forEach(function (controller) { return controller.destroy(); });\n    delete fig.custom._calculatorControllers;\n    if (fig.countdownId != null) {\n        clearTimeout(fig.countdownId);\n        fig.countdownId = null;\n    }\n    if (fig._slideContinuePoll != null) {\n        clearInterval(fig._slideContinuePoll);\n        fig._slideContinuePoll = null;\n    }\n    if (fig._slideNextPoll != null) {\n        clearInterval(fig._slideNextPoll);\n        fig._slideNextPoll = null;\n    }\n    if (fig._slideNextFallback != null) {\n        clearTimeout(fig._slideNextFallback);\n        fig._slideNextFallback = null;\n    }\n    if (fig._slideNextCeiling != null) {\n        clearTimeout(fig._slideNextCeiling);\n        fig._slideNextCeiling = null;\n    }\n    if (fig._slideNextDoTimer != null) {\n        clearTimeout(fig._slideNextDoTimer);\n        fig._slideNextDoTimer = null;\n    }\n    clearAllTimers();\n    // Cancel any pending requestAnimationFrame callbacks from workpad scroll\n    // handlers.  These closures capture workpad elements and prevent GC until\n    // the next frame; cancelling them releases the references immediately.\n    if (fig._pendingRafs) {\n        for (var _u = 0, _v = fig._pendingRafs; _u < _v.length; _u++) {\n            var id = _v[_u];\n            cancelAnimationFrame(id);\n        }\n        fig._pendingRafs = [];\n    }\n    if (fig.speechManager) {\n        // Clean stop while everything still exists, then deep cleanup below.\n        (_g = (_f = fig.speechManager).stopPlaying) === null || _g === void 0 ? void 0 : _g.call(_f);\n        fig.speechManager.currentAudio = null;\n        if (fig.speechManager.playPauseTimerId != null) {\n            clearTimeout(fig.speechManager.playPauseTimerId);\n            fig.speechManager.playPauseTimerId = null;\n        }\n        if (fig.speechManager.hideCaptionsTimeoutId != null) {\n            clearTimeout(fig.speechManager.hideCaptionsTimeoutId);\n            fig.speechManager.hideCaptionsTimeoutId = null;\n        }\n        // Pending caption segment swap, which would otherwise fire against the\n        // next question's captions div.\n        if (fig.speechManager.captionTimeoutId != null) {\n            clearTimeout(fig.speechManager.captionTimeoutId);\n            fig.speechManager.captionTimeoutId = null;\n        }\n        if (fig.speechManager.resumePlayChunkTimeoutId != null) {\n            clearTimeout(fig.speechManager.resumePlayChunkTimeoutId);\n            fig.speechManager.resumePlayChunkTimeoutId = null;\n        }\n        // The stall watchdog's setInterval self-cancels on stale generation,\n        // but generation only bumps when the next question's makeSpeechManager\n        // runs.  Explicitly clear here so the interval stops ticking during\n        // the teardown→next-question gap (and forever if no next question\n        // follows, e.g. user navigates away).\n        if (fig.speechManager._stallWatchdogId != null) {\n            clearInterval(fig.speechManager._stallWatchdogId);\n            fig.speechManager._stallWatchdogId = null;\n        }\n        fig.speechManager.isPlaying = false;\n        fig.speechManager.interruptedState = null;\n        fig.speechManager.playFinishedCallback1 = null;\n        fig.speechManager.startCount = 0;\n        fig.speechManager.completeCount = 0;\n        fig.speechManager.freeze = null;\n        // Release per-question DOM and element refs from the speechManager.\n        fig.speechManager.playContainer = null;\n        fig.speechManager.playLoadingIcon = null;\n        fig.speechManager.speechLoadingIcon = null;\n        fig.speechManager.toPlayButton = function () { };\n        fig.speechManager.toPauseButton = function () { };\n        fig.speechManager.showContinueOnEnd = false;\n        // Null the closure-captured FigureOne elements.  speechRect and\n        // speechArrow are stored as direct properties AND captured by\n        // closures (showArrow, etc.) in the makeSpeechManager scope.\n        // Nulling the properties won't free the closure scope, but\n        // makeSpeechManager() will overwrite all function properties on\n        // the next question load, releasing the old closures.\n        fig.speechManager.speechRect = null;\n        fig.speechManager.speechArrow = null;\n        // Release all function closures from the makeSpeechManager scope.\n        // Each function captures the entire scope (speechRect, speechArrow,\n        // playContainer, DOM elements, etc.).  Replacing with no-ops (not\n        // null) allows GC to collect the old scope while keeping callers\n        // that fire during the teardown→rebuild gap from throwing.\n        var noop = function () { };\n        for (var _w = 0, _x = Object.keys(fig.speechManager); _w < _x.length; _w++) {\n            var key = _x[_w];\n            if (typeof fig.speechManager[key] === 'function') {\n                fig.speechManager[key] = noop;\n            }\n        }\n        // Preserve AudioContext across transitions (requires user gesture to\n        // create, so we can't make a new one during rebuild).\n        window.__preservedAudioCtx = fig.speechManager.ctx;\n        // Null remaining object/DOM properties (speakerIcon, seekContainer,\n        // seekBar, etc.) that hold detached DOM subtrees whose event-listener\n        // closures capture the makeSpeechManager scope — preventing GC of\n        // speechRect and speechArrow.\n        for (var _y = 0, _z = Object.keys(fig.speechManager); _y < _z.length; _y++) {\n            var key = _z[_y];\n            var val = fig.speechManager[key];\n            if (val !== null && val !== undefined && typeof val === 'object') {\n                fig.speechManager[key] = null;\n            }\n        }\n    }\n    if (fig.speech) {\n        (_j = (_h = fig.speech).stop) === null || _j === void 0 ? void 0 : _j.call(_h);\n    }\n    // Remove captions div (appended to navbar, outside the figureone__html\n    // layer that teardown clears via innerHTML='').\n    var oldCaptions = document.getElementById('speech_captions');\n    if (oldCaptions)\n        oldCaptions.remove();\n    // Disconnect all audio sources from the preserved AudioContext before\n    // clearing chunkedSpeech.  When audio finishes naturally, playBuffer()'s\n    // 'ended' handler fires but the source stays connected to ctx.destination.\n    // The preserved AudioContext keeps these sources alive across transitions,\n    // retaining their decoded buffers (~100KB+ each) and closure chains.\n    for (var _0 = 0, _1 = Object.keys(fig.chunkedSpeech); _0 < _1.length; _0++) {\n        var speechId = _1[_0];\n        var chunks = fig.chunkedSpeech[speechId];\n        if (!Array.isArray(chunks))\n            continue;\n        for (var _2 = 0, chunks_1 = chunks; _2 < chunks_1.length; _2++) {\n            var chunk = chunks_1[_2];\n            if (chunk.audio) {\n                if (chunk.audio.source) {\n                    try {\n                        chunk.audio.source.stop();\n                    }\n                    catch (_) { /* already stopped */ }\n                    chunk.audio.source.disconnect();\n                    chunk.audio.source = null;\n                }\n                chunk.audio.buffer = null;\n                chunk.audio.onEnd = null;\n                chunk.audio.onLoad = null;\n                // Null closure-bearing functions (play=playBuffer, pause, resume,\n                // getCurrentTime, load).  These close over the makeSpeechManager\n                // scope which holds speechRect and speechArrow.  The config object\n                // shares the same chunkedSpeech array (slides.ts line 42), so even\n                // after fig.chunkedSpeech={}, the config's reference keeps these\n                // closures alive if any window global captures the config.\n                chunk.audio.play = null;\n                chunk.audio.pause = null;\n                chunk.audio.resume = null;\n                chunk.audio.getCurrentTime = null;\n                chunk.audio.load = null;\n            }\n        }\n    }\n    fig.chunkedSpeech = {};\n    fig.speechOptions = {};\n    fig.speechId = null;\n    fig.speechMessage = null;\n    fig.speechClass = null;\n    // `figureWPBuilding` holds a workpad figure whose construction threw\n    // part-way (see createWorkPadNew) — it was never published as `figureWP`,\n    // but it still owns a WebGL context and document listeners, so it has to\n    // be destroyed here too or the context leaks into the next question.\n    if (window.figureWP || window.figureWPBuilding) {\n        destroyWorkPadFigure(window.figureWP || window.figureWPBuilding);\n        window.figureWP = null;\n        window.figureWPBuilding = null;\n    }\n    window.figureOneFigures = [fig];\n    // Clear per-question notification subscribers from the figure.\n    // These closures capture references to the current question's elements\n    // (e.g. answer_input.locate, speechComplete handler, tile.setMoveBounds).\n    // The NotificationManager stores events by name: { 'ready': Notification, ... }.\n    // Preserve only the persistent notifications registered in createFigure.\n    if (fig.notifications && fig.notifications.notifications) {\n        var persistent = new Set(['contextLost', 'contextRestored']);\n        for (var _3 = 0, _4 = Object.keys(fig.notifications.notifications); _3 < _4.length; _3++) {\n            var name_2 = _4[_3];\n            if (!persistent.has(name_2)) {\n                fig.notifications.notifications[name_2].cleanup();\n                delete fig.notifications.notifications[name_2];\n            }\n        }\n    }\n    // Clear per-question fontsLoaded subscribers from the FontManager.\n    // autoCenter, tile sizing, and other per-question handlers register here.\n    // The persistent fontsLoaded handler from createFigure (enableInteraction\n    // cycling) is also cleared — we re-register it in reloadQuestion.\n    if (fig.fonts && fig.fonts.notifications && fig.fonts.notifications.notifications) {\n        var persistentFont = new Set();\n        for (var _5 = 0, _6 = Object.keys(fig.fonts.notifications.notifications); _5 < _6.length; _5++) {\n            var name_3 = _6[_5];\n            if (!persistentFont.has(name_3)) {\n                fig.fonts.notifications.notifications[name_3].cleanup();\n                delete fig.fonts.notifications.notifications[name_3];\n            }\n        }\n    }\n    // Clear per-question font callbacks before removing elements.\n    // The FontManager holds callbacks that reference question elements;\n    // if not cleared, font-load events fire on removed elements.\n    if (fig.fonts && fig.fonts.fonts) {\n        for (var _7 = 0, _8 = Object.keys(fig.fonts.fonts); _7 < _8.length; _7++) {\n            var fontName = _8[_7];\n            var font = fig.fonts.fonts[fontName];\n            if (font.callbacks)\n                font.callbacks = [];\n        }\n    }\n    // Remove all child elements.  For each subtree, clear .custom\n    // before removal (to break cross-references) and then break\n    // self-referencing cycles after removal (animations, fnMap,\n    // notifications create self-cycles via pulseTransformMethod\n    // capturing `this`).\n    //\n    // FigureOne's drawOrder can hold the same name twice (addElementWithName\n    // and toFront don't dedupe), and getChildren() then returns that child\n    // twice.  The second pass would call getAllElements() on a collection\n    // whose properties were already nulled below and throw, aborting teardown\n    // with the leftover name still in drawOrder -- the next frame then crashes\n    // in setupDraw.  So: report it (to find the source), visit each child once,\n    // and skip names with no element.\n    var topOrder = fig.elements.drawOrder || [];\n    var dupNames = topOrder.filter(function (n, i) { return topOrder.indexOf(n) !== i; });\n    var missingNames = topOrder.filter(function (n) { return fig.elements.elements[n] == null; });\n    if (dupNames.length > 0 || missingNames.length > 0) {\n        logError({\n            msg: \"teardown: bad top-level drawOrder (duplicates: [\".concat(dupNames.join(', '), \"], \")\n                + \"missing: [\".concat(missingNames.join(', '), \"])\"),\n            recovered: true,\n        }, 'teardownQuestion', { drawOrder: topOrder.slice() });\n    }\n    var children = fig.elements.getChildren().filter(function (c, i, all) { return c != null && all.indexOf(c) === i; });\n    for (var _9 = 0, children_1 = children; _9 < children_1.length; _9++) {\n        var child = children_1[_9];\n        var subtree = child.getAllElements\n            ? child.getAllElements() : [child];\n        for (var _10 = 0, subtree_1 = subtree; _10 < subtree_1.length; _10++) {\n            var el = subtree_1[_10];\n            // Clean up notificationHelper — linearBlocks and other manipulatives\n            // create these to manage event subscriptions.  If not cleaned up,\n            // their listeners accumulate (~26 per question with blocks).\n            if (el.notificationHelper) {\n                el.notificationHelper.cleanup();\n                el.notificationHelper = null;\n            }\n            el.custom = null;\n        }\n        // FigureOne's remove() → cleanup(true) releases this element's WebGL\n        // buffers and decrements its reference on any shared font atlas; the\n        // atlas survives for sibling elements (and the next question) until its\n        // last owner releases it.  See FigureOne ≥1.9 texture reference counting.\n        fig.elements.remove(child.name);\n        // Post-removal: aggressively null element properties to break\n        // reference cycles.  FigureOne's cleanup() only nulls figure\n        // and parent; remaining properties (fnMap, drawingObject, scene,\n        // transform, state, move, color) can retain large closure chains.\n        for (var _11 = 0, subtree_2 = subtree; _11 < subtree_2.length; _11++) {\n            var el = subtree_2[_11];\n            el.fnMap = null;\n            el.drawingObject = null;\n            el.scene = null;\n            el.state = {};\n            el.move = null;\n            el.color = null;\n            el.transform = null;\n            el.opacity = null;\n            el.lastDrawTransform = null;\n            el.pulseTransforms = null;\n            // Replace with a safe stub instead of null so that pending\n            // callbacks (e.g. speech playFinished) calling hide()/show()\n            // on removed elements don't crash on notifications.publish().\n            el.notifications = { publish: function () { }, add: function () { }, remove: function () { } };\n            // Null the AnimationManager to release animation step closures.\n            // FigureOne's cleanup() clears animation notifications but keeps\n            // the animations array — completed steps with trigger/beforeFrame\n            // callbacks capture the entire manipulative scope (tile, toAdd,\n            // container, slots).  remove() nulls animations on the top-level\n            // child, but cleanupChildren() does NOT null it on sub-elements.\n            if (el.animations) {\n                if (el.animations.animations)\n                    el.animations.animations = [];\n                el.animations = null;\n            }\n            // Null ALL remaining own properties to release closure scopes and\n            // cross-references.  Manipulative elements (tiles, blocks, clocks,\n            // etc.) set many methods and data properties directly on the element\n            // (moveTo, checkSlotSnaps, answerContainers, snappedSlot, etc.)\n            // whose closures/values reference other elements in the detached\n            // graph.  Using getOwnPropertyNames to also catch non-enumerable\n            // properties that Object.keys would miss.\n            var ownKeys = Object.getOwnPropertyNames(el);\n            for (var ki = 0; ki < ownKeys.length; ki++) {\n                var key = ownKeys[ki];\n                if (key === 'notifications')\n                    continue; // keep the safe stub set above\n                var val = el[key];\n                if (val === null || val === undefined)\n                    continue;\n                var t = typeof val;\n                if (t === 'function' || t === 'object') {\n                    try {\n                        el[key] = null;\n                    }\n                    catch (_) { /* non-configurable */ }\n                }\n            }\n        }\n    }\n    // remove() splices only one copy of a name, so drop any leftovers.\n    fig.elements.drawOrder = fig.elements.drawOrder.filter(function (n) { return fig.elements.elements[n] != null; });\n    // Clear font atlas notification subscribers.  Each GLText element\n    // subscribes to its atlas's \"updated\" notification, but FigureOne's\n    // remove()/cleanup() does not unsubscribe.  The atlases live on\n    // fig.webglLow and persist across transitions, so subscribers\n    // accumulate — each holding a native_bind(bound_this) that retains\n    // the removed text element and its entire subtree.\n    if (fig.webglLow && fig.webglLow.atlases) {\n        for (var _12 = 0, _13 = Object.keys(fig.webglLow.atlases); _12 < _13.length; _12++) {\n            var key = _13[_12];\n            var atlas = fig.webglLow.atlases[key];\n            if (atlas && atlas.notifications && atlas.notifications.notifications) {\n                for (var _14 = 0, _15 = Object.keys(atlas.notifications.notifications); _14 < _15.length; _14++) {\n                    var name_4 = _15[_14];\n                    var notif = atlas.notifications.notifications[name_4];\n                    if (notif && notif.subscribers)\n                        notif.subscribers = [];\n                }\n            }\n        }\n    }\n    // Clear the root collection's .custom — it holds refs like\n    // answer_input that point to now-removed child elements.\n    fig.elements.custom = {};\n    // Clear the root collection's fnMap — per-question equation code\n    // and manipulative setup can register closures that capture child\n    // elements.  The root collection persists, so stale entries prevent\n    // GC of the detached children.\n    if (fig.elements.fnMap) {\n        fig.elements.fnMap.fns = {};\n    }\n    // Clear per-question notifications on the root collection.\n    // Manipulatives register layoutForms handlers on their parent\n    // collections; if those parents are removed, the handlers are gone.\n    // But direct subscribers on fig.elements itself would survive.\n    if (fig.elements.notifications && fig.elements.notifications.notifications) {\n        for (var _16 = 0, _17 = Object.keys(fig.elements.notifications.notifications); _16 < _17.length; _16++) {\n            var name_5 = _17[_16];\n            fig.elements.notifications.notifications[name_5].cleanup();\n            delete fig.elements.notifications.notifications[name_5];\n        }\n    }\n    // Unmount any per-question React roots (achievements, progress, palette)\n    // before clearing the DOM.  After unmounting, scrub React's internal\n    // __react* properties from the containers to break the FiberRoot ↔\n    // container reference cycle and allow GC to collect the ~135 delegated\n    // event listeners that createRoot attaches but unmount() leaves behind.\n    if (window._grokkoliReactRoots) {\n        for (var _18 = 0, _19 = window._grokkoliReactRoots; _18 < _19.length; _18++) {\n            var root = _19[_18];\n            // Grab the container before unmount clears _internalRoot.\n            var container_1 = (_k = root._internalRoot) === null || _k === void 0 ? void 0 : _k.containerInfo;\n            try {\n                root.unmount();\n            }\n            catch (_) { /* already unmounted */ }\n            if (container_1) {\n                for (var _20 = 0, _21 = Object.getOwnPropertyNames(container_1); _20 < _21.length; _20++) {\n                    var key = _21[_20];\n                    if (key.startsWith('__react')) {\n                        try {\n                            delete container_1[key];\n                        }\n                        catch (_) { }\n                    }\n                }\n            }\n        }\n        delete window._grokkoliReactRoots;\n    }\n    // Clean up achievement timeout helpers set by createTimeouts().\n    if (window.__clearTimeouts) {\n        window.__clearTimeouts();\n    }\n    // Drain any timeouts registered directly (e.g. cursor blinkers in\n    // workpadElement/equationInput/eqn) — these lazily create __timeoutKeys\n    // even when createTimeouts() never ran, so __clearTimeouts may be absent.\n    var timeouts = window.__timeouts;\n    if (timeouts) {\n        for (var i = 0; i < timeouts.length; i += 1)\n            clearTimeout(timeouts[i]);\n    }\n    var timeoutKeys = window.__timeoutKeys;\n    if (timeoutKeys) {\n        for (var _22 = 0, _23 = Object.keys(timeoutKeys); _22 < _23.length; _22++) {\n            var key = _23[_22];\n            clearTimeout(timeoutKeys[key]);\n        }\n    }\n    delete window.__clearTimeouts;\n    delete window.__timeouts;\n    delete window.__timeoutKeys;\n    // Clear the Helper component tree from the preserved React root.\n    // The root stays alive (avoiding re-registration of ~135 delegated\n    // listeners), but rendering null releases the old Helper's DOM nodes\n    // and React fiber tree so they can be GC'd.\n    if (window._questionMainRoot) {\n        flushSync(function () {\n            window._questionMainRoot.render(null);\n        });\n    }\n    // Strip event listeners from keyboard button containers before DOM\n    // removal.  Each button's addEventListener closures form cross-heap\n    // V8↔Blink cycles with the detached DOM elements that Chrome's GC\n    // cannot always collect.  Replacing each listener-bearing element\n    // with a listenerless clone breaks these cycles.\n    var kbDiv = document.getElementById('input_keyboard');\n    if (kbDiv) {\n        var buttons = kbDiv.querySelectorAll('[class*=\"keyboard_button_container\"]');\n        for (var i = 0; i < buttons.length; i++) {\n            var btn = buttons[i];\n            var clone = btn.cloneNode(true);\n            (_l = btn.parentNode) === null || _l === void 0 ? void 0 : _l.replaceChild(clone, btn);\n        }\n        if (kbDiv.parentNode) {\n            var kbClone = kbDiv.cloneNode(true);\n            kbDiv.parentNode.replaceChild(kbClone, kbDiv);\n        }\n    }\n    // Clear all custom HTML from the figureone__html overlay layer.\n    // This removes answer bubbles, equation icons, keyboards, play buttons,\n    // workpad buttons, and any other HTML injected by question code.\n    // FigureOne will re-render its own text elements on the next frame.\n    //\n    // Preserve the question-main div and its React root across transitions.\n    // React 18's createRoot attaches ~135 delegated event listeners to the\n    // container; unmount() does not remove them, so creating a new root each\n    // time leaks listeners.  By keeping the same root + div, we reuse them.\n    var questionMainDiv = document.getElementById('question-main');\n    var htmlCanvas = document.getElementsByClassName('figureone__html')[0];\n    if (htmlCanvas) {\n        htmlCanvas.innerHTML = '';\n        // Re-attach the preserved div (innerHTML='' detached it from the DOM\n        // but our JS reference keeps the node alive for the React root).\n        if (questionMainDiv) {\n            htmlCanvas.appendChild(questionMainDiv);\n        }\n    }\n    var stc = document.getElementById('speed_test_container');\n    if (stc)\n        stc.classList.add('hide');\n    var stb = document.getElementById('speed_test_bar');\n    if (stb)\n        stb.style.width = '100%';\n    var wpc = document.getElementById('workPad_container');\n    if (wpc)\n        wpc.remove();\n    var wpadContainer = document.getElementById('workpadContainer');\n    if (wpadContainer)\n        wpadContainer.classList.add('workpad_hide');\n    var mainEl = document.getElementById('main');\n    if (mainEl)\n        mainEl.classList.remove('interstitial_message_background');\n    var container = document.getElementById('figureOneContainer');\n    // See --figure-surface in heliomath_tokens.css; the literal is the fallback\n    // for brands that do not define it (Grokkoli), so this is a no-op there.\n    if (container)\n        container.style.background = 'var(--figure-surface, #f6f7f7)';\n    if (fig.helper) {\n        (_o = (_m = fig.helper).stop) === null || _o === void 0 ? void 0 : _o.call(_m);\n    }\n    fig.helper = null;\n    fig.answerChanged = null;\n    fig.answerSubmitted = false;\n    fig.instanceType = null;\n    fig.question_id = null;\n    fig.loadTime = null;\n    fig.questionReady = null;\n    fig.remainingTime = 0;\n    // FigureOne only reassigns previousCursorPoint on its own touch down, and\n    // writes its x/y on every move - a move with no fresh down (e.g. a touch\n    // still in progress across the transition, or one that began while scene\n    // zoom held the gesture) throws on null. A fresh point holds no references.\n    fig.previousCursorPoint = new Fig.Point(0, 0);\n    // Moves buffered against the old question's elements must not be replayed\n    // into the next one on the next draw.\n    fig.moveBuffer = [];\n    if (fig.gesture) {\n        fig.gesture.mouseDown = false;\n        fig.gesture.previousPoint = null;\n    }\n    fig.beingTouchedElement = null;\n    fig.beingMovedElement = null;\n    // Release closures on fig.custom that capture question elements\n    // (e.g. stopContinueFadeIn holds button references).\n    // reloadQuestion() will reinitialize fig.custom = {} later, but\n    // the profiler measures between teardown and reload, so we must\n    // clear it here to allow elements to be GC'd.\n    fig.custom = {};\n    // Clear keyboard input handler references.  tools/keyboard.ts stores\n    // closures (addChar, deleteChar, onSubmit, onMove) on figure._inputs\n    // that capture the entire createInput scope — including the keyboard\n    // DOM element, answer_input, eqn, and correctness objects.  Without\n    // this, those closures survive teardown and prevent GC of the old\n    // keyboard elements and their event listeners.\n    fig._inputs = {};\n    window.expression = null;\n    window.instruction = null;\n    window.message = null;\n    window.hint = null;\n    window.elements = null;\n    window.initParams = null;\n    window._qc = null;\n    window._secondsAfterCreation = null;\n    window._grokkoli_in_honing = null;\n    window.grokkoli_question_id = null;\n    window._transitionTimeout = null;\n    window.shown_answer = null;\n    window.grokkoliManipulatives = {};\n    window.autoCenter = null;\n    window.helpAnswerYes = null;\n    // YAML js: blocks use bare assignments (e.g. `a = ...`) which create\n    // globals.  Clear `window.a` to release formExplorer references.\n    window.a = null;\n    // Workpad touch tracking — holds a reference to the old figure.\n    window.grokkoliLastTouch = null;\n    // Monitor records array — already cleared on answer submit, but not\n    // on teardown when no answer was submitted.\n    window._grokkoli_monitor_records = null;\n    // Debug utilities set by initQuestionFinalize.  window.dg stores\n    // speechManager.debugGuide — a closure capturing the makeSpeechManager\n    // scope (speechRect, speechArrow, and all speech elements).\n    window.dg = null;\n    window.dgc = null;\n    window.forms = null;\n    window.speech = null;\n    window.vs = null;\n    window.pc = null;\n    window.cb = null;\n    window.id = null;\n    window.ft = null;\n    window.sh = null;\n    window.pt = null;\n    window.br = null;\n    window.ls = null;\n    window.qt = null;\n    window.fb = null;\n    window.sw = null;\n    // Speech helpers set in makeSpeechManager - same closure scope as dg.\n    window.sp = null;\n    window.sc = null;\n    window.st = null;\n    window.h = null;\n    // Clear browser performance entries that accumulate from fetch requests.\n    if (performance.clearResourceTimings) {\n        performance.clearResourceTimings();\n    }\n    // Clear the console to release objects retained by console.log calls.\n    // Chrome holds strong references to all logged objects in the console\n    // message store, preventing GC of elements, closures, and DOM nodes\n    // that were logged during the question (e.g. equationInput.ts logs\n    // FigureOne elements, createEquation.ts logs config objects).\n    // eslint-disable-next-line no-console\n    console.clear();\n    // Clear the 2D text canvas to remove any ghost text from removed elements\n    clearTextCanvas(fig);\n    fig.animateNextFrame();\n    setTeardownTime(Math.round(performance.now() - teardownStart));\n}\n/**\n * Reload a question in-place (SPA transition).\n * Reuses the existing Figure instance and AudioContext.\n */\nexport function reloadQuestion(config) {\n    teardownQuestion();\n    console.log('%cSPA Transition', 'color: #2ecc71; font-weight: bold;');\n    // When memory profiling, yield to the event loop after teardown so the\n    // profiler can capture the clean state before the new question builds.\n    // The profiler sets __memoryProfileReady when done; we continue in a\n    // setTimeout callback.\n    if (window.__memoryProfileEnabled) {\n        window.__teardownComplete = true;\n        var waitAndRebuild_1 = function () {\n            if (window.__memoryProfileReady) {\n                window.__memoryProfileReady = false;\n                window.__teardownComplete = false;\n                _rebuildQuestion(config);\n            }\n            else {\n                setTimeout(waitAndRebuild_1, 5);\n            }\n        };\n        setTimeout(waitAndRebuild_1, 0);\n        return;\n    }\n    _rebuildQuestion(config);\n}\nfunction _rebuildQuestion(config) {\n    var _a, _b, _c, _d, _e;\n    resetQuestionZoomTelemetry();\n    // JSON receipt normally stamps first; this also covers direct/debug loads.\n    // Already-stamped deadlines are preserved across delayed SPA animations.\n    stampInlineSpeechConfig(config);\n    var bringupStart = performance.now();\n    // Every question config carries a fresh signed token, and this is the SPA path --\n    // reloadQuestion() and the memory-profiling branch both land here, and neither goes\n    // through loadQuestion(). Without this the token was only ever refreshed by a full\n    // page render, so a speech setting changed in another tab stayed unheard for the\n    // rest of the session: each new question kept speaking with the token minted when\n    // the tab first loaded.\n    setSpeechToken(config.speech_token);\n    var fig = window.figure;\n    if (config.foundation) {\n        // Update global font/color config\n        var fc = config.foundation.figure;\n        window.colors = fc.colors;\n        window.defaultFontFamily = fc.defaultFontFamily;\n        window.defaultFontFamilyMath = fc.defaultFontFamilyMath;\n        window.defaultLetterSpacing = fc.defaultLetterSpacing;\n        window.defaultFont = {\n            family: fc.defaultFontFamily, render: '2d', glyphs: 'latin',\n            size: fc.defaultFontSize, style: 'normal', weight: fc.defaultFontWeight,\n        };\n        window.defaultTextFont = {\n            family: fc.defaultFontFamily, render: '2d', glyphs: 'latin',\n            size: fc.defaultFontSize, weight: fc.defaultFontWeight, style: 'normal',\n        };\n        window.grokkoli = {};\n        // Update foreground color throughout the figure's object hierarchy.\n        // The color flows: Figure.defaultColor → primitives.defaultColor → Equation default color.\n        // All three levels must be updated for new elements to get the correct color.\n        var tools = Fig.tools;\n        var newColor = tools.color.HexToArray(fc.foregroundColor);\n        fig.defaultColor = newColor.slice();\n        fig.elements.color = newColor.slice();\n        fig.elements.defaultColor = newColor.slice();\n        if (fig.primitives) {\n            fig.primitives.defaultColor = newColor.slice();\n        }\n        if ((_a = fig.primitives) === null || _a === void 0 ? void 0 : _a.defaultFont) {\n            fig.primitives.defaultFont.color = newColor.slice();\n        }\n        // Re-initialize fig.custom (replicates what createFigure sets up)\n        fig.custom = {};\n        fig.custom.showContinueDelay = fc.showContinueDelay;\n        fig.loadTime = performance.now();\n        fig.gesturePreventDefault = 'ifTouched';\n        fig.answerChanged = function (params) {\n            if (fig.helper) {\n                fig.helper.answerChanged(params);\n            }\n        };\n        fig.custom.keyboard = 'enabled';\n        // Background setup\n        if (fc.backgroundType === 'msg') {\n            var c = document.getElementById('figureOneContainer');\n            if (c)\n                c.style.background = 'none';\n            var m = document.getElementById('main');\n            if (m)\n                m.classList.add('interstitial_message_background');\n        }\n        else {\n            var c = document.getElementById('figureOneContainer');\n            // See --figure-surface in heliomath_tokens.css (fallback = today's colour).\n            if (c)\n                c.style.background = 'var(--figure-surface, #f6f7f7)';\n        }\n        window.stopHelper = function () { };\n        fig.custom.reload = function () {\n            // A redirect (e.g. a tutorial \"Try it\" returning to its tutorial) is a full page\n            // load, so it wins over forceReload, which would otherwise reload /question/.\n            // Servers send it with or without a leading slash ('/instruction_mode/').\n            if (fig.custom.reloadRedirect != null) {\n                window.location.href = \"\".concat(window.location.origin, \"/\").concat(fig.custom.reloadRedirect.replace(/^\\/+/, ''));\n            }\n            else if (fig.custom.forceReload) {\n                window.location.reload();\n            }\n            else {\n                window.FigTools.transitionToNextQuestion();\n            }\n        };\n        fig.custom.helpers = {\n            unsnapAllTiles: window.FigTools.unsnapAllTiles,\n            showElement: window.FigTools.showElement,\n            hideElement: window.FigTools.hideElement,\n        };\n        fig.custom.cancelFontLoading = function () {\n            if (fig.fonts.checkTimer != null) {\n                clearTimeout(fig.fonts.checkTimer);\n                fig.fonts.checkTimer = null;\n            }\n        };\n        // Background gesture\n        fig.custom.backgroundGesture = fig.add({\n            make: 'rectangle',\n            width: fig.getScene().widthNear,\n            height: fig.getScene().heightNear,\n            color: [0, 0, 0, 0],\n        });\n        fig.custom.backgroundGestureCallback = null;\n        fig.custom.backgroundGesture.notifications.add('onClick', function () {\n            if (fig.custom.backgroundGestureCallback)\n                fig.custom.backgroundGestureCallback();\n        });\n        fig.custom.backgroundGesture.hide();\n        var round_1 = Fig.round;\n        fig.custom.getSpeechStats = function () {\n            var playCount = 0;\n            var playDuration = 0;\n            var completeCount = 0;\n            if (fig.speechManager != null && fig.speechManager.startCount > 0) {\n                playCount = fig.speechManager.startCount;\n                completeCount = fig.speechManager.completeCount;\n                playDuration = round_1(fig.speechManager.getPlayDuration(), 1);\n            }\n            else if (fig.speech != null && fig.speech.startCount > 0) {\n                playCount = fig.speech.startCount;\n                completeCount = fig.speech.completeCount;\n                playDuration = round_1(fig.speech.getPlayDuration(), 1);\n            }\n            return [playCount, completeCount, playDuration];\n        };\n        fig.custom.dullBrain = function () { var b = document.getElementById('ghelp_grokkoli'); if (b)\n            b.style.opacity = '0.5'; };\n        fig.custom.undullBrain = function () { var b = document.getElementById('ghelp_grokkoli'); if (b)\n            b.style.opacity = '1'; };\n        fig.custom.dullHelp = function () {\n            var icons = document.getElementsByClassName('ghelp_icon_container');\n            for (var i = 0; i < icons.length; i++)\n                icons[i].style.opacity = '0.5';\n            var line = document.getElementById('ghelp_menu_line');\n            if (line)\n                line.style.opacity = '0.25';\n        };\n        fig.custom.undullHelp = function () {\n            var icons = document.getElementsByClassName('ghelp_icon_container');\n            for (var i = 0; i < icons.length; i++)\n                icons[i].style.opacity = '1';\n            var line = document.getElementById('ghelp_menu_line');\n            if (line)\n                line.style.opacity = '1';\n        };\n        fig.custom.flashDisabled = function () {\n            var mainElement = document.getElementById('main');\n            if (mainElement != null) {\n                mainElement.classList.contains('interstitial_message_background');\n                return;\n            }\n            var foc = document.getElementById('figureOneContainer');\n            if (foc) {\n                foc.classList.remove('flash-disabled');\n                foc.offsetWidth;\n                foc.classList.add('flash-disabled');\n            }\n            var mc = document.getElementById('main');\n            if (mc) {\n                mc.classList.remove('flash-disabled');\n                mc.offsetWidth;\n                mc.classList.add('flash-disabled');\n            }\n        };\n        fig.custom.disableInteractionCallbacks = [];\n        fig.custom.enableInteractionCallbacks = [];\n        fig.custom.disableInteraction = function (callback) {\n            if (callback === void 0) { callback = null; }\n            if (fig.custom.disabled)\n                return;\n            if (window._grokkoli_silent_log)\n                window._grokkoli_silent_log('disable');\n            else\n                console.log('disable');\n            fig.custom.backgroundGesture.show();\n            fig.custom.backgroundGestureCallback = function () { fig.custom.flashDisabled(); if (callback)\n                callback(); };\n            fig.custom.disabled = true;\n            var elements = fig.elements.getAllElements();\n            for (var i = 0; i < elements.length; i++) {\n                if (!elements[i].isShown)\n                    continue;\n                elements[i].custom.wasDisabled = { isTouchable: elements[i].isTouchable, isMovable: elements[i].isMovable, disabled: true };\n                if (elements[i].custom.canBeDisabled == null || elements[i].custom.canBeDisabled === true) {\n                    if (elements[i].isTouchable)\n                        elements[i].isTouchable = false;\n                    if (elements[i].isMovable)\n                        elements[i].isMovable = false;\n                    if (elements[i].custom.disabled !== true && elements[i].custom.disableInteraction) {\n                        elements[i].custom.disabled = true;\n                        elements[i].custom.disableInteraction();\n                    }\n                }\n            }\n            fig.custom.backgroundGesture.isTouchable = true;\n            for (var i = 0; i < fig.custom.disableInteractionCallbacks.length; i++)\n                fig.custom.disableInteractionCallbacks[i]();\n        };\n        fig.custom.enableInteraction = function () {\n            if (window._grokkoli_silent_log)\n                window._grokkoli_silent_log('enable');\n            else\n                console.log('enable');\n            fig.elements.setOpacity(1);\n            fig.custom.undullBrain();\n            fig.custom.undullHelp();\n            fig.custom.disabled = false;\n            var elements = fig.elements.getAllElements();\n            for (var i = 0; i < elements.length; i++) {\n                if (elements[i].custom && elements[i].custom.wasDisabled != null) {\n                    elements[i].isTouchable = elements[i].custom.wasDisabled.isTouchable;\n                    elements[i].isMovable = elements[i].custom.wasDisabled.isMovable;\n                    if (elements[i].custom.disabled && elements[i].custom.enableInteraction) {\n                        elements[i].custom.disabled = false;\n                        elements[i].custom.enableInteraction();\n                    }\n                }\n            }\n            for (var i = 0; i < fig.custom.enableInteractionCallbacks.length; i++)\n                fig.custom.enableInteractionCallbacks[i]();\n            fig.custom.backgroundGestureCallback = null;\n            fig.custom.backgroundGesture.hide();\n            fig.custom.backgroundGesture.isTouchable = false;\n        };\n        fig.custom.disableBackgroundGesture = function () { fig.custom.backgroundGestureCallback = null; fig.custom.backgroundGesture.hide(); fig.custom.backgroundGesture.isTouchable = false; };\n        fig.custom.jiggleGrokkoli = function () {\n            var el = document.getElementById('ghelp_grokkoli');\n            if (el) {\n                el.classList.remove('speaker_pulse');\n                el.offsetWidth;\n                el.classList.add('speaker_pulse');\n            }\n        };\n        fig.custom.throwException = function () {\n            var excepter = fig.add({ name: 'excepter', make: 'rectangle', width: 0.1, height: 0.1, color: [1, 0, 0, 1] });\n            excepter.setTouchable();\n            excepter.notifications.add('onClick', function () { throw new Error('Manual exception thrown'); });\n        };\n        window.createBadge = window.FigTools.createBadge;\n        window.createHoningBadges = window.FigTools.createHoningBadges;\n        window.createSessionSummary = window.FigTools.createSessionSummary;\n        window.showKeyboard = window.FigTools.showKeyboard;\n        // Re-register the fontsLoaded handler that was cleared during teardown.\n        // The original in createFigure updates contextState.lastFontsLoadedAt and\n        // cycles enable/disable interaction. We replicate the interaction cycling.\n        fig.fonts.notifications.add('fontsLoaded', function () {\n            var contextState = window.grokkoliWebGLContextTracker;\n            if (contextState)\n                contextState.lastFontsLoadedAt = performance.now();\n            if (fig.custom.willBeEnabled) {\n                // console.log('will be enabled');\n            }\n            else if (fig.custom.disabled) {\n                fig.custom.enableInteraction();\n                fig.custom.disableInteraction();\n            }\n        });\n        fig.instanceType = config.foundation.instanceType;\n        processZoomAvailability(config.helper);\n        questionMain(fig);\n        for (var _i = 0, _f = config.foundation.equations; _i < _f.length; _i++) {\n            var eqConfig = _f[_i];\n            createEquation(eqConfig);\n        }\n        if (config.foundation.autoCenter && config.foundation.autoCenter !== false) {\n            setupAutoCenter(config.foundation.autoCenter);\n        }\n        else if (config.foundation.autoCenter === false) {\n            window.autoCenter = function () { };\n        }\n    }\n    // Answer inputs\n    if (config.answerInputs) {\n        processAnswerInputs(config.answerInputs);\n    }\n    if (config.hint) {\n        processHint(config.hint);\n    }\n    if (config.speech) {\n        processSpeech(config.speech);\n    }\n    if (config.helper) {\n        processHelper(config.helper);\n    }\n    if (config.equationsData) {\n        processEquationsData(config.equationsData);\n    }\n    window._qc = config;\n    if (config.learner) {\n        var l = config.learner;\n        window.initParams = {};\n        window._secondsAfterCreation = l.secondsAfterCreation;\n        window._guid = l.guid;\n        if (l.inHoning)\n            window._grokkoli_in_honing = true;\n        if (l.catchJsErrors)\n            window._grokkoli_catch_js_errors = true;\n        if (l.questionId) {\n            fig.question_id = l.questionId;\n            window.grokkoli_question_id = l.questionId;\n        }\n        if (l.colors) {\n            for (var _g = 0, _h = Object.entries(l.colors); _g < _h.length; _g++) {\n                var _j = _h[_g], key = _j[0], value = _j[1];\n                fig.custom[key] = value;\n            }\n        }\n        if (l.transitionTimeout != null)\n            window._transitionTimeout = l.transitionTimeout;\n    }\n    try {\n        if (config.remainingJs) {\n            new Function(config.remainingJs)();\n        }\n        createTrainingFinger(config);\n        if (config.finalize) {\n            var customInit = void 0;\n            if (config.finalize.customInit) {\n                customInit = new Function(config.finalize.customInit);\n            }\n            finalizeQuestion(customInit);\n        }\n    }\n    finally {\n        setupAutoSpeakNotification(config);\n        if (!((_b = config.learner) === null || _b === void 0 ? void 0 : _b.consoleDebug))\n            removeConsoleHelpers();\n    }\n    lockForTraining(config);\n    if (config.learner && ((_c = config.finalize) === null || _c === void 0 ? void 0 : _c.instanceType) === 'question') {\n        var useAutospeak = ((_d = fig === null || fig === void 0 ? void 0 : fig.custom) === null || _d === void 0 ? void 0 : _d.transitionsAutospeak)\n            && willAutoSpeak(config);\n        var transitionFn = useAutospeak\n            ? fig.custom.transitionsAutospeak\n            : (_e = fig === null || fig === void 0 ? void 0 : fig.custom) === null || _e === void 0 ? void 0 : _e.transitions;\n        if (transitionFn) {\n            transitionFn(config.learner.secondsAfterCreation, config.learner.transitionTimeout, function () { return playQuestionSpeech(config); });\n        }\n        else {\n            playQuestionSpeech(config);\n        }\n    }\n    else {\n        playQuestionSpeech(config);\n    }\n    fig.questionReady = true;\n    if (fig.gesture) {\n        fig.gesture.enable = true;\n    }\n    setBringupTime(Math.round(performance.now() - bringupStart));\n}\n/**\n * SPA-style transition to next question.\n * Falls back to full page reload on error.\n */\nexport function transitionToNextQuestion() {\n    return __awaiter(this, void 0, void 0, function () {\n        var reloading, fig, csrftoken, response, data, err_1, e, msg, fig;\n        var _a, _b, _c, _d;\n        return __generator(this, function (_e) {\n            switch (_e.label) {\n                case 0:\n                    if (window._transitionInProgress)\n                        return [2 /*return*/];\n                    window._transitionInProgress = true;\n                    reloading = false;\n                    _e.label = 1;\n                case 1:\n                    _e.trys.push([1, 4, 5, 6]);\n                    fig = window.figure;\n                    if (fig.speechManager) {\n                        (_b = (_a = fig.speechManager).stopPlaying) === null || _b === void 0 ? void 0 : _b.call(_a);\n                    }\n                    if (fig.speech) {\n                        (_d = (_c = fig.speech).stop) === null || _d === void 0 ? void 0 : _d.call(_c);\n                    }\n                    csrftoken = document.querySelector('[name=csrfmiddlewaretoken]');\n                    return [4 /*yield*/, fetch('/question_config/', {\n                            method: 'POST',\n                            headers: {\n                                'X-CSRFToken': (csrftoken === null || csrftoken === void 0 ? void 0 : csrftoken.value) || '',\n                                'Content-Type': 'application/json',\n                                'X-Pointer': getPointerType(),\n                            },\n                        })];\n                case 2:\n                    response = _e.sent();\n                    if (!response.ok)\n                        throw new Error(\"HTTP \".concat(response.status));\n                    return [4 /*yield*/, response.json()];\n                case 3:\n                    data = _e.sent();\n                    if (data.redirect) {\n                        window.location.assign(data.redirect);\n                        return [2 /*return*/];\n                    }\n                    // Keep the document title current across SPA transitions (WCAG 2.4.2:\n                    // Page Titled). The server always sends a non-empty page_title; guard\n                    // anyway so a missing field can never blank the title or throw.\n                    if (data.page_title) {\n                        document.title = data.page_title;\n                    }\n                    // Swap the question DOM first, THEN snap the chrome to the new screen.\n                    // Syncing before reload would unhide the chrome while the previous\n                    // screen's DOM (e.g. a message) is still visible.  The bar animation\n                    // for the just-answered question already ran in response.ts before\n                    // this transition fired, so no animation call is needed here.\n                    reloadQuestion(data.question_config);\n                    if (window.syncProgressChrome) {\n                        window.syncProgressChrome(data);\n                    }\n                    return [3 /*break*/, 6];\n                case 4:\n                    err_1 = _e.sent();\n                    e = err_1;\n                    msg = (e && e.message) || String(err_1);\n                    // An Error serialises to {} in the captured console, so log its parts.\n                    console.error('Transition failed, falling back to reload:', msg, e && e.stack);\n                    // No `stack` field: logError would fetch the source files to annotate it\n                    // before posting, and the reload below would cancel that.\n                    logError({ msg: \"Transition failed: \".concat(msg), recovered: true }, 'transitionToNextQuestion', { stack: e && e.stack });\n                    fig = window.figure;\n                    if (fig && fig.state)\n                        fig.state.pause = 'paused';\n                    reloading = true;\n                    setTimeout(function () { return window.location.reload(); }, 1000);\n                    return [3 /*break*/, 6];\n                case 5:\n                    if (!reloading)\n                        window._transitionInProgress = false;\n                    return [7 /*endfinally*/];\n                case 6: return [2 /*return*/];\n            }\n        });\n    });\n}\n","/**\n * Timer - A generic timing checkpoint utility for the frontend\n *\n * Similar to the backend alpha/models/utils/timing.py module.\n * Allows creating multiple timers, recording checkpoints with deltas,\n * storing arbitrary data, and automatically sending timing data to the backend.\n *\n * Usage:\n *   import { startTimer, checkpoint, addData, stopTimer } from './question/timer';\n *\n *   // Start a timer with optional total timeout\n *   startTimer('my_operation', { totalTimeoutMs: 5000 });\n *\n *   // Record checkpoints with optional timeout for next checkpoint\n *   checkpoint('step_1', { nextTimeoutMs: 2000 });\n *   checkpoint('step_2');\n *   checkpoint('step_3', { fromCheckpoint: 'step_1' });\n *\n *   // Add arbitrary data\n *   addData('user_id', 123);\n *\n *   // Stop and optionally send to backend if duration >= threshold\n *   stopTimer({ threshold: 1000 });\n */\nvar __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nimport request from './request/request';\nimport { withSpeechToken } from '../tools/speech_token';\n// Initialize global storage\nif (typeof window !== 'undefined') {\n    if (window._timers == null) {\n        window._timers = {};\n    }\n    if (window._activeTimerId === undefined) {\n        window._activeTimerId = null;\n    }\n}\nvar DEFAULT_ENDPOINT = 'frontend_timing';\n/**\n * Send timing data to the backend.\n */\nfunction sendTimingToBackend(report, timerName, timedOutCheckpoint) {\n    request('POST', DEFAULT_ENDPOINT, \n    // Without the token the server has to resolve the learner through the session,\n    // which is four reads for a telemetry row - and it refuses an unauthenticated\n    // caller outright, so this is also what keeps the endpoint from being spammed.\n    withSpeechToken({\n        timer_id: timerName !== null && timerName !== void 0 ? timerName : report.timerId,\n        total_duration: report.totalDuration,\n        checkpoints: report.checkpoints,\n        data: report.data,\n        timed_out_checkpoint: timedOutCheckpoint,\n        question_id: window.grokkoli_question_id,\n    }), function () { }, 1000);\n}\n/**\n * Start a new timer with the given ID.\n *\n * @param timerId - Unique identifier for this timer\n * @param options - Optional configuration for timeouts and endpoint\n */\nexport function startTimer(timerId, options) {\n    var now = performance.now();\n    var timerName = options === null || options === void 0 ? void 0 : options.timerName;\n    window._timers[timerId] = {\n        startTime: now,\n        lastCheckpointTime: now,\n        lastCheckpointId: 'start',\n        checkpoints: [],\n        data: {},\n        timerName: timerName,\n    };\n    window._activeTimerId = timerId;\n    // Set up total timeout if specified\n    if ((options === null || options === void 0 ? void 0 : options.totalTimeoutMs) != null && options.totalTimeoutMs > 0) {\n        window._timers[timerId].totalTimeoutId = setTimeout(function () {\n            var report = getTimerReport(timerId);\n            if (report) {\n                sendTimingToBackend(report, timerName, 'total_timeout');\n            }\n        }, options.totalTimeoutMs);\n    }\n}\n/**\n * Record a timing checkpoint.\n *\n * @param checkpointId - Unique identifier for this checkpoint\n * @param options - Optional configuration for delta reference and next checkpoint timeout\n * @returns The delta time in milliseconds from the reference checkpoint\n */\nexport function checkpoint(checkpointId, options) {\n    var _a;\n    var id = (_a = options === null || options === void 0 ? void 0 : options.timerId) !== null && _a !== void 0 ? _a : window._activeTimerId;\n    if (id == null || window._timers[id] == null) {\n        console.warn(\"Timer '\".concat(id, \"' not found. Call startTimer() first.\"));\n        return 0;\n    }\n    var timer = window._timers[id];\n    var now = performance.now();\n    var fromCheckpoint = options === null || options === void 0 ? void 0 : options.fromCheckpoint;\n    // Clear any pending next-checkpoint timeout\n    if (timer.nextCheckpointTimeoutId != null) {\n        clearTimeout(timer.nextCheckpointTimeoutId);\n        timer.nextCheckpointTimeoutId = undefined;\n    }\n    // Determine reference checkpoint\n    var fromId;\n    var fromTime;\n    if (fromCheckpoint == null) {\n        fromId = timer.lastCheckpointId;\n        fromTime = timer.lastCheckpointTime;\n    }\n    else if (fromCheckpoint === 'start') {\n        fromId = 'start';\n        fromTime = timer.startTime;\n    }\n    else {\n        fromId = fromCheckpoint;\n        var found = timer.checkpoints.find(function (cp) { return cp.id === fromCheckpoint; });\n        if (found) {\n            fromTime = found.time;\n        }\n        else {\n            console.warn(\"Checkpoint '\".concat(fromCheckpoint, \"' not found, using last checkpoint\"));\n            fromId = timer.lastCheckpointId;\n            fromTime = timer.lastCheckpointTime;\n        }\n    }\n    var delta = Math.round(now - fromTime);\n    var elapsed = Math.round(now - timer.startTime);\n    var checkpointData = {\n        id: checkpointId,\n        time: now,\n        delta: delta,\n        from: fromId,\n        elapsed: elapsed,\n    };\n    timer.checkpoints.push(checkpointData);\n    timer.lastCheckpointTime = now;\n    timer.lastCheckpointId = checkpointId;\n    // Set up timeout for next checkpoint if specified\n    if ((options === null || options === void 0 ? void 0 : options.nextTimeoutMs) != null && options.nextTimeoutMs > 0) {\n        timer.nextCheckpointTimeoutId = setTimeout(function () {\n            var report = getTimerReport(id);\n            if (report) {\n                sendTimingToBackend(report, timer.timerName, checkpointId);\n            }\n        }, options.nextTimeoutMs);\n    }\n    return delta;\n}\n/**\n * Add a key-value pair to the timer's data dictionary.\n */\nexport function addData(key, value, timerId) {\n    var id = timerId !== null && timerId !== void 0 ? timerId : window._activeTimerId;\n    if (id == null || window._timers[id] == null) {\n        console.warn(\"Timer '\".concat(id, \"' not found. Call startTimer() first.\"));\n        return;\n    }\n    window._timers[id].data[key] = value;\n}\n/**\n * Get the current timer data (including data field).\n */\nexport function getData(timerId) {\n    var id = timerId !== null && timerId !== void 0 ? timerId : window._activeTimerId;\n    if (id == null || window._timers[id] == null) {\n        return {};\n    }\n    return __assign({}, window._timers[id].data);\n}\n/**\n * Stop a timer and return the full timing report.\n * Optionally sends timing data to backend based on threshold.\n *\n * @param options - Optional configuration for threshold-based backend sending\n */\nexport function stopTimer(options) {\n    var _a;\n    var id = (_a = options === null || options === void 0 ? void 0 : options.timerId) !== null && _a !== void 0 ? _a : window._activeTimerId;\n    if (id == null || window._timers[id] == null) {\n        console.warn(\"Timer '\".concat(id, \"' not found.\"));\n        return null;\n    }\n    var timer = window._timers[id];\n    var now = performance.now();\n    var totalDuration = Math.round(now - timer.startTime);\n    // Build the report\n    var report = {\n        timerId: id,\n        startTime: timer.startTime,\n        totalDuration: totalDuration,\n        checkpoints: timer.checkpoints.map(function (cp) { return ({\n            id: cp.id,\n            delta: cp.delta,\n            from: cp.from,\n            elapsed: cp.elapsed,\n        }); }),\n        data: __assign({}, timer.data),\n    };\n    // Clean up timeouts\n    if (timer.totalTimeoutId != null) {\n        clearTimeout(timer.totalTimeoutId);\n    }\n    if (timer.nextCheckpointTimeoutId != null) {\n        clearTimeout(timer.nextCheckpointTimeoutId);\n    }\n    // Send to backend if threshold is met\n    if ((options === null || options === void 0 ? void 0 : options.threshold) != null) {\n        var shouldSend = options.threshold === 0 || totalDuration >= options.threshold;\n        if (shouldSend) {\n            sendTimingToBackend(report, timer.timerName);\n        }\n    }\n    // Clean up timer\n    delete window._timers[id];\n    if (window._activeTimerId === id) {\n        window._activeTimerId = null;\n    }\n    return report;\n}\n/**\n * Get the current timing report without stopping the timer.\n */\nexport function getTimerReport(timerId) {\n    var id = timerId !== null && timerId !== void 0 ? timerId : window._activeTimerId;\n    if (id == null || window._timers[id] == null) {\n        return null;\n    }\n    var timer = window._timers[id];\n    var now = performance.now();\n    return {\n        timerId: id,\n        startTime: timer.startTime,\n        totalDuration: Math.round(now - timer.startTime),\n        checkpoints: timer.checkpoints.map(function (cp) { return ({\n            id: cp.id,\n            delta: cp.delta,\n            from: cp.from,\n            elapsed: cp.elapsed,\n        }); }),\n        data: __assign({}, timer.data),\n    };\n}\n/**\n * Check if a timer exists.\n */\nexport function hasTimer(timerId) {\n    return window._timers[timerId] != null;\n}\n/**\n * Get a specific checkpoint from a timer.\n */\nexport function getCheckpoint(checkpointId, timerId) {\n    var _a;\n    var id = timerId !== null && timerId !== void 0 ? timerId : window._activeTimerId;\n    if (id == null || window._timers[id] == null) {\n        return null;\n    }\n    return (_a = window._timers[id].checkpoints.find(function (cp) { return cp.id === checkpointId; })) !== null && _a !== void 0 ? _a : null;\n}\n/**\n * Cancel and remove a timer without generating a report.\n */\nexport function cancelTimer(timerId) {\n    var id = timerId !== null && timerId !== void 0 ? timerId : window._activeTimerId;\n    if (id == null || window._timers[id] == null) {\n        return;\n    }\n    var timer = window._timers[id];\n    if (timer.totalTimeoutId != null) {\n        clearTimeout(timer.totalTimeoutId);\n    }\n    if (timer.nextCheckpointTimeoutId != null) {\n        clearTimeout(timer.nextCheckpointTimeoutId);\n    }\n    delete window._timers[id];\n    if (window._activeTimerId === id) {\n        window._activeTimerId = null;\n    }\n}\n/**\n * Get all active timer IDs.\n */\nexport function getActiveTimerIds() {\n    return Object.keys(window._timers);\n}\n/**\n * Clear all timers.\n */\nexport function clearAllTimers() {\n    Object.keys(window._timers).forEach(function (id) {\n        var timer = window._timers[id];\n        if (timer.totalTimeoutId != null) {\n            clearTimeout(timer.totalTimeoutId);\n        }\n        if (timer.nextCheckpointTimeoutId != null) {\n            clearTimeout(timer.nextCheckpointTimeoutId);\n        }\n    });\n    window._timers = {};\n    window._activeTimerId = null;\n}\n","function startCriticalAnimation(id, delay, criticalFunc, onElement) {\n    if (onElement === void 0) { onElement = figure.elements; }\n    criticalAnimation(id, delay, criticalFunc, onElement);\n    onElement.animations\n        .new(id)\n        .delay(delay)\n        .trigger(function () {\n        criticalFunc();\n        clearCriticalAnimation(id);\n    })\n        .start();\n}\nfunction criticalAnimation(id, delay, // in seconds\ncriticalFunc, animationElement) {\n    if (delay === void 0) { delay = 0; }\n    if (figure.custom.criticalAnimations == null) {\n        figure.custom.criticalAnimations = {};\n    }\n    // console.log('delaying', delay * 1000 + 500, performance.now());\n    figure.custom.criticalAnimations[id] = setTimeout(function () {\n        // console.log('checking', id, performance.now());\n        // console.log(animationElement.isAnimating());\n        // If the animation is still going, then don't do the criticalFunc\n        if (animationElement.isAnimating()) {\n            for (var i = 0; i < animationElement.animations.animations.length; i += 1) {\n                if (animationElement.animations.animations[i].name === id) {\n                    // console.log(\n                    //   'cancelling',\n                    //   animationElement.animations.animations[i].name,\n                    // );\n                    animationElement.animations.cancel(id);\n                }\n            }\n        }\n        // console.log('executing critical func');\n        criticalFunc();\n    }, delay * 1000 + 500);\n}\nfunction clearCriticalAnimation(id) {\n    if (figure.custom.criticalAnimations != null &&\n        figure.custom.criticalAnimations[id] != null) {\n        // console.log('clearing timeout', id);\n        clearTimeout(figure.custom.criticalAnimations[id]);\n        figure.custom.criticalAnimations[id] = null;\n    }\n}\nexport { clearCriticalAnimation, criticalAnimation, startCriticalAnimation };\n","var AnswerResult = {\n    CORRECT: 1,\n    INCORRECT: 2,\n    TECHNICALLY_CORRECT: 3,\n    DONT_KNOW: 7,\n    INVALID: 4,\n    INVALID_EMPTY: 8,\n    INVALID_FRACTION: 9,\n    INVALID_REPEATER_AT_END: 10,\n    INVALID_REPEATER_DECIMAL: 11,\n    INVALID_MULTI_REPEATER: 12,\n    INVALID_REPEATER_DIGIT: 13,\n    INVALID_REPEATER_EMPTY: 14,\n    INVALID_POWER: 101,\n    INVALID_BACKWARDS: 102,\n    MESSAGE: 15,\n    DECISION: 16,\n    SLIDES: 17,\n    NEEDS_HELP: 18,\n    TIMEOUT: 19,\n    NOT_ANSWERED_NOT_NEEDED: 20,\n    CORRECT_STEP: 21,\n    CORRECT_BUT_WRONG_LOCATION: 22,\n};\nexport { AnswerResult, };\n","function setFontFamily(font, text) {\n    if (text === void 0) { text = null; }\n    if (font.family === 'text') {\n        font.family = defaultFontFamily;\n    }\n    if (font.family === 'math') {\n        font.family = defaultFontFamilyMath;\n    }\n    if (font.family === 'auto') {\n        var format = /[0123456789]/;\n        if (typeof text === 'string') {\n            if (format.test(text)) {\n                font.family = defaultFontFamilyMath;\n            }\n            else {\n                font.family = defaultFontFamily;\n            }\n        }\n    }\n    setAtlasId(font);\n}\n// Assigns a shared atlasId to a font so that fonts with the same family,\n// style, weight, glyphs, and size bracket share a single glyph atlas\n// (reducing GPU memory). Named subset glyph presets (latin/greek/math/\n// mathlatin/numbers) are promoted to their 'common' superset so they\n// collapse onto one atlas instead of one texture per subset. Also sets\n// atlasSize = 0.5 so the atlas fontSize is canvas.height * 0.5. Skips\n// fonts that already have an atlasId or use a custom src/id.\nfunction setAtlasId(font) {\n    if (!font || font.atlasId || font.src || font.id)\n        return;\n    var family = (font.family || 'arial').split(',')[0].toLowerCase();\n    var style = (font.style || 'normal').toLowerCase();\n    var weight = (font.weight || 'normal').toLowerCase();\n    // Normalize CSS weight keywords to numeric equivalents so fonts\n    // with weight 'normal' and '400' share the same atlas.\n    if (weight === 'normal')\n        weight = '400';\n    if (weight === 'bold')\n        weight = '700';\n    var glyphs = font.glyphs || 'common';\n    // Consolidate the named subset glyph presets onto a single superset\n    // atlas.  'common' (= latin + greek + math) is a strict superset of\n    // 'latin', 'greek', 'math', 'mathlatin' and 'numbers', so fonts that\n    // request any of those can share one atlas texture instead of\n    // allocating a separate texture per subset.  On GPU-memory-constrained\n    // devices the per-glyph atlases all clamp to MAX_TEXTURE_SIZE, so the\n    // dominant cost is the atlas *count*, not the glyph count — merging\n    // subsets is a net win there.\n    //\n    // font.glyphs is promoted too, not just the key: the atlas is\n    // rasterized from whichever font creates it first, so if only the key\n    // matched, a subset font (e.g. 'latin') could win the race and leave\n    // the superset glyphs ('greek'/'math') unrasterized for a 'common'\n    // font sharing the same atlasId, producing missing glyphs.\n    //\n    // 'all'/'mathExt' are NOT subsets of 'common' (mathExt has the extended\n    // operator range), and custom string/array glyph lists may contain\n    // glyphs outside 'common', so those are left untouched.\n    var commonSubsets = ['latin', 'greek', 'math', 'mathlatin', 'numbers', 'common'];\n    if (typeof glyphs === 'string' && commonSubsets.indexOf(glyphs) !== -1) {\n        glyphs = 'common';\n        font.glyphs = 'common';\n    }\n    var glyphKey = Array.isArray(glyphs) ? glyphs.slice().sort().join('+') : glyphs;\n    var mods = '';\n    if (font.modifiers && Object.keys(font.modifiers).length > 0) {\n        var h = 0;\n        var s = JSON.stringify(font.modifiers);\n        for (var i = 0; i < s.length; i++) {\n            h = ((h << 5) - h + s.charCodeAt(i)) | 0;\n        }\n        mods = \"-mods-\".concat(Math.abs(h).toString().slice(0, 5));\n    }\n    var size = font.size || 0;\n    var sizeBracket;\n    if (size <= 0.03)\n        sizeBracket = 'xs';\n    else if (size <= 0.1)\n        sizeBracket = 'sm';\n    else if (size <= 0.3)\n        sizeBracket = 'md';\n    else\n        sizeBracket = 'lg';\n    font.atlasId = \"\".concat(family, \"-\").concat(style, \"-\").concat(weight, \"-\").concat(glyphKey, \"-\").concat(sizeBracket).concat(mods);\n    if (font.atlasSize == null)\n        font.atlasSize = 0.08;\n}\nfunction createEquation(toAdd, options, yAlign) {\n    if (yAlign === void 0) { yAlign = 'middle'; }\n    var o = Fig.joinObjects({\n        font: {\n            size: 0.1,\n            color: [0.2, 0.2, 0.2, 1],\n            render: 'gl',\n            // family: null,\n            // style: 'normal',\n        },\n        equation_elements: {},\n        position: [0, 0],\n        scale: 1,\n        name: 'label',\n    }, options);\n    if (o.textFont == null) {\n        o.textFont = {};\n    }\n    setFontFamily(o.font);\n    setFontFamily(o.textFont);\n    var equationElements = {};\n    var equationMakeElements = {};\n    if (o.equation_elements != null) {\n        Object.keys(o.equation_elements).forEach(function (name) {\n            var e = o.equation_elements[name];\n            if (e.make != null) {\n                equationMakeElements[name] = e;\n                equationMakeElements[name].name = name;\n            }\n            else {\n                equationElements[name] = e;\n            }\n        });\n    }\n    var label = toAdd.add({\n        name: o.name,\n        make: 'equation',\n        elements: equationElements,\n        formDefaults: {\n            alignment: {\n                xAlign: 'center',\n                yAlign: yAlign,\n            },\n        },\n        font: o.font,\n        textFont: o.textFont,\n        xAlign: 'center',\n        yAlign: yAlign,\n        scale: o.scale,\n        position: o.position,\n        color: o.font.color,\n    });\n    label.collections = figure.collections;\n    Object.keys(equationMakeElements).forEach(function (name) {\n        label.add(equationMakeElements[name]);\n    });\n    label.addForms({ '0': o.label });\n    label.showForm('0');\n    return label;\n}\nexport { createEquation, setFontFamily, setAtlasId };\n","// @ts-nocheck\nfunction getCount(counter, key) {\n    if (counter[key] == null) {\n        counter[key] = 0;\n    }\n    else {\n        counter[key] += 1;\n    }\n    return counter[key];\n}\nfunction wrapBar(content, key) {\n    if (key === void 0) { key = 'right'; }\n    return {\n        bar: {\n            content: content,\n            side: key,\n            symbol: { __bar__: { symbol: 'bar', side: 'right', lineWidth: 0.004 } },\n            inSize: false,\n            space: key === 'right' ? 0.001 : -0.01,\n            top: 0.01,\n            bottom: 0.01,\n        },\n    };\n}\nfunction EqnPhrase(parent, description, phraseOptions) {\n    if (parent === void 0) { parent = null; }\n    if (description === void 0) { description = ''; }\n    this.parent = parent;\n    this.phraseOptions = phraseOptions;\n    this.content = [];\n    this.id = 'phrase';\n    this.cursor = false;\n    this.description = description;\n    this.defaultPhrase = false;\n    this.isEmpty = function () {\n        return this.content.length === 0;\n    };\n    this._dup = function (dupParent) {\n        var dup = new EqnPhrase(null, this.description, phraseOptions);\n        var content = [];\n        for (var i = 0; i < this.content.length; i += 1) {\n            content.push(this.content[i]._dup(dup));\n        }\n        dup.content = content;\n        dup.cursor = this.cursor;\n        dup.defaultPhrase = this.defaultPhrase;\n        dup.parent = dupParent;\n        return dup;\n    };\n    this.getAllElements = function () {\n        var elements = [];\n        for (var i = 0; i < this.content.length; i += 1) {\n            var elems = this.content[i].getAllElements();\n            for (var j = 0; j < elems.length; j += 1) {\n                elements.push(elems[j]);\n            }\n        }\n        return elements;\n    };\n    this.render = function (counter) {\n        this.symbolName = null;\n        var out = [];\n        if (this.cursor && this.content.length > 0) {\n            this.content[0].cursor = 'left';\n        }\n        for (var i = 0; i < this.content.length; i += 1) {\n            out.push(this.content[i].render(counter));\n        }\n        if (this.cursor && this.content.length == 0) {\n            out = wrapBar({\n                container: {\n                    content: { color: ['2', [0, 0, 0, 0]] },\n                    // width: 0,\n                    // height: 0.1,\n                },\n            }, 'left');\n        }\n        if (this.content.length === 0 && !this.defaultPhrase) {\n            this.symbolName = \"box\".concat(getCount(counter, 's'));\n            var symbol = {};\n            symbol[this.symbolName] = {\n                symbol: 'box',\n                lineWidth: 0.002,\n                color: [0.3, 0.3, 0.3, 1],\n            };\n            var content = out;\n            if (Array.isArray(content) && content.length === 0) {\n                content = { color: ['2', [0, 0, 0, 0]] };\n            }\n            out = {\n                container: {\n                    content: {\n                        box: {\n                            content: content,\n                            symbol: symbol,\n                            inSize: false,\n                            leftSpace: 0.001,\n                            rightSpace: 0.001,\n                            topSpace: 0.015,\n                            bottomSpace: 0.015,\n                        },\n                    },\n                },\n            };\n        }\n        this.cursor = false;\n        return out;\n    };\n    this.summarize = function () {\n        var summary = [];\n        for (var i = 0; i < this.content.length; i += 1) {\n            var c = this.content[i].summarize();\n            summary.push(c);\n        }\n        return summary;\n    };\n    this.create = function (defIn) {\n        var def = defIn;\n        if (typeof defIn == 'number') {\n            def = defIn.toString().split('');\n        }\n        else if (typeof defIn == 'string') {\n            def = defIn.split('');\n        }\n        else if (!Array.isArray(defIn)) {\n            def = [defIn];\n        }\n        for (var i = 0; i < def.length; i += 1) {\n            var d = def[i];\n            if (typeof d != 'object') {\n                this.content.push(new EqnElement(\"\".concat(d)));\n                continue;\n            }\n            if (d.frac != null) {\n                var frac = new EqnFrac(this.phraseOptions);\n                frac.parent = this;\n                this.content.push(frac);\n                frac.numerator.create(d.frac[0]);\n                frac.denominator.create(d.frac[1]);\n                continue;\n            }\n            if (d.mfrac != null) {\n                var mfrac = new EqnMixedFrac(this.phraseOptions);\n                mfrac.parent = this;\n                this.content.push(mfrac);\n                mfrac.whole.create(d.mfrac[0]);\n                mfrac.numerator.create(d.mfrac[1]);\n                mfrac.denominator.create(d.mfrac[2]);\n                continue;\n            }\n            if (d.root != null) {\n                var root = new EqnRoot(this.phraseOptions);\n                root.parent = this;\n                this.content.push(root);\n                root.content.create(d.root[0]);\n                continue;\n            }\n            if (d.repeater != null) {\n                if (Array.isArray(d.repeater) &&\n                    d.repeater.length == 1 &&\n                    d.repeater[0] === '') {\n                    continue;\n                }\n                var repeater = new EqnRepeater(this.phraseOptions);\n                repeater.parent = this;\n                this.content.push(repeater);\n                repeater.content.create(d.repeater);\n                continue;\n            }\n            if (d.brac != null) {\n                var brac = new EqnBrac(this.phraseOptions);\n                brac.parent = this;\n                this.content.push(brac);\n                brac.content.create(d.brac[0]);\n                continue;\n            }\n            if (d.pow != null) {\n                var pow = new EqnPow(this.phraseOptions);\n                pow.parent = this;\n                this.content.push(pow);\n                pow.content.create(d.pow[0]);\n                pow.superscript.create(d.pow[0]);\n                continue;\n            }\n        }\n    };\n}\nfunction EqnElement(text) {\n    this.parent = null;\n    this.id = 'text';\n    this.text = text;\n    this.cursor = false;\n    this.noDelete = false;\n    this.isEmpty = function () {\n        return false;\n    };\n    this.equationElementName = null;\n    this._dup = function (dupParent) {\n        var dup = new EqnElement(this.text);\n        dup.cursor = this.cursor;\n        dup.parent = dupParent;\n        return dup;\n    };\n    this.render = function (counter) {\n        this.equationElementName = \"\".concat(this.text, \"_\").concat(getCount(counter, this.text) + 1);\n        var out = this.equationElementName;\n        if (this.cursor) {\n            out = wrapBar(out, this.cursor);\n            this.cursor = false;\n        }\n        return out;\n    };\n    this.summarize = function () {\n        return this.text;\n    };\n    this.getAllElements = function () {\n        return [this];\n    };\n    this.getEquationElement = function (equation) {\n        return equation.elements[this.equationElementName];\n    };\n}\n// .########.########.....###.....######.\n// .##.......##.....##...##.##...##....##\n// .##.......##.....##..##...##..##......\n// .######...########..##.....##.##......\n// .##.......##...##...#########.##......\n// .##.......##....##..##.....##.##....##\n// .##.......##.....##.##.....##..######.\nfunction EqnFrac(phraseOptions) {\n    this.name = 'frac';\n    this.phraseOptions = phraseOptions;\n    this.numerator = new EqnPhrase(this, 'numerator', phraseOptions);\n    this.denominator = new EqnPhrase(this, 'denominator', phraseOptions);\n    this.order = ['numerator', 'denominator'];\n    this.vorder = ['numerator', 'denominator'];\n    this.symbol = { symbol: 'vinculum' };\n    this.leftSymbol = true;\n    this.parent = null;\n    this.noDelete = false;\n    this.id = 'func';\n    this.cursor = false;\n    this._dup = function (dupParent) {\n        var dup = new EqnFrac(phraseOptions);\n        dup.numerator = this.numerator._dup(dupParent);\n        dup.denominator = this.denominator._dup(dupParent);\n        dup.cursor = this.cursor;\n        dup.parent = dupParent;\n        return dup;\n    };\n    this.isEmpty = function () {\n        return this.numerator.isEmpty() && this.denominator.isEmpty();\n    };\n    this.render = function (counter) {\n        var symbolName = \"_vin\".concat(getCount(counter, '_vin'));\n        var symbol = {};\n        symbol[symbolName] = { symbol: 'vinculum', lineWidth: 0.006 };\n        var out = {\n            frac: {\n                numerator: this.numerator.render(counter),\n                denominator: this.denominator.render(counter),\n                symbol: symbol,\n                scale: this.phraseOptions.frac_scale,\n                numeratorSpace: 0.03,\n                denominatorSpace: 0.03,\n                offsetY: 0.03,\n                overhang: 0.03,\n            },\n        };\n        if (this.cursor) {\n            out = wrapBar(out, this.cursor);\n            this.cursor = false;\n        }\n        return out;\n    };\n    this.summarize = function () {\n        var out = { frac: [this.numerator.summarize(), this.denominator.summarize()] };\n        return out;\n    };\n    this.getAllElements = function () {\n        return this.numerator\n            .getAllElements()\n            .concat(this.denominator.getAllElements());\n    };\n}\n// .##.....##.########.########.....###.....######.\n// .###...###.##.......##.....##...##.##...##....##\n// .####.####.##.......##.....##..##...##..##......\n// .##.###.##.######...########..##.....##.##......\n// .##.....##.##.......##...##...#########.##......\n// .##.....##.##.......##....##..##.....##.##....##\n// .##.....##.##.......##.....##.##.....##..######.\nfunction EqnMixedFrac(phraseOptions) {\n    this.phraseOptions = phraseOptions;\n    this.name = 'mfrac';\n    this.whole = new EqnPhrase(this, 'whole', phraseOptions);\n    this.numerator = new EqnPhrase(this, 'numerator', phraseOptions);\n    this.denominator = new EqnPhrase(this, 'denominator', phraseOptions);\n    this.order = ['whole', 'numerator', 'denominator'];\n    this.vorder = ['whole', 'numerator', 'denominator'];\n    this.symbol = { symbol: 'vinculum' };\n    this.leftSymbol = true;\n    this.parent = null;\n    this.noDelete = false;\n    this.id = 'func';\n    this.cursor = false;\n    this._dup = function (dupParent) {\n        var dup = new EqnMixedFrac(phraseOptions);\n        dup.whole = this.whole._dup(dupParent);\n        dup.numerator = this.numerator._dup(dupParent);\n        dup.denominator = this.denominator._dup(dupParent);\n        dup.cursor = this.cursor;\n        dup.parent = dupParent;\n        return dup;\n    };\n    this.isEmpty = function () {\n        return (this.numerator.isEmpty() &&\n            this.denominator.isEmpty() &&\n            this.whole.isEmpty());\n    };\n    this.render = function (counter) {\n        var symbolName = \"_vin\".concat(getCount(counter, '_vin'));\n        var symbol = {};\n        symbol[symbolName] = { symbol: 'vinculum', lineWidth: 0.006 };\n        var out = [\n            this.whole.render(counter),\n            {\n                frac: {\n                    numerator: this.numerator.render(counter),\n                    denominator: this.denominator.render(counter),\n                    symbol: symbol,\n                    scale: 0.75,\n                    numeratorSpace: 0.03,\n                    denominatorSpace: 0.03,\n                    offsetY: 0.03,\n                    overhang: 0.03,\n                },\n            },\n        ];\n        if (this.cursor) {\n            out = wrapBar(out, this.cursor);\n            this.cursor = false;\n        }\n        return out;\n    };\n    this.summarize = function () {\n        out = {\n            mfrac: [\n                this.whole.summarize(),\n                this.numerator.summarize(),\n                this.denominator.summarize(),\n            ],\n        };\n        return out;\n    };\n    this.getAllElements = function () {\n        return this.whole\n            .getAllElements()\n            .concat(this.numerator\n            .getAllElements()\n            .concat(this.denominator.getAllElements()));\n    };\n}\n// .########...#######...#######..########\n// .##.....##.##.....##.##.....##....##...\n// .##.....##.##.....##.##.....##....##...\n// .########..##.....##.##.....##....##...\n// .##...##...##.....##.##.....##....##...\n// .##....##..##.....##.##.....##....##...\n// .##.....##..#######...#######.....##...\nfunction EqnRoot(phraseOptions) {\n    this.phraseOptions = phraseOptions;\n    this.name = 'root';\n    this.content = new EqnPhrase(this, 'content', phraseOptions);\n    this.order = ['content'];\n    this.vorder = ['content'];\n    this.symbol = { symbol: 'radical' };\n    this.leftSymbol = true;\n    this.parent = null;\n    this.noDelete = false;\n    this.id = 'func';\n    this.cursor = false;\n    this._dup = function (dupParent) {\n        var dup = new EqnRoot(this.phraseOptions);\n        dup.content = this.content._dup(dupParent);\n        dup.cursor = this.cursor;\n        dup.parent = dupParent;\n        return dup;\n    };\n    this.isEmpty = function () {\n        return this.content.isEmpty();\n    };\n    this.getAllElements = function () {\n        return this.content.getAllElements();\n    };\n    this.render = function (counter) {\n        var symbolName = \"_radical\".concat(getCount(counter, '_radical'));\n        var symbol = {};\n        symbol[symbolName] = {\n            symbol: 'radical',\n            lineWidth: 0.006,\n            lineWidth2: 0.006,\n        };\n        var out = {\n            root: {\n                content: this.content.render(counter),\n                symbol: symbol,\n                leftSpace: 0.005,\n                bottomSpace: 0.005,\n                topSpace: 0.01,\n            },\n        };\n        if (this.cursor) {\n            out = wrapBar(out, this.cursor);\n            this.cursor = false;\n        }\n        return out;\n    };\n    this.summarize = function () {\n        return { root: [this.content.summarize()] };\n    };\n}\n//  .########..########.########.\n//  .##.....##.##.......##.....##\n//  .##.....##.##.......##.....##\n//  .########..######...########.\n//  .##...##...##.......##.......\n//  .##....##..##.......##.......\n//  .##.....##.########.##.......\nfunction EqnRepeater(phraseOptions) {\n    this.phraseOptions = phraseOptions;\n    this.name = 'repeater';\n    this.content = new EqnPhrase(this, 'content', phraseOptions);\n    this.order = ['content'];\n    this.vorder = ['content'];\n    this.symbol = { symbol: 'bar' };\n    this.leftSymbol = true;\n    this.parent = null;\n    this.noDelete = false;\n    this.id = 'func';\n    this.cursor = false;\n    this._dup = function (dupParent) {\n        var dup = new EqnRoot(this.phraseOptions);\n        dup.content = this.content._dup(dupParent);\n        dup.cursor = this.cursor;\n        dup.parent = dupParent;\n        return dup;\n    };\n    this.isEmpty = function () {\n        return this.content.isEmpty();\n    };\n    this.getAllElements = function () {\n        return this.content.getAllElements();\n    };\n    this.render = function (counter) {\n        var symbolName = \"_bar\".concat(getCount(counter, '_bar'));\n        var symbol = {};\n        symbol[symbolName] = { symbol: 'bar', side: 'top', lineWidth: 0.01 };\n        var out = {\n            bar: {\n                content: this.content.render(counter),\n                symbol: symbol,\n                space: 0.01,\n            },\n        };\n        if (this.cursor) {\n            out = wrapBar(out, this.cursor);\n            this.cursor = false;\n        }\n        return out;\n    };\n    this.summarize = function () {\n        return { repeater: this.content.summarize() };\n    };\n}\n// .########..########.....###.....######.\n// .##.....##.##.....##...##.##...##....##\n// .##.....##.##.....##..##...##..##......\n// .########..########..##.....##.##......\n// .##.....##.##...##...#########.##......\n// .##.....##.##....##..##.....##.##....##\n// .########..##.....##.##.....##..######.\nfunction EqnBrac(phraseOptions) {\n    this.phraseOptions = phraseOptions;\n    this.name = 'brac';\n    this.content = new EqnPhrase(this, 'content', phraseOptions);\n    this.order = ['content'];\n    this.vorder = ['content'];\n    this.symbol = { symbol: 'radical' };\n    this.leftSymbol = true;\n    this.parent = null;\n    this.noDelete = false;\n    this.id = 'brac';\n    this.cursor = false;\n    this._dup = function (dupParent) {\n        var dup = new EqnBrac(this.phraseOptions);\n        dup.content = this.content._dup(dupParent);\n        dup.cursor = this.cursor;\n        dup.parent = dupParent;\n        return dup;\n    };\n    this.isEmpty = function () {\n        return this.content.isEmpty();\n    };\n    this.getAllElements = function () {\n        return this.content.getAllElements();\n    };\n    this.render = function (counter) {\n        var leftSymbolName = \"_leftBrac\".concat(getCount(counter, '_leftBrac'));\n        var rightSymbolName = \"_rightBrac\".concat(getCount(counter, '_rightBrac'));\n        var leftSymbol = {};\n        leftSymbol[leftSymbolName] = {\n            symbol: 'bracket',\n            side: 'left',\n            lineWidth: 0.008,\n        };\n        var rightSymbol = {};\n        rightSymbol[rightSymbolName] = {\n            symbol: 'bracket',\n            side: 'right',\n            lineWidth: 0.008,\n        };\n        var out = {\n            brac: {\n                content: this.content.render(counter),\n                left: leftSymbol,\n                right: rightSymbol,\n                insideSpace: 0.01,\n                outsideSpace: 0.02,\n                topSpace: 0.02,\n                bottomSpace: 0.02,\n            },\n        };\n        if (this.cursor) {\n            out = wrapBar(out, this.cursor);\n            this.cursor = false;\n        }\n        return out;\n    };\n    this.summarize = function () {\n        return { brac: [this.content.summarize()] };\n    };\n}\n// .########...#######..##......##\n// .##.....##.##.....##.##..##..##\n// .##.....##.##.....##.##..##..##\n// .########..##.....##.##..##..##\n// .##........##.....##.##..##..##\n// .##........##.....##.##..##..##\n// .##.........#######...###..###.\nfunction EqnPow(phraseOptions) {\n    this.phraseOptions = phraseOptions;\n    this.name = 'pow';\n    this.content = new EqnPhrase(this, 'content', phraseOptions);\n    this.superscript = new EqnPhrase(this, 'superscript', phraseOptions);\n    this.order = ['content', 'superscript'];\n    this.vorder = ['superscript', 'content'];\n    this.leftSymbol = false;\n    this.parent = null;\n    this.noDelete = false;\n    this.id = 'func';\n    this.cursor = false;\n    this._dup = function (dupParent) {\n        var dup = new EqnPow(this.phraseOptions);\n        dup.content = this.content._dup(dupParent);\n        dup.superscript = this.superscript._dup(dupParent);\n        dup.cursor = this.cursor;\n        dup.parent = dupParent;\n        return dup;\n    };\n    this.isEmpty = function () {\n        return this.content.isEmpty() && this.superscript.isEmpty();\n    };\n    this.getAllElements = function () {\n        return this.content\n            .getAllElements()\n            .concat(this.superscript.getAllElements());\n    };\n    this.render = function (counter) {\n        var out = {\n            sup: {\n                content: this.content.render(counter),\n                superscript: this.superscript.render(counter),\n                offset: [-0.015, 0],\n            },\n        };\n        if (this.cursor) {\n            out = wrapBar(out, this.cursor);\n            this.cursor = false;\n        }\n        return out;\n    };\n    this.summarize = function () {\n        return { pow: [this.content.summarize(), this.superscript.summarize()] };\n    };\n}\nvar eqnFuncs = {\n    frac: EqnFrac,\n    mfrac: EqnMixedFrac,\n    root: EqnRoot,\n    repeater: EqnRepeater,\n    pow: EqnPow,\n    brac: EqnBrac,\n};\n// .########..#######..##.....##....###....########.####..#######..##....##\n// .##.......##.....##.##.....##...##.##......##.....##..##.....##.###...##\n// .##.......##.....##.##.....##..##...##.....##.....##..##.....##.####..##\n// .######...##.....##.##.....##.##.....##....##.....##..##.....##.##.##.##\n// .##.......##..##.##.##.....##.#########....##.....##..##.....##.##..####\n// .##.......##....##..##.....##.##.....##....##.....##..##.....##.##...###\n// .########..#####.##..#######..##.....##....##....####..#######..##....##\nfunction Eqn(equationElement, endCursor, phraseOptions) {\n    if (endCursor === void 0) { endCursor = true; }\n    if (phraseOptions === void 0) { phraseOptions = {}; }\n    this.phrase = new EqnPhrase(null, '', phraseOptions);\n    this.phraseOptions = phraseOptions;\n    this.phrase.defaultPhrase = true;\n    this.cursorIndex = 0;\n    // if (!endCursor) {\n    //   this.cursorIndex = 1;\n    // }\n    this.counter = {};\n    this.equationElement = equationElement;\n    this.history = [];\n    this.maxHistoryLength = 10;\n    this.cursorBlinkTimeout = null;\n    this.disabled = false;\n    this.endCursor = endCursor;\n}\nEqn.prototype.reset = function () {\n    this.phrase = new EqnPhrase(null, '', this.phraseOptions);\n    // As in the constructor: the top-level phrase draws no placeholder box\n    // when empty (only nested empty slots, like a blank numerator, do).\n    this.phrase.defaultPhrase = true;\n    this.history = [];\n};\nEqn.prototype._dup = function () {\n    var dup = new Eqn(this.equationElement, this.endCursor, this.phraseOptions);\n    dup.phrase = this.phrase._dup(dup);\n    dup.cursorIndex = this.cursorIndex;\n    return dup;\n};\nEqn.prototype.pushHistory = function () {\n    if (this.history.length > this.maxHistoryLength) {\n        this.history.shift();\n    }\n    this.history.push(this._dup());\n};\nEqn.prototype.popHistory = function () {\n    if (this.history.length === 0) {\n        return;\n    }\n    var dup = this.history.pop();\n    this.phrase = dup.phrase;\n    this.phrase.parent = this;\n    this.cursorIndex = dup.cursorIndex;\n    this.render();\n};\nEqn.prototype.getAllElements = function () {\n    return this.phrase.getAllElements();\n};\nEqn.prototype.getClosestElement = function (phrase, position, space) {\n    var _this = this;\n    if (space === void 0) { space = 'local'; }\n    var elements = phrase.getAllElements();\n    var boxes = [];\n    Object.keys(this.equationElement.elements).forEach(function (key) {\n        if (key.startsWith('box')) {\n            var element_1 = _this.equationElement.elements[key];\n            if (element_1.isShown) {\n                boxes.push(element_1);\n            }\n        }\n    });\n    if (elements.length === 0 && boxes.length === 0) {\n        return [null, null];\n    }\n    var pos = new Fig.Point(position);\n    var minDistance = 100;\n    var minIndex = 0;\n    var return_element;\n    var element;\n    for (var i = 0; i < elements.length; i += 1) {\n        var e = elements[i].getEquationElement(this.equationElement);\n        var r = e.getBoundingRect(space);\n        var p_1 = new Fig.Point(r.left + r.width / 2, r.bottom + r.height / 2);\n        // const p = element.getPosition(space);\n        var distance = p_1.distance(position);\n        if (distance < minDistance) {\n            minIndex = i;\n            minDistance = distance;\n        }\n        element = elements[minIndex].getEquationElement(this.equationElement);\n        return_element = elements[minIndex];\n    }\n    for (var i = 0; i < boxes.length; i += 1) {\n        var e = boxes[i];\n        var r = e.getBoundingRect(space);\n        var p_2 = new Fig.Point(r.left + r.width / 2, r.bottom + r.height / 2);\n        var distance = p_2.distance(position);\n        if (distance < minDistance) {\n            return_element = e;\n            element = e;\n            minDistance = distance;\n        }\n    }\n    var rect = element.getBoundingRect(space);\n    var p = element.getPosition(space);\n    var leftDistance = position.distance(p);\n    var rightDistance = position.distance(p.add(rect.width, 0));\n    return [return_element, leftDistance < rightDistance ? 'left' : 'right'];\n};\nEqn.prototype.calcLength = function (element) {\n    if (element.id === 'text') {\n        return 1;\n    }\n    var len = 0;\n    if (element.id == 'phrase') {\n        for (var i = 0; i < element.content.length; i += 1) {\n            len += this.calcLength(element.content[i]);\n        }\n        return len + 1;\n    }\n    for (var i = 0; i < element.order.length; i += 1) {\n        len += this.calcLength(element[element.order[i]]);\n        if (i === 0 && element.leftSymbol === false) {\n            len -= 1;\n        }\n    }\n    return len + 1;\n};\nEqn.prototype.getLength = function () {\n    return this.calcLength(this.phrase) - 1;\n};\nEqn.prototype.getPhraseIndex = function (indexToFind) {\n    var index = 0;\n    var result = null;\n    var eqnLength = this.getLength();\n    function processElement(e) {\n        if (e.id === 'phrase') {\n            if (indexToFind == index) {\n                result = [e, 0];\n                return;\n            }\n            if (e.content.length === 0 && indexToFind === index + 1) {\n                result = [e, 0];\n                return;\n            }\n            for (var i = 0; i < e.content.length; i += 1) {\n                if (index + 1 === indexToFind) {\n                    if (e.content[i].id === 'text') {\n                        result = [e, i + 1];\n                        return;\n                    }\n                }\n                if (e.content[i].id !== 'text') {\n                    processElement(e.content[i]);\n                    if (result != null) {\n                        return;\n                    }\n                    if (index === indexToFind) {\n                        result = [e, i + 1];\n                        if (i + 1 > e.content.length - 1) {\n                            result = [e, -1];\n                        }\n                        return;\n                    }\n                }\n                else {\n                    index += 1;\n                }\n            }\n            if (e.content.length === 0) {\n                index += 1;\n            }\n            return;\n        }\n        for (var i = 0; i < e.order.length; i += 1) {\n            if (e[e.order[i]].content.length > 0) {\n                index += 1;\n            }\n            if (i === 0 && !e.leftSymbol && e[e.order[i]].content.length > 0) {\n                index -= 1;\n            }\n            processElement(e[e.order[i]]);\n            if (result != null) {\n                return;\n            }\n        }\n        index += 1;\n    }\n    processElement(this.phrase, false);\n    if (result == null) {\n        return [this.phrase, -1];\n    }\n    return result;\n};\nEqn.prototype.getFraction = function () {\n    function processElement(e) {\n        if (e.name === 'frac') {\n            return e;\n        }\n        for (var i = 0; i < e.content.length; i += 1) {\n            var result_1 = processElement(e.content[i]);\n            if (result_1 != null) {\n                return result_1;\n            }\n        }\n        return null;\n    }\n    var result = processElement(this.phrase);\n    if (result != null) {\n        var elements = result.getAllElements();\n        var out = [];\n        for (var i = 0; i < elements.length; i += 1) {\n            out.push(elements[i].getEquationElement(this.equationElement));\n        }\n        out.push(this.equationElement.get('_vin0'));\n        out.push(this.equationElement.get('box0'));\n        out.push(this.equationElement.get('box1'));\n        out.push(this.equationElement.get('__bar__'));\n        return out;\n    }\n    return null;\n};\nEqn.prototype.getVinculum = function () {\n    return this.equationElement.get('_vin0');\n};\nEqn.prototype.getNumerator = function (description) {\n    if (description === void 0) { description = 'numerator'; }\n    function processElement(e) {\n        if (e.description === description) {\n            return e;\n        }\n        if (e[description] != null) {\n            return e[description];\n        }\n        if (e.content != null) {\n            for (var i = 0; i < e.content.length; i += 1) {\n                var result_2 = processElement(e.content[i]);\n                if (result_2 != null) {\n                    return result_2;\n                }\n            }\n        }\n        return null;\n    }\n    var result = processElement(this.phrase);\n    if (result != null) {\n        var elements = result.getAllElements();\n        var out = [];\n        for (var i = 0; i < elements.length; i += 1) {\n            out.push(elements[i].getEquationElement(this.equationElement));\n        }\n        if (result.symbolName != null) {\n            out.push(this.equationElement.get(result.symbolName));\n        }\n        return out;\n    }\n    return null;\n};\nEqn.prototype.getDenominator = function () {\n    return Eqn.prototype.getNumerator.call(this, 'denominator');\n};\nEqn.prototype.getWhole = function () {\n    return Eqn.prototype.getNumerator.call(this, 'whole');\n};\nEqn.prototype.getIndexFromElement = function (element) {\n    var index = 0;\n    var beforeCursorIndex = null;\n    var afterCursorIndex = null;\n    var eqnLength = this.getLength();\n    var inTargetElement = false;\n    var phrase = null;\n    var phraseIndex = null;\n    var boxCounter = 0;\n    function processElement(e) {\n        if (e.id === 'phrase') {\n            for (var i = 0; i < e.content.length; i += 1) {\n                if (e.content[i] == element) {\n                    beforeCursorIndex = index;\n                    phraseIndex = i + 1;\n                    if (i + 1 > e.content[i].length - 1) {\n                        phraseIndex = -1;\n                    }\n                    phrase = e;\n                    inTargetElement = e;\n                }\n                if (inTargetElement == e && e.content[i].id == 'text') {\n                    afterCursorIndex = index + 1;\n                    return;\n                }\n                if (inTargetElement && e.content[i] !== element) {\n                    afterCursorIndex = index;\n                    return;\n                }\n                if (e.content[i].id != 'text') {\n                    processElement(e.content[i]);\n                }\n                if (afterCursorIndex != null) {\n                    return;\n                }\n                index += 1;\n            }\n            return;\n        }\n        for (var i = 0; i < e.order.length; i += 1) {\n            index += 1;\n            if (i === 0 && !e.leftSymbol && e[e.order[i]].content.length > 0) {\n                index -= 1;\n            }\n            if (e[e.order[i]].content.length === 0) {\n                if (element.type === 'primitive') {\n                    if (element.name === \"box\".concat(boxCounter)) {\n                        beforeCursorIndex = index;\n                        afterCursorIndex = index;\n                        return;\n                    }\n                    boxCounter += 1;\n                }\n                continue;\n            }\n            processElement(e[e.order[i]]);\n            if (afterCursorIndex != null) {\n                return;\n            }\n        }\n    }\n    processElement(this.phrase, 0);\n    if (beforeCursorIndex != null && afterCursorIndex == null) {\n        afterCursorIndex = index;\n    }\n    return [beforeCursorIndex, afterCursorIndex, phrase, phraseIndex];\n};\nEqn.prototype.getCursorIndexFromPhrase = function (phrase) {\n    var index = 0;\n    var eqnLength = this.getLength();\n    var result = null;\n    function processElement(e) {\n        if (e.id === 'phrase') {\n            if (e === phrase) {\n                result = index;\n                return;\n            }\n            for (var i = 0; i < e.content.length; i += 1) {\n                if (e.content[i].id != 'text') {\n                    processElement(e.content[i]);\n                }\n                if (result != null) {\n                    return;\n                }\n                index += 1;\n            }\n            return;\n        }\n        for (var i = 0; i < e.order.length; i += 1) {\n            index += 1;\n            if (i === 0 && !e.leftSymbol && e[e.order[i]].content.length > 0) {\n                index -= 1;\n            }\n            processElement(e[e.order[i]]);\n            if (result != null) {\n                return;\n            }\n        }\n    }\n    processElement(this.phrase);\n    return result;\n};\nEqn.prototype.getElementAtIndex = function (index) {\n    if (index == 0 || this.phrase.content.length === 0) {\n        return null;\n    }\n    var _a = this.getPhraseIndex(index), phrase = _a[0], phraseIndex = _a[1];\n    if (phraseIndex == 0) {\n        return null;\n    }\n    if (phraseIndex == -1) {\n        return phrase.content.slice(-1)[0];\n    }\n    return phrase.content[phraseIndex - 1];\n};\nEqn.prototype.getElementAtCursor = function () {\n    return this.getElementAtIndex(this.cursorIndex);\n};\nEqn.prototype.getlastIndex = function (element) {\n    var index = 0;\n    var eqnLength = this.getLength();\n    var phrase = null;\n    var phraseIndex = null;\n    var boxCounter = 0;\n    function processElement(e) {\n        if (e.id === 'phrase') {\n            for (var i = 0; i < e.content.length; i += 1) {\n                if (e.content[i].id != 'text') {\n                    processElement(e.content[i]);\n                }\n                index += 1;\n            }\n            return;\n        }\n        for (var i = 0; i < e.order.length; i += 1) {\n            index += 1;\n            if (i === 0 && !e.leftSymbol && e[e.order[i]].content.length > 0) {\n                index -= 1;\n            }\n            processElement(e[e.order[i]]);\n        }\n    }\n    processElement(this.phrase, 0);\n    return index;\n};\nEqn.prototype.add = function (element, noDelete) {\n    if (noDelete === void 0) { noDelete = false; }\n    if (this.disabled) {\n        return;\n    }\n    if (this.getLength() === 1) {\n        if (this.phrase.content[0].text != null &&\n            this.phrase.content[0].text === '0' &&\n            this.cursorIndex === 1) {\n            if (element !== '.') {\n                this.delete();\n                return this.add(element);\n            }\n        }\n    }\n    this.pushHistory();\n    var elementToAdd = element;\n    if (eqnFuncs[element] != null) {\n        elementToAdd = new eqnFuncs[element](this.phraseOptions);\n    }\n    else {\n        elementToAdd = new EqnElement(element);\n    }\n    elementToAdd.noDelete = noDelete;\n    var _a = this.getPhraseIndex(this.cursorIndex), list = _a[0], index = _a[1];\n    elementToAdd.parent = list;\n    if (index === -1) {\n        list.content.push(elementToAdd);\n    }\n    else {\n        list.content.splice(index, 0, elementToAdd);\n    }\n    this.cursorIndex += 1;\n    this.render();\n};\nEqn.prototype.getCursorPosition = function () {\n    return this.equationElement.get('__bar__').getPosition();\n};\nEqn.prototype.getCursorPositions;\nEqn.prototype.down = function () {\n    var _a = this.getPhraseIndex(this.cursorIndex), phrase = _a[0], phraseIndex = _a[1];\n    function getBelowPhrase(phraseUp) {\n        if (phraseUp.parent == null) {\n            return null;\n        }\n        var vOrder = phraseUp.parent.vorder;\n        var vIndex = vOrder.indexOf(phraseUp.description);\n        if (vIndex === vOrder.length - 1) {\n            return getBelowPhrase(phraseUp.parent.parent);\n        }\n        return phraseUp.parent[vOrder[vIndex + 1]];\n    }\n    var belowPhrase = getBelowPhrase(phrase);\n    if (belowPhrase == null) {\n        return;\n    }\n    var _b = this.getClosestElement(belowPhrase, this.getCursorPosition()), closestElement = _b[0], side = _b[1];\n    if (closestElement === null) {\n        this.cursorIndex = this.getCursorIndexFromPhrase(belowPhrase);\n    }\n    else {\n        var _c = this.getIndexFromElement(closestElement), beforeCursorIndex = _c[0], afterCursorIndex = _c[1];\n        this.cursorIndex = side === 'left' ? beforeCursorIndex : afterCursorIndex;\n    }\n    this.render();\n};\nEqn.prototype.up = function () {\n    var _a = this.getPhraseIndex(this.cursorIndex), phrase = _a[0], phraseIndex = _a[1];\n    function getAbovePhrase(phraseDown) {\n        if (phraseDown.parent == null) {\n            return null;\n        }\n        var vOrder = phraseDown.parent.vorder;\n        var vIndex = vOrder.indexOf(phraseDown.description);\n        if (vIndex === 0) {\n            return getAbovePhrase(phraseDown.parent.parent);\n        }\n        return phraseDown.parent[vOrder[vIndex - 1]];\n    }\n    var abovePhrase = getAbovePhrase(phrase);\n    if (abovePhrase == null) {\n        return;\n    }\n    var _b = this.getClosestElement(abovePhrase, this.getCursorPosition()), closestElement = _b[0], side = _b[1];\n    if (closestElement === null) {\n        this.cursorIndex = this.getCursorIndexFromPhrase(abovePhrase);\n    }\n    else {\n        var _c = this.getClosestElement(abovePhrase, this.getCursorPosition()), closestElement_1 = _c[0], side_1 = _c[1];\n        var _d = this.getIndexFromElement(closestElement_1), beforeCursorIndex = _d[0], afterCursorIndex = _d[1];\n        this.cursorIndex = side_1 === 'left' ? beforeCursorIndex : afterCursorIndex;\n    }\n    this.render();\n};\nEqn.prototype.isAtStart = function () {\n    var min = this.endCursor ? 0 : 1;\n    return this.cursorIndex <= min;\n};\nEqn.prototype.isAtEnd = function () {\n    var max = this.endCursor ? this.getLength() : this.getLength() - 1;\n    return this.cursorIndex >= max;\n};\nEqn.prototype.left = function () {\n    if (this.endCursor) {\n        this.cursorIndex = Math.max(this.cursorIndex - 1, 0);\n    }\n    else {\n        this.cursorIndex = Math.max(this.cursorIndex - 1, 1);\n    }\n    this.render();\n};\nEqn.prototype.right = function () {\n    if (this.endCursor) {\n        this.cursorIndex = Math.min(this.getLength(), this.cursorIndex + 1);\n    }\n    else {\n        this.cursorIndex = Math.min(this.getLength() - 1, this.cursorIndex + 1);\n    }\n    this.render();\n};\nEqn.prototype.delete = function (index) {\n    var _a;\n    if (index === void 0) { index = this.cursorIndex; }\n    if (index === 0 || this.phrase.content.length === 0) {\n        return;\n    }\n    var _b = this.getPhraseIndex(index), phrase = _b[0], phraseIndex = _b[1];\n    var element = null;\n    if (phrase.parent != null &&\n        phrase.parent.id === 'func' &&\n        phrase.parent.isEmpty()) {\n        element = phrase.parent;\n    }\n    else if (phraseIndex === 0) {\n        this.left();\n        return;\n    }\n    else {\n        element = this.getElementAtIndex(index);\n    }\n    if (element.noDelete) {\n        return;\n    }\n    this.pushHistory();\n    var beforeCursorIndex;\n    var afterCursorIndex;\n    _a = this.getIndexFromElement(element), beforeCursorIndex = _a[0], afterCursorIndex = _a[1], phrase = _a[2], phraseIndex = _a[3];\n    // [phrase, phraseIndex] = this.getIndex(afterIndex)\n    this.cursorIndex = beforeCursorIndex;\n    if (phraseIndex == 0) {\n    }\n    else if (phraseIndex == -1) {\n        phrase.content.splice(-1, 1);\n    }\n    else {\n        phrase.content.splice(phraseIndex - 1, 1);\n    }\n    this.render();\n};\nEqn.prototype.blink = function (init) {\n    var _this = this;\n    if (init === void 0) { init = true; }\n    // Guard against zombie setTimeout firing after the equation has been\n    // torn down: figureone clears `.elements` on teardown, so\n    // equationElement.get('__bar__') would throw reading '__bar__' on null.\n    if (this.equationElement == null || this.equationElement.elements == null) {\n        return;\n    }\n    var cursor = this.equationElement.get('__bar__');\n    if (cursor == null)\n        return;\n    cursor.show();\n    if (init) {\n        cursor.setOpacity(0.0001);\n    }\n    if (cursor.opacity === 1) {\n        cursor.setOpacity(0.0001);\n    }\n    else if (this.disabled === false) {\n        cursor.setOpacity(1);\n    }\n    clearTimeout(this.cursorBlinkTimeout);\n    this.cursorBlinkTimeout = setTimeout(function () { return _this.blink(false); }, 500);\n    if (!window.__timeoutKeys) {\n        window.__timeoutKeys = {};\n    }\n    window.__timeoutKeys[\"cursor_eqn_\".concat(this.equationElement.getPath())] = this.cursorBlinkTimeout;\n};\nEqn.prototype.hideCursor = function () {\n    if (this.cursorBlinkTimeout != null) {\n        clearTimeout(this.cursorBlinkTimeout);\n        this.cursorBlinkTimeout = null;\n    }\n    var cursor = this.equationElement.get('__bar__');\n    cursor.hide();\n};\nEqn.prototype.disable = function () {\n    this.hideCursor();\n    var c = this.equationElement.get('__bar__').color.slice();\n    this.equationElement.get('__bar__').setColor([c[0], c[1], c[2], 0]);\n    this.disabled = true;\n};\nEqn.prototype.enable = function () {\n    this.hideCursor();\n    this.blink();\n    var bar = this.equationElement.get('__bar__');\n    if (bar != null) {\n        var c = bar.color.slice();\n        bar.setColor([c[0], c[1], c[2], 1]);\n    }\n    this.disabled = false;\n};\nEqn.prototype.summarize = function () {\n    return this.phrase.summarize();\n};\nEqn.prototype.render = function () {\n    if (this.cursorBlinkTimeout != null) {\n        clearTimeout(this.cursorBlinkTimeout);\n        this.cursorBlinkTimeout = null;\n    }\n    var _a = this.getPhraseIndex(this.cursorIndex), phrase = _a[0], phraseIndex = _a[1];\n    if (phraseIndex == 0 || phrase.content.length === 0) {\n        phrase.cursor = 'left';\n    }\n    else if (phraseIndex === -1) {\n        phrase.content.slice(-1)[0].cursor = 'right';\n    }\n    else {\n        phrase.content[phraseIndex - 1].cursor = 'right';\n    }\n    this.counter = {};\n    var form = this.phrase.render(this.counter);\n    figure.elements.clear();\n    this.equationElement.addForms({ '0': form });\n    this.equationElement.layoutForms('all');\n    this.equationElement.get('__bar__').hide();\n    if (this.disabled == false) {\n        this.blink();\n    }\n};\nexport default Eqn;\n","var NotificationHelper = /** @class */ (function () {\n    function NotificationHelper() {\n        this.ids = [];\n    }\n    NotificationHelper.prototype.add = function (element, notification, callback, num) {\n        if (num === void 0) { num = -1; }\n        var id = element.notifications.add(notification, callback, num);\n        this.ids.push([element, notification, id]);\n    };\n    NotificationHelper.prototype.cleanup = function (notificationName, element) {\n        var remaining = [];\n        for (var i = 0; i < this.ids.length; i += 1) {\n            var _a = this.ids[i], e = _a[0], notification = _a[1], id = _a[2];\n            var nameMatch = notificationName == null || notification === notificationName;\n            var elementMatch = element == null || e === element;\n            if (nameMatch && elementMatch) {\n                e.notifications.remove(notification, id);\n            }\n            else {\n                remaining.push(this.ids[i]);\n            }\n        }\n        this.ids = remaining;\n    };\n    return NotificationHelper;\n}());\nvar Notification = /** @class */ (function () {\n    function Notification() {\n        this.subscribers = {};\n        this.nextId = 0;\n        this.order = [];\n    }\n    Notification.prototype.cleanup = function () {\n        Object.keys(this.subscribers).forEach(function (s) {\n            // @ts-expect-error TS2339\n            delete s.callback;\n        });\n        this.subscribers = {};\n    };\n    /**\n     * Add a subscriber to an event.\n     * @param {string} subscriptionName event name\n     * @param {string | function(): void} callback to be called when events\n     * are published. If `string`, then {@link FunctionMap} of the {@link Figure}\n     * or {@link FigureElement} to which the notification manager is a property\n     * of will be used.\n     * @param {number} numberOfSubscriptions how many publications the\n     * subscription will receive. `-1` is no limit (`-1`).\n     * @return {number} subscirber id\n     */\n    Notification.prototype.add = function (callback, numberOfPublications) {\n        if (numberOfPublications === void 0) { numberOfPublications = -1; }\n        this.subscribers[\"\".concat(this.nextId)] = {\n            callback: callback,\n            num: numberOfPublications,\n        };\n        this.order.push(\"\".concat(this.nextId));\n        this.nextId += 1;\n        return this.nextId - 1;\n    };\n    /**\n     * Publish to all subscribers\n     *\n     * @param {any} functionArgument argument to pass to subscriber callback\n     */\n    Notification.prototype.publish = function (functionArgument, asArray) {\n        var _this = this;\n        if (functionArgument === void 0) { functionArgument = undefined; }\n        if (asArray === void 0) { asArray = true; }\n        var subscribersToRemove = [];\n        for (var i = 0; i < this.order.length; i += 1) {\n            var id = this.order[i];\n            var _a = this.subscribers[id], callback = _a.callback, num = _a.num;\n            if (num === 1) {\n                subscribersToRemove.push(id);\n            }\n            var publishOk = false;\n            if (num !== 0) {\n                publishOk = true;\n            }\n            if (num > 0) {\n                this.subscribers[\"\".concat(id)].num = num - 1;\n            }\n            if (publishOk) {\n                if (asArray) {\n                    callback(functionArgument);\n                }\n                else {\n                    callback.apply(void 0, functionArgument);\n                }\n            }\n        }\n        subscribersToRemove.forEach(function (id) { _this.remove(id); });\n    };\n    /**\n     * Remove subscriber - the subscirber id is returned by this object's `add`\n     * method\n     */\n    Notification.prototype.remove = function (subscirberId) {\n        var id = \"\".concat(subscirberId);\n        if (this.subscribers[id] != null) {\n            delete this.subscribers[id];\n        }\n        var index = this.order.indexOf(id);\n        if (index > -1) {\n            this.order.splice(index, 1);\n        }\n    };\n    return Notification;\n}());\nvar NotificationManager = /** @class */ (function () {\n    function NotificationManager() {\n        this.notifications = {};\n    }\n    NotificationManager.prototype.cleanup = function () {\n        var _this = this;\n        Object.keys(this.notifications).forEach(function (name) {\n            _this.notifications[name].cleanup();\n        });\n        this.notifications = {};\n    };\n    /**\n     * Subscribe to a notification.\n     * @param {string} name event notification name\n     * @param {string | function(): void} callback to be called when events\n     * occur. If `string`, then {@link FunctionMap} of the {@link Figure}\n     * or {@link FigureElement} to which the notification manager is a property\n     * of will be used.\n     * @param {number} num how many notifications the subscriber will receive.\n     * `num = 1` will mean only the first notification will be sent to the\n     * subscriber .`num = -1` means all notifications of the event will be sent\n     * to the subscriber (`-1`).\n     * @return {number} subscriber id\n     */\n    NotificationManager.prototype.add = function (name, callback, num) {\n        if (num === void 0) { num = -1; }\n        if (this.notifications[name] == null) {\n            this.notifications[name] = new Notification();\n        }\n        return this.notifications[name].add(callback, num);\n    };\n    /**\n     * Publish to all subscribers\n     *\n     * @param {string} subscriptionName\n     * @param {any} payload payload to pass to subscribers\n     * @param {boolean} asArray set to `true` if payload is an array that should\n     * be published as an array. Set to `false` if payload should be published as\n     * separated arguments.\n     */\n    NotificationManager.prototype.publish = function (eventName, payload, asArray) {\n        if (payload === void 0) { payload = undefined; }\n        if (asArray === void 0) { asArray = true; }\n        if (this.notifications[eventName] != null) {\n            this.notifications[eventName].publish(payload, asArray);\n        }\n    };\n    /**\n    * Remove subscriber from subscription\n     * @param {string} subsciptionName\n     * @param {string | number} subscriberId\n     */\n    NotificationManager.prototype.remove = function (eventName, subscriberId) {\n        if (this.notifications[eventName] != null) {\n            var subscription = this.notifications[eventName];\n            subscription.remove(subscriberId);\n            if (subscription.order.length === 0) {\n                delete this.notifications[eventName];\n            }\n        }\n    };\n    return NotificationManager;\n}());\nexport { NotificationHelper, NotificationManager };\n","// One-time reports for scene zoom failures that otherwise leave no trace: the\n// zoom quietly does nothing and nothing throws. Logged server-side as\n// SCENE_ZOOM_FAILURE lines (alpha.views.scene_zoom_event).\nimport request from '../request/request';\nimport { getSceneZoomTelemetry } from './sceneZoomTelemetry';\n// Page-lifetime, like the zoom telemetry counters: once per reason per load.\nvar reported = new Set();\nexport function reportSceneZoomFailure(reason, detail) {\n    var _a;\n    if (detail === void 0) { detail = {}; }\n    if (reported.has(reason))\n        return;\n    reported.add(reason);\n    request('POST', 'scene_zoom_event/', {\n        reason: reason,\n        detail: detail,\n        question_id: (_a = window.grokkoli_question_id) !== null && _a !== void 0 ? _a : null,\n        zoom: getSceneZoomTelemetry(),\n        userAgent: navigator.userAgent.slice(0, 256),\n    }, function () { });\n}\n","// Page-lifetime counters survive SPA question transitions and reset on reload.\n// An activation counts when scene zoom crosses into a visibly magnified view.\nvar ZOOMED_THRESHOLD = 1.01;\nvar usedThisQuestion = false;\nvar currentlyZoomed = false;\nvar countSinceReload = 0;\nexport function resetQuestionZoomTelemetry() {\n    usedThisQuestion = false;\n    currentlyZoomed = false;\n}\nexport function observeSceneZoom(magnification) {\n    if (!Number.isFinite(magnification))\n        return;\n    var zoomed = magnification > ZOOMED_THRESHOLD;\n    if (zoomed && !currentlyZoomed) {\n        usedThisQuestion = true;\n        countSinceReload += 1;\n    }\n    currentlyZoomed = zoomed;\n}\nexport function getSceneZoomTelemetry() {\n    return { used: usedThisQuestion, current: currentlyZoomed, countSinceReload: countSinceReload };\n}\n","var __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nvar __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n        if (ar || !(i in from)) {\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n            ar[i] = from[i];\n        }\n    }\n    return to.concat(ar || Array.prototype.slice.call(from));\n};\n// Read-only snapshots attached only to existing speech error reports.\n// No listeners, timers, storage, console writes, or new reporting triggers.\nimport { getTimerReport } from './timer';\nfunction pageSnapshot() {\n    var _a, _b, _c, _d, _e, _f;\n    return {\n        visibility: document.visibilityState,\n        focused: typeof document.hasFocus === 'function' ? document.hasFocus() : null,\n        online: navigator.onLine,\n        audio_session_state: (_b = (_a = navigator.audioSession) === null || _a === void 0 ? void 0 : _a.state) !== null && _b !== void 0 ? _b : null,\n        user_agent: navigator.userAgent,\n        user_activation_active: (_d = (_c = navigator.userActivation) === null || _c === void 0 ? void 0 : _c.isActive) !== null && _d !== void 0 ? _d : null,\n        user_activation_ever: (_f = (_e = navigator.userActivation) === null || _e === void 0 ? void 0 : _e.hasBeenActive) !== null && _f !== void 0 ? _f : null,\n    };\n}\nexport function speechStallSnapshot(manager, chunk, speechId, ssmlHash, totalChunks) {\n    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x;\n    if (totalChunks === void 0) { totalChunks = null; }\n    // Diagnostic failures must never prevent the existing error/cleanup path.\n    try {\n        var ctx = manager.ctx;\n        var audio = (_a = manager.currentAudio) !== null && _a !== void 0 ? _a : chunk === null || chunk === void 0 ? void 0 : chunk.audio;\n        var audioTime = null;\n        try {\n            audioTime = (_c = (_b = audio === null || audio === void 0 ? void 0 : audio.getCurrentTime) === null || _b === void 0 ? void 0 : _b.call(audio)) !== null && _c !== void 0 ? _c : null;\n        }\n        catch ( /* unavailable */_y) { /* unavailable */ }\n        // Audio objects capture their context at creation, which can differ\n        // from the manager's current context after replacement.\n        return __assign(__assign({}, pageSnapshot()), { speech_id: speechId, chunk_index: manager.chunkIndex, total_chunks: totalChunks, current_audio_is_chunk: manager.currentAudio != null\n                ? manager.currentAudio === (chunk === null || chunk === void 0 ? void 0 : chunk.audio) : null, audio_origin: manager.currentAudio != null ? 'current_audio' : 'chunk', sound_ctx_state: (_e = (_d = manager.soundCtx) === null || _d === void 0 ? void 0 : _d.state) !== null && _e !== void 0 ? _e : null, delay_pending: manager.delayTimeoutId != null, start_count: (_f = manager.startCount) !== null && _f !== void 0 ? _f : null, ms_since_last_progress: manager._stallLastProgressAt != null\n                ? Math.round(performance.now() - manager._stallLastProgressAt) : null, ssml_hash: ssmlHash, ctx_state: (_g = ctx === null || ctx === void 0 ? void 0 : ctx.state) !== null && _g !== void 0 ? _g : null, ctx_time_ms: ctx ? Math.round(ctx.currentTime * 1000) : null, source_ctx_state: (_k = (_j = (_h = audio === null || audio === void 0 ? void 0 : audio.source) === null || _h === void 0 ? void 0 : _h.context) === null || _j === void 0 ? void 0 : _j.state) !== null && _k !== void 0 ? _k : null, source_ctx_time_ms: ((_l = audio === null || audio === void 0 ? void 0 : audio.source) === null || _l === void 0 ? void 0 : _l.context)\n                ? Math.round(audio.source.context.currentTime * 1000) : null, source_present: (audio === null || audio === void 0 ? void 0 : audio.source) != null, source_started_at_ctx_ms: (audio === null || audio === void 0 ? void 0 : audio.contextStartTime) != null\n                ? Math.round(audio.contextStartTime * 1000) : null, audio_start_time: (_m = audio === null || audio === void 0 ? void 0 : audio.startTime) !== null && _m !== void 0 ? _m : null, audio_pause_time: (_o = audio === null || audio === void 0 ? void 0 : audio.pauseTime) !== null && _o !== void 0 ? _o : null, audio_state: (_p = audio === null || audio === void 0 ? void 0 : audio.state) !== null && _p !== void 0 ? _p : null, chunk_audio_state: (_r = (_q = chunk === null || chunk === void 0 ? void 0 : chunk.audio) === null || _q === void 0 ? void 0 : _q.state) !== null && _r !== void 0 ? _r : null, chunk_audio_loading: (_s = chunk === null || chunk === void 0 ? void 0 : chunk._audioLoading) !== null && _s !== void 0 ? _s : null, marks_state: (_u = (_t = chunk === null || chunk === void 0 ? void 0 : chunk.marks) === null || _t === void 0 ? void 0 : _t.state) !== null && _u !== void 0 ? _u : null, audio_current_time: audioTime, audio_buffer_duration: (_w = (_v = audio === null || audio === void 0 ? void 0 : audio.buffer) === null || _v === void 0 ? void 0 : _v.duration) !== null && _w !== void 0 ? _w : null, is_playing: manager.isPlaying, freeze: manager.freeze != null, interrupted_state: manager.interruptedState != null, load_timer_scope: 'active_load_only', \n            // The chunk's own load timer (ids are per load, not per ssml hash).\n            load_timer: ((_x = chunk === null || chunk === void 0 ? void 0 : chunk.audio) === null || _x === void 0 ? void 0 : _x.timerId) ? getTimerReport(chunk.audio.timerId) : null });\n    }\n    catch (_z) {\n        return { diagnostic_snapshot_unavailable: true };\n    }\n}\nexport function speechFetchSnapshot(url, attempts, timerId) {\n    var _a, _b;\n    try {\n        var out = __assign(__assign({}, pageSnapshot()), { attempts: __spreadArray([], attempts, true), \n            // Load timer ids are speech_<seq>_<ssml hash> (speech.ts speechTimerId).\n            ssml_hash: (_b = (_a = timerId === null || timerId === void 0 ? void 0 : timerId.match(/ssml_[0-9a-f]+$/)) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : null, load_timer: timerId ? getTimerReport(timerId) : null });\n        var connection = navigator.connection;\n        if (connection) {\n            out.connection = {\n                effectiveType: connection.effectiveType,\n                rtt: connection.rtt,\n                downlink: connection.downlink,\n                saveData: connection.saveData,\n            };\n        }\n        if (typeof performance.getEntriesByName === 'function') {\n            var entries = performance.getEntriesByName(url);\n            var entry = entries[entries.length - 1];\n            if (entry) {\n                // The latest entry may be from an earlier attempt or load. Include\n                // its start time; never present it as proven timing of this failure.\n                out.latest_resource_timing = {\n                    start_ms: Math.round(entry.startTime),\n                    duration_ms: Math.round(entry.duration),\n                    detail_available: entry.responseStart > 0,\n                };\n                // Cross-origin timing can be restricted. Zero fields are not\n                // evidence that DNS/TCP completed instantly.\n                if (entry.responseStart > 0) {\n                    Object.assign(out.latest_resource_timing, {\n                        dns_ms: Math.round(entry.domainLookupEnd - entry.domainLookupStart),\n                        connect_ms: Math.round(entry.connectEnd - entry.connectStart),\n                        ttfb_ms: Math.round(entry.responseStart - entry.requestStart),\n                        response_ms: Math.round(entry.responseEnd - entry.responseStart),\n                        transfer_size: entry.transferSize,\n                    });\n                }\n            }\n        }\n        return out;\n    }\n    catch (_c) {\n        // Nothing here may throw: the caller's cleanup/recovery runs after this.\n        // The attempt history is already in the error's context string.\n        return { diagnostic_snapshot_unavailable: true };\n    }\n}\n","var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n        if (ar || !(i in from)) {\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n            ar[i] = from[i];\n        }\n    }\n    return to.concat(ar || Array.prototype.slice.call(from));\n};\n/* eslint prefer-destructuring: 0 */\n/* globals figure, round */\nimport request, { logError } from './question/request/request';\nimport { withSpeechToken } from './tools/speech_token';\nimport { processResponse } from './question/answer/response';\nimport { getAnswerInput, getAnyAnswerInput, showAnswerInput } from './question/tools/getAnswerInput';\nimport getElements from './question/tools/getElements';\nimport { getElement } from './question/tools/getElements';\nimport { duplicate } from './question/tools/joinObjects';\nimport { startTimer, checkpoint, addData, stopTimer, cancelTimer, hasTimer, } from './question/timer';\nimport { AUTO_SPEECH_ID, MANUAL_SPEECH_ID } from './question/loadQuestion';\nimport { speechStallSnapshot, speechFetchSnapshot } from './question/speechErrorDiagnostics';\n// // This does not work - so cannot load a file while playing a file\n// function test1() {\n//   const audio = new Audio(`http://${window.location.host}/static/speech/test.mp3`)\n//   audio.play();\n//   setTimeout(() => {\n//     const audio2 = new Audio(`http://${window.location.host}/static/speech/test2.mp3`)\n//     audio2.play();\n//     audio2.addEventListener('ended', () => {\n//       const audio3 = new Audio(`http://${window.location.host}/static/speech/test3.mp3`)\n//       audio3.play();\n//     })\n//   }, 4000);\n// }\n// // This does not work - so cannot use a pause event to load next media\n// function test2() {\n//   const audio = new Audio(`http://${window.location.host}/static/speech/test.mp3`)\n//   audio.play();\n//   audio.addEventListener('pause', () => {\n//     const audio2 = new Audio(`http://${window.location.host}/static/speech/test2.mp3`)\n//     audio2.play();\n//     audio2.addEventListener('ended', () => {\n//       const audio3 = new Audio(`http://${window.location.host}/static/speech/test3.mp3`)\n//       audio3.play();\n//     })\n//   })\n//   setTimeout(() => {\n//     audio.pause();\n//   }, 4000);\n// }\n// function oneTimeListener(node, type, callback) {\n//   function listener(e) {\n//     e.target.removeEventListener(e.type, listener);\n//     return callback.call(this, e);\n//   }\n//   node.addEventListener(type, listener);\n//   function removeListener() {\n//     node.removeEventListener(type, listener);\n//   }\n//   return removeListener;\n// }\n/*\n..######..########..########.########..######..##.....##\n.##....##.##.....##.##.......##.......##....##.##.....##\n.##.......##.....##.##.......##.......##.......##.....##\n..######..########..######...######...##.......#########\n.......##.##........##.......##.......##.......##.....##\n.##....##.##........##.......##.......##....##.##.....##\n..######..##........########.########..######..##.....##\n\n\n.##.....##....###....##....##....###.....######...########.########.\n.###...###...##.##...###...##...##.##...##....##..##.......##.....##\n.####.####..##...##..####..##..##...##..##........##.......##.....##\n.##.###.##.##.....##.##.##.##.##.....##.##...####.######...########.\n.##.....##.#########.##..####.#########.##....##..##.......##...##..\n.##.....##.##.....##.##...###.##.....##.##....##..##.......##....##.\n.##.....##.##.....##.##....##.##.....##..######...########.##.....##\n*/\n/**\n * Tell the helper the speech the learner is waiting on could not be played,\n * so the speaker shows a red ring and \"!\" badge. Pressing it plays again,\n * and a failed chunk (audio.state 'failed') is re-fetched.\n * Never throws: reporting must not get in the way of the recovery.\n */\nfunction notifyAudioFailed() {\n    var _a, _b, _c;\n    try {\n        (_c = (_b = (_a = window.figure) === null || _a === void 0 ? void 0 : _a.helper) === null || _b === void 0 ? void 0 : _b.audioFailed) === null || _c === void 0 ? void 0 : _c.call(_b, true);\n    }\n    catch (_d) {\n        // The helper may be mid-teardown; the hint is best-effort.\n    }\n}\n/** Audio is playing again, so take the failure hint down. */\nfunction clearAudioFailed() {\n    var _a;\n    try {\n        var helper_1 = (_a = window.figure) === null || _a === void 0 ? void 0 : _a.helper;\n        if (helper_1 === null || helper_1 === void 0 ? void 0 : helper_1.audioFailedShown)\n            helper_1.audioFailed(false);\n    }\n    catch (_b) {\n        // Best-effort, as above.\n    }\n}\n// eslint-disable-next-line\n// Shared retry config for the two fetch retry sites in this file:\n// load() (MP3 binary) and getMarks() (text marks). Hoisted so they stay in\n// sync — divergence would be a footgun. If a site needs different tuning\n// later, give it its own local constants then.\nvar RETRY_MAX_ATTEMPTS = 3;\n// Per-attempt ceilings, indexed by attemptNum - 1 and escalating. 3s still\n// catches a dead connection quickly on a healthy link, where a real answer\n// arrives in tens of ms. The longer later caps are for a slow link (3G, ~1s\n// RTT), where one small fetch is 2-3s of handshakes and round trips: a flat\n// 3s aborted those right at the edge and the retry started from zero on the\n// same link, so an attempt that would have finished at 3.2s never did.\nvar RETRY_ATTEMPT_TIMEOUTS_MS = [3000, 5000, 8000];\nvar RETRY_BACKOFF_MS = [300, 900];\n// Backoff with ±50% jitter. With a fixed delay every chunk that timed out in\n// the same moment retried in the same moment, recreating the contention that\n// timed them out.\nfunction retryDelay(attemptNum) {\n    var _a;\n    var base = (_a = RETRY_BACKOFF_MS[attemptNum - 1]) !== null && _a !== void 0 ? _a : 1000;\n    return Math.round(base * (0.5 + Math.random()));\n}\n// Every attempt hanging: 3 + 0.3 + 5 + 0.9 + 8 = 17.2s. The stall watchdog\n// does not race this total: each attempt on the active speech's audio resets\n// the watchdog's progress clock (see attempt() in makeAudio), so the watchdog\n// measures time since the loader last did anything, and only the single\n// longest cap here has to fit under INITIAL_LOAD_THRESHOLD_MS. That holds\n// because an active speech's fetch never waits for a slot behind another\n// speech's fetch -- the limiter pre-empts those (see acquireFetchSlot) -- so\n// the only thing it can queue behind is the active speech's own earlier\n// chunks, which are needed first anyway.\nfunction attemptTimeoutMs(attemptNum) {\n    var i = Math.min(attemptNum, RETRY_ATTEMPT_TIMEOUTS_MS.length) - 1;\n    return RETRY_ATTEMPT_TIMEOUTS_MS[Math.max(i, 0)];\n}\n/** \"3000/5000/8000ms\" for the attempts actually made -- for hung reports. */\nfunction attemptTimeoutsUsed(attempts) {\n    return \"\".concat(RETRY_ATTEMPT_TIMEOUTS_MS.slice(0, attempts).join('/'), \"ms\");\n}\n// Ceilings on speech file fetches in flight at once, per speech manager\n// generation, one lane for MP3s and one for marks. A batched speech_urls/\n// response used to release every chunk's MP3 and marks fetch in the same tick\n// -- ten requests against one host -- and on a slow link (3G, ~1s RTT, <1Mbps)\n// that burst pushed most of them past the 3s per-attempt cap, so they retried\n// from zero on the same congested link and the last chunk exhausted all three\n// attempts. Limiting only the MP3s moved the burst to the marks files: on a 2G\n// link the marks fetches went out five at once while their MP3s waited, and\n// hung through all three attempts. Chunk N isn't needed until chunk N-1 has\n// finished playing, so there is nothing to gain from fetching them all at\n// once. Two MP3s keeps one download's TLS setup overlapping another's transfer\n// without saturating the link. Marks get their own single slot rather than a\n// share of the MP3 pair: a day of field timing showed a third of MP3 loads\n// already queue under the pair (p90 wait ~3.4s), and marks are a third as many\n// fetches again, so sharing would have lengthened every MP3 queue by a third\n// to bound a burst of 200-byte files. See acquireFetchSlot.\nvar MP3_FETCH_MAX_CONCURRENT = 2;\nvar MARKS_FETCH_MAX_CONCURRENT = 1;\nfunction isRetryable(err, status) {\n    if (status != null) {\n        if (status >= 500)\n            return true;\n        if (status === 408)\n            return true;\n        return false;\n    }\n    if (err && (err.name === 'AbortError' || err instanceof TypeError)) {\n        return true;\n    }\n    return false;\n}\nfunction makeSpeechManager() {\n    if (figure.speechMessage == null) {\n        return;\n    }\n    // @ts-expect-error TS2339\n    if (navigator.audioSession) {\n        // @ts-expect-error TS2339\n        navigator.audioSession.type = 'playback';\n    }\n    /* **************************************************************\n     * **************************************************************\n     * Supporting functions\n     * **************************************************************\n     * ************************************************************ */\n    // Speech rect - for surrounding elements\n    var speechRect = figure.add({\n        make: 'collections.rectangle',\n        line: { width: 0.005 },\n        color: [0, 0, 1, 1],\n    });\n    speechRect.hide();\n    // Speech arrow - for pointing at elements\n    var speechArrow = figure.add({\n        make: 'arrow',\n        width: 0.1,\n        length: 0.15,\n        tail: 0.05,\n        tailWidth: 0.05,\n        color: [0.5, 0.5, 0.5, 1],\n    });\n    speechArrow.hide();\n    function showArrow(direction, elements, duration, pulse, space, color) {\n        if (duration === void 0) { duration = null; }\n        if (pulse === void 0) { pulse = 1.1; }\n        if (space === void 0) { space = 0.05; }\n        if (color === void 0) { color = null; }\n        // Get bounding box of elements\n        var elems = figure.get(elements);\n        if (!Array.isArray(elems)) {\n            elems = [elems];\n        }\n        var left;\n        var right;\n        var bottom;\n        var top;\n        for (var i = 0; i < elems.length; i += 1) {\n            var r = elems[i].getBoundingRect('figure');\n            if (i === 0) {\n                left = r.left;\n                right = r.right;\n                top = r.top;\n                bottom = r.bottom;\n            }\n            else {\n                if (r.left < left) {\n                    left = r.left;\n                }\n                if (r.bottom < bottom) {\n                    bottom = r.bottom;\n                }\n                if (r.right > right) {\n                    right = r.right;\n                }\n                if (r.top > top) {\n                    top = r.top;\n                }\n            }\n        }\n        if (direction === 'left') {\n            speechArrow.setRotation(0);\n            speechArrow.setPosition([left - space, (top - bottom) / 2 + bottom]);\n        }\n        else if (direction === 'right') {\n            speechArrow.setRotation(Math.PI);\n            speechArrow.setPosition([right + space, (top - bottom) / 2 + bottom]);\n        }\n        else if (direction === 'bottom') {\n            speechArrow.setRotation(Math.PI / 2);\n            speechArrow.setPosition([(right - left) / 2 + left, bottom - space]);\n        }\n        else if (direction === 'top') {\n            speechArrow.setRotation((Math.PI / 2) * 3);\n            speechArrow.setPosition([(right - left) / 2 + left, top + space]);\n        }\n        if (color != null) {\n            speechArrow.setColor(color);\n        }\n        speechArrow.show();\n        speechArrow.pulse({ scale: pulse, duration: 0.4 });\n        if (duration != null) {\n            speechArrow.animations.new().delay(duration).dissolveOut(0.2).start();\n        }\n    }\n    function hideHighlightElements() {\n        for (var i = 0; i < figure.elements.drawOrder.length; i += 1) {\n            var element = figure.elements.elements[figure.elements.drawOrder[i]];\n            if (element.custom.highlightElement) {\n                element.hide();\n            }\n        }\n    }\n    var defaultArrowOptions = {\n        arrow: [0, 0],\n        element: '_Arrow1',\n        position: 'top',\n        pulse: 1.3,\n        space: 0.05,\n        color: [0.843, 0.847, 0.851, 1],\n        offset: [0, 0],\n        move: 0.4,\n        toFront: true,\n        width: 0.2,\n        length: 0.3,\n        tail: 0.1,\n        tailWidth: 0.1,\n    };\n    // Create the arrow primitive if it doesn't yet exist. Shared between\n    // showArrowNew and setArrowDefaults so an arrowDefaults action can\n    // pre-create + configure the arrow before its first show.\n    function ensureArrowElement(o) {\n        // @ts-expect-error TS2352\n        var arrowElement = getElements(o.element);\n        if (arrowElement == null) {\n            var s = 0.8;\n            arrowElement = figure.elements.add({\n                name: o.element,\n                make: 'arrow',\n                width: o.width * s,\n                length: o.length * s,\n                tail: o.tail * s,\n                tailWidth: o.tailWidth * s,\n                color: o.color,\n            });\n            arrowElement.hide();\n            arrowElement.custom.highlightElement = true;\n        }\n        return arrowElement;\n    }\n    // Stash a set of default arrow options on the named arrow element so that\n    // subsequent showArrowNew calls inherit them (builtin < saved < per-call).\n    function setArrowDefaults(defaults) {\n        var o = FigTools.joinObjects({}, defaultArrowOptions, defaults);\n        var arrowElement = ensureArrowElement(o);\n        arrowElement.custom.arrowDefaults = defaults;\n    }\n    function showArrowNew(arrowOptions) {\n        // Resolve element name first so we can pull any saved defaults off the\n        // existing element before merging the final option set.\n        var elementName = (arrowOptions.element != null)\n            ? arrowOptions.element\n            : defaultArrowOptions.element;\n        // @ts-expect-error TS2352\n        var arrowElement = getElements(elementName);\n        var savedDefaults = (arrowElement != null\n            && arrowElement.custom != null\n            && arrowElement.custom.arrowDefaults != null) ? arrowElement.custom.arrowDefaults : {};\n        var o = FigTools.joinObjects({}, defaultArrowOptions, savedDefaults, arrowOptions);\n        if (arrowElement == null) {\n            arrowElement = ensureArrowElement(o);\n        }\n        if (o.toFront) {\n            figure.elements.toFront(arrowElement);\n        }\n        else {\n            figure.elements.toBack(arrowElement);\n        }\n        if (typeof o.arrow === 'string') {\n            o.arrow = [o.arrow];\n        }\n        // Resolve arrowCustom strings (\"ELEMENT_NAME.PARAM\") through each base\n        // element's custom.getElement(PARAM). The result of each lookup may be a\n        // single element or a list, so flatten as we go.\n        var customElems = null;\n        if (o.arrowCustom != null) {\n            var items = o.arrowCustom;\n            if (typeof items === 'string') {\n                items = [items];\n            }\n            customElems = [];\n            for (var i = 0; i < items.length; i += 1) {\n                var item = items[i];\n                var dotIndex = item.indexOf('.');\n                if (dotIndex < 0) {\n                    continue;\n                }\n                var elementName_1 = item.substring(0, dotIndex);\n                var param = item.substring(dotIndex + 1);\n                var e = getElement(elementName_1);\n                if (e == null || e.custom == null || e.custom.getElement == null) {\n                    continue;\n                }\n                var result = e.custom.getElement(param);\n                if (result == null) {\n                    continue;\n                }\n                var targets = Array.isArray(result) ? result : [result];\n                for (var t = 0; t < targets.length; t += 1) {\n                    if (targets[t] != null) {\n                        customElems.push(targets[t]);\n                    }\n                }\n            }\n        }\n        var left;\n        var right;\n        var bottom;\n        var top;\n        if (customElems != null || typeof o.arrow[0] === 'string') {\n            var elems = customElems != null\n                ? customElems\n                // @ts-expect-error TS2345 -- guarded above: arrow[0] is a string here\n                : getElements(o.arrow);\n            for (var i = 0; i < elems.length; i += 1) {\n                var r = elems[i].getBoundingRect('figure');\n                var elem = elems[i];\n                // `drawingObject.text` is an array of text runs, so `.length === 1` just\n                // means \"one run\" — true for essentially every text element. Also check\n                // the run itself is a single character, otherwise this 0.85 shrink\n                // (intended to tighten a lone digit/letter) fires on multi-character\n                // elements and pulls the right edge in, skewing the highlight left.\n                var txt = elem.type == 'primitive' && elem.drawingObject != null\n                    ? elem.drawingObject.text : null;\n                if (txt != null && txt.length === 1 && String(txt[0]).length === 1) {\n                    r.width *= 0.85;\n                    r.right = r.left + r.width;\n                }\n                if (i === 0) {\n                    left = r.left;\n                    right = r.right;\n                    top = r.top;\n                    bottom = r.bottom;\n                }\n                else {\n                    if (r.left < left) {\n                        left = r.left;\n                    }\n                    if (r.bottom < bottom) {\n                        bottom = r.bottom;\n                    }\n                    if (r.right > right) {\n                        right = r.right;\n                    }\n                    if (r.top > top) {\n                        top = r.top;\n                    }\n                }\n            }\n        }\n        else {\n            left = o.arrow[0];\n            right = o.arrow[0];\n            top = o.arrow[1];\n            bottom = o.arrow[1];\n        }\n        var offset = Fig.parsePoint(o.offset);\n        // // Get bounding box of elements\n        // let elems = figure.get(elements);\n        // if (!Array.isArray(elems)) {\n        //   elems = [elems];\n        // }\n        var arrowPosition = arrowElement.getPosition();\n        var arrowRotation = arrowElement.getRotation();\n        if (o.position === 'left') {\n            arrowRotation = 0;\n            arrowPosition = [\n                left - o.space + offset.x,\n                (top - bottom) / 2 + bottom + offset.y,\n            ];\n        }\n        else if (o.position === 'right') {\n            arrowRotation = Math.PI;\n            arrowPosition = [\n                right + o.space + offset.x,\n                (top - bottom) / 2 + bottom + offset.y,\n            ];\n        }\n        else if (o.position === 'bottom') {\n            arrowRotation = Math.PI / 2;\n            arrowPosition = [\n                (right - left) / 2 + left + offset.x,\n                bottom - o.space + offset.y,\n            ];\n        }\n        else if (o.position === 'top') {\n            arrowRotation = (Math.PI / 2) * 3;\n            arrowPosition = [\n                (right - left) / 2 + left + offset.x,\n                top + o.space + offset.y,\n            ];\n        }\n        var arrowColor = arrowElement.color.slice();\n        if (o.color != null) {\n            arrowColor = o.color.slice();\n        }\n        arrowElement.stop();\n        if (arrowElement.isShown) {\n            arrowElement.animations\n                .new()\n                .inParallel([\n                arrowElement.animations.position({\n                    target: arrowPosition,\n                    duration: o.move,\n                }),\n                arrowElement.animations.rotation({\n                    target: arrowRotation,\n                    duration: o.move,\n                }),\n                arrowElement.animations.color({ target: arrowColor, duration: o.move })\n            ])\n                .pulse({\n                scale: o.pulse,\n                duration: 0.5,\n                frequency: 2,\n                // xAlign: 'origin',\n                // yAlign: 'origin',\n            })\n                .start();\n        }\n        else {\n            arrowElement.show();\n            arrowElement.setPosition(arrowPosition);\n            arrowElement.setRotation(arrowRotation);\n            arrowElement.setColor(arrowColor);\n            arrowElement.animations\n                .new()\n                .dissolveIn(0.2)\n                .pulse({\n                scale: o.pulse,\n                duration: 0.5,\n                frequency: 2,\n                // xAlign: 'origin',\n                // yAlign: 'origin',\n            })\n                .start();\n        }\n        // arrowElement.show();\n        // arrowElement.pulse({ scale: o.pulse, duration: 0.4 });\n        if (o.duration != null) {\n            arrowElement.animations.new().delay(o.duration).dissolveOut(0.4).start();\n        }\n    }\n    function hideHighlight(hideOptions) {\n        var defaultElement = '_Fill1';\n        if (hideOptions.arrow != null) {\n            defaultElement = '_Arrow1';\n        }\n        var defaultHideOptions = {\n            duration: 0.4,\n            delay: 0,\n            element: defaultElement,\n        };\n        var o = FigTools.joinObjects({}, defaultHideOptions, hideOptions);\n        // @ts-expect-error TS2352\n        var hideElement = getElements(o.element);\n        if (hideElement == null) {\n            return;\n        }\n        hideElement.stop('complete');\n        hideElement.animations.new()\n            .delay(o.delay)\n            .dissolveOut(o.duration)\n            .start();\n    }\n    function showFill(fillOptions) {\n        var defaultFillOptions = {\n            fill: [0, 0],\n            element: '_Fill1',\n            pulse: 1,\n            space: [0.02, 0.05],\n            color: [0.843, 0.847, 0.851, 1],\n            offset: [0, 0],\n            move: 0.4,\n            toFront: false,\n        };\n        var o = FigTools.joinObjects({}, defaultFillOptions, fillOptions);\n        // @ts-expect-error TS2352\n        var fillElement = getElements(o.element);\n        if (fillElement == null) {\n            fillElement = figure.elements.add({\n                name: o.element,\n                make: 'rectangle',\n                width: 1,\n                length: 1,\n                color: o.color,\n                xAlign: 'center',\n                line: o.line ? o.line : null,\n                yAlign: 'middle',\n                corner: {\n                    radius: 0.02,\n                    sides: 10,\n                }\n            });\n            fillElement.hide();\n            fillElement.custom.highlightElement = true;\n            // fillElement.custom.getWidth = () => {\n            //   return fillElement.drawingObject.points[118] - fillElement.drawingObject.points[0];\n            // }\n            // fillElement.custom.getHeight = () => {\n            //   return fillElement.drawingObject.points[191] - fillElement.drawingObject.points[53];\n            // }\n        }\n        if (o.toFront) {\n            figure.elements.toFront(fillElement);\n        }\n        else {\n            figure.elements.toBack(fillElement);\n        }\n        if (typeof o.fill === 'string') {\n            o.fill = [o.fill];\n        }\n        var left = 0;\n        var right = 0;\n        var bottom = 0;\n        var top = 0;\n        if (typeof o.fill[0] === 'string') {\n            // @ts-expect-error TS2345\n            var elems = getElements(o.fill);\n            for (var i = 0; i < elems.length; i += 1) {\n                var r = elems[i].getBoundingRect('figure');\n                var elem = elems[i];\n                // `drawingObject.text` is an array of text runs, so `.length === 1` just\n                // means \"one run\" — true for essentially every text element. Also check\n                // the run itself is a single character, otherwise this 0.85 shrink\n                // (intended to tighten a lone digit/letter) fires on multi-character\n                // elements and pulls the right edge in, skewing the highlight left.\n                var txt = elem.type == 'primitive' && elem.drawingObject != null\n                    ? elem.drawingObject.text : null;\n                if (txt != null && txt.length === 1 && String(txt[0]).length === 1) {\n                    r.width *= 0.85;\n                    r.right = r.left + r.width;\n                }\n                if (i === 0) {\n                    left = r.left;\n                    right = r.right;\n                    top = r.top;\n                    bottom = r.bottom;\n                }\n                else {\n                    if (r.left < left) {\n                        left = r.left;\n                    }\n                    if (r.bottom < bottom) {\n                        bottom = r.bottom;\n                    }\n                    if (r.right > right) {\n                        right = r.right;\n                    }\n                    if (r.top > top) {\n                        top = r.top;\n                    }\n                }\n            }\n        }\n        else {\n            left = o.fill[0];\n            right = o.fill[0];\n            top = o.fill[1];\n            bottom = o.fill[1];\n        }\n        var offset = Fig.parsePoint(o.offset);\n        // Normalise space to per-side padding [left, right, bottom, top]:\n        //  - scalar          -> same padding on all sides\n        //  - [horiz, vert]    -> horiz on left/right, vert on top/bottom\n        //  - [l, r, b, t]     -> used as-is\n        var space = o.space;\n        if (!Array.isArray(space)) {\n            space = [space, space, space, space];\n        }\n        else if (space.length === 2) {\n            space = [space[0], space[0], space[1], space[1]];\n        }\n        var spaceLeft = space[0];\n        var spaceRight = space[1];\n        var spaceBottom = space[2];\n        var spaceTop = space[3];\n        // Shift the centre by half the padding difference so asymmetric padding\n        // grows the correct side (symmetric padding leaves the centre unchanged).\n        var fillPosition = new Fig.Point(left + (right - left) / 2 + offset.x + (spaceRight - spaceLeft) / 2, bottom + (top - bottom) / 2 + offset.y + (spaceTop - spaceBottom) / 2);\n        var fillWidth = Fig.round(o.width == null ? right - left + spaceLeft + spaceRight : o.width, 5);\n        var fillHeight = Fig.round(o.height == null ? top - bottom + spaceBottom + spaceTop : o.height, 5);\n        var fillColor = fillElement.color.slice();\n        if (o.color != null) {\n            fillColor = o.color.slice();\n        }\n        // const initialWidth = Fig.round(fillElement.custom.getWidth(), 5);\n        // const initialHeight = Fig.round(fillElement.custom.getHeight(), 5);\n        var initialWidth = fillElement.getBoundingRect('local').width;\n        var initialHeight = fillElement.getBoundingRect('local').height;\n        fillElement.stop('complete');\n        if (fillElement.isShown) {\n            fillElement.animations\n                .new()\n                .inParallel([\n                fillElement.animations.position({\n                    target: fillPosition,\n                    // duration: o.move,\n                    duration: 1,\n                }),\n                fillElement.animations.custom({\n                    callback: function (p) {\n                        // const newP = p > 0.5 ? Math.min(1, p * 2) : p;\n                        var newP = p * p / (2 * (p * p - p) + 1);\n                        if (fillWidth !== initialWidth || fillHeight !== initialHeight) {\n                            var w = initialWidth + (fillWidth - initialWidth) * newP;\n                            var h = initialHeight + (fillHeight - initialHeight) * newP;\n                            fillElement.custom.updatePoints({ width: w, height: h });\n                        }\n                    },\n                    // duration: o.move,\n                    duration: 1,\n                }),\n                fillElement.animations.color({ target: fillColor, duration: o.move })\n            ])\n                .pulse({\n                scale: o.pulse,\n                duration: 0.5,\n                frequency: 2,\n                // xAlign: 'origin',\n                // yAlign: 'origin',\n            })\n                .start();\n        }\n        else {\n            fillElement.show();\n            fillElement.setPosition(fillPosition);\n            fillElement.custom.updatePoints({ width: fillWidth, height: fillHeight });\n            fillElement.setColor(fillColor);\n            fillElement.animations\n                .new()\n                .dissolveIn(0.2)\n                .pulse({\n                scale: o.pulse,\n                duration: 0.25,\n                frequency: 4,\n                // xAlign: 'origin',\n                // yAlign: 'origin',\n            })\n                .start();\n        }\n        // fillElement.show();\n        // fillElement.pulse({ scale: o.pulse, duration: 0.4 });\n        if (o.duration != null) {\n            fillElement.animations.new().delay(o.duration).dissolveOut(0.4).start();\n        }\n    }\n    function addClassToElements(elementNames, className, add) {\n        if (add === void 0) { add = true; }\n        var names = elementNames;\n        if (typeof elementNames === 'string') {\n            names = [elementNames];\n        }\n        var elements = [];\n        for (var i = 0; i < names.length; i += 1) {\n            var element = document.getElementById(names[i]);\n            if (element != null) {\n                elements.push(element);\n                element.classList.remove(className);\n            }\n        }\n        if (elements.length > 0) {\n            elements[0].offsetWidth;\n        }\n        if (add) {\n            for (var i = 0; i < elements.length; i += 1) {\n                elements[i].classList.add(className);\n            }\n        }\n    }\n    // Expands regex patterns in element names so speech directives like\n    // `|v:Tile.*|` pulse every currently-visible element whose name matches\n    // the pattern. Entries are treated as regex when they contain any regex\n    // metacharacter other than `.` (which legitimately appears in element\n    // names as a collection separator, e.g. `Tile12.a`); literal names and\n    // non-string entries are passed through untouched, so patterns and\n    // explicit names can be mixed in one directive (e.g.\n    // `|v:Tile.*,INLINE.numerator|`). Patterns are anchored with `^…$`.\n    // Note this is a breaking change from the previous glob syntax: write\n    // `Tile.*` instead of `Tile*`, and `Tile[^.]*` if you want to avoid\n    // crossing collection boundaries. If a pattern matches no visible\n    // element (or fails to compile), the entry is passed through as a\n    // literal name so elements actually named with a regex metacharacter\n    // (e.g. `now?`) still resolve via the downstream figure.get lookup.\n    var regexMetaChars = /[*+?^${}()|[\\]\\\\]/;\n    function expandWildcardElements(elements) {\n        var arr = typeof elements === 'string' ? [elements] : elements;\n        var hasPattern = arr.some(function (e) { return typeof e === 'string' && regexMetaChars.test(e); });\n        if (!hasPattern) {\n            return elements;\n        }\n        var result = [];\n        for (var i = 0; i < arr.length; i += 1) {\n            var elem = arr[i];\n            if (typeof elem !== 'string' || !regexMetaChars.test(elem)) {\n                result.push(elem);\n                continue;\n            }\n            // Pick which collection's drawOrder to enumerate. Bare names default\n            // to the `expression` namespace, matching the fallback behavior used\n            // elsewhere in pulseElement for non-prefixed names.\n            var collection = void 0;\n            var pattern = void 0;\n            var prefix = void 0;\n            if (elem.startsWith('expression.')) {\n                collection = figure.elements._expression;\n                pattern = elem.substring('expression.'.length);\n                prefix = 'expression.';\n            }\n            else if (elem.startsWith('instruction.')) {\n                collection = figure.elements._instruction;\n                pattern = elem.substring('instruction.'.length);\n                prefix = 'instruction.';\n            }\n            else {\n                collection = figure.elements._expression;\n                pattern = elem;\n                prefix = 'expression.';\n            }\n            if (collection == null || collection.drawOrder == null) {\n                result.push(elem);\n                continue;\n            }\n            var regex = null;\n            try {\n                regex = new RegExp(\"^\".concat(pattern, \"$\"));\n            }\n            catch (_a) {\n                regex = null;\n            }\n            // Only emit matches that are currently shown — hidden elements are\n            // excluded so a directive like `|v:Tile.*|` pulses what the learner\n            // can actually see, not stale or pre-staged elements.\n            var matched = false;\n            if (regex != null) {\n                for (var j = 0; j < collection.drawOrder.length; j += 1) {\n                    var name_1 = collection.drawOrder[j];\n                    if (regex.test(name_1)) {\n                        var child = collection.elements[name_1];\n                        if (child != null && child.isShown) {\n                            result.push(\"\".concat(prefix).concat(name_1));\n                            matched = true;\n                        }\n                    }\n                }\n            }\n            if (!matched) {\n                // Regex matched no visible element (or failed to compile). Fall\n                // back to passing the entry through as a literal name so the\n                // downstream figure.get lookup can find an element actually named\n                // with a regex metacharacter (e.g. `now?`).\n                result.push(elem);\n            }\n        }\n        return result;\n    }\n    function pulseElement(elements, mag, duration, type, frequency, delay, stopAnimation) {\n        if (frequency === void 0) { frequency = null; }\n        if (delay === void 0) { delay = 0; }\n        if (stopAnimation === void 0) { stopAnimation = 'cancel'; }\n        elements = expandWildcardElements(elements);\n        var elems = figure.get(elements);\n        if (elems == null || elems.length < elements.length) {\n            if (typeof elements === 'string') {\n                elems = figure.get(\"expression.\".concat(elements));\n            }\n            else if (Array.isArray(elements)) {\n                var expression_elements = [];\n                for (var i = 0; i < elements.length; i += 1) {\n                    var elem = elements[i];\n                    var function_elements = [];\n                    if (figure.elements._expression) {\n                        function_elements.push.apply(function_elements, figure.elements._expression.getFunctionElements(elem));\n                    }\n                    if (elem === 'INLINE.numerator') {\n                        var ai = getAnswerInput();\n                        var numeratorElements = ai.eqn.getNumerator();\n                        if (numeratorElements != null) {\n                            for (var j = 0; j < numeratorElements.length; j += 1) {\n                                expression_elements.push(numeratorElements[j]);\n                            }\n                        }\n                    }\n                    else if (elem === 'INLINE.denominator') {\n                        var ai = getAnswerInput();\n                        var denominatorElements = ai.eqn.getDenominator();\n                        if (denominatorElements != null) {\n                            for (var j = 0; j < denominatorElements.length; j += 1) {\n                                expression_elements.push(denominatorElements[j]);\n                            }\n                        }\n                    }\n                    else if (elem === 'INLINE.whole') {\n                        var ai = getAnswerInput();\n                        var wholeElements = ai.eqn.getWhole();\n                        if (wholeElements != null) {\n                            for (var j = 0; j < wholeElements.length; j += 1) {\n                                expression_elements.push(wholeElements[j]);\n                            }\n                        }\n                    }\n                    else if (elem === 'INLINE.fraction') {\n                        var ai = getAnswerInput();\n                        var fractionElements = ai.eqn.getFraction();\n                        if (fractionElements != null) {\n                            for (var j = 0; j < fractionElements.length; j += 1) {\n                                expression_elements.push(fractionElements[j]);\n                            }\n                        }\n                    }\n                    else if (elem === 'INLINE.vinculum') {\n                        var ai = getAnswerInput();\n                        var fractionElement = ai.eqn.getVinculum();\n                        if (fractionElement != null) {\n                            expression_elements.push(fractionElement);\n                        }\n                    }\n                    else if (!elem.startsWith('expression') &&\n                        !elem.startsWith('instruction') &&\n                        !elem.startsWith('workPad')) {\n                        if (figure.elements._workPad != null\n                            && figure.elements._workPad.custom.getAllMapNames) {\n                            var mapNames = figure.elements._workPad.custom.getAllMapNames();\n                            for (var i_1 = 0; i_1 < mapNames.length; i_1 += 1) {\n                                var mapName = mapNames[i_1];\n                                if (elem === mapName) {\n                                    var map = figure.elements._workPad.custom.getMap(mapName);\n                                    var snappedElements = map.getSnappedTiles();\n                                    for (var j = 0; j < snappedElements.length; j += 1) {\n                                        expression_elements.push(snappedElements[j].getPath());\n                                    }\n                                }\n                                else {\n                                    expression_elements.push(\"expression.\".concat(elem));\n                                }\n                            }\n                        }\n                        else if (figure.elements._workPad\n                            && figure.elements._workPad.custom.getInputTiles) {\n                            var inputTiles = figure.elements._workPad.custom.getInputTiles();\n                            if (inputTiles[elem] != null) {\n                                for (var j = 0; j < inputTiles[elem].length; j += 1) {\n                                    expression_elements.push(inputTiles[elem][j].getPath());\n                                }\n                            }\n                        }\n                        else if (function_elements.length > 0) {\n                            for (var i_2 = 0; i_2 < function_elements.length; i_2 += 1) {\n                                expression_elements.push(function_elements[i_2].getPath());\n                            }\n                        }\n                        else {\n                            expression_elements.push(\"expression.\".concat(elem));\n                        }\n                    }\n                    else {\n                        expression_elements.push(elem);\n                    }\n                }\n                elems = expression_elements;\n            }\n            elems = figure.get(elems);\n        }\n        if (!Array.isArray(elems)) {\n            elems = [elems];\n        }\n        for (var i = 0; i < elems.length; i += 1) {\n            elems[i].stop(stopAnimation);\n            if (type === 'scale') {\n                elems[i].animations\n                    .new()\n                    .pulse({ delay: delay, duration: duration, scale: mag })\n                    .start();\n                if (elems[i].custom.toPulse != null) {\n                    elems[i].custom.toPulse({ delay: delay, duration: duration, scale: mag });\n                }\n            }\n            else if (type === 'v') {\n                var p1 = elems[i].pointFromSpaceToSpace([0, 0], 'figure', 'draw');\n                var p2 = elems[i].pointFromSpaceToSpace([0, mag], 'figure', 'draw');\n                var delta = p2.y - p1.y;\n                elems[i].animations\n                    .new()\n                    .pulse({\n                    delay: delay,\n                    duration: duration,\n                    translation: delta,\n                    min: -delta,\n                    angle: Math.PI / 2,\n                    frequency: frequency,\n                })\n                    .start();\n                if (elems[i].custom.toPulse != null) {\n                    elems[i].custom.toPulse({\n                        delay: delay,\n                        duration: duration,\n                        translation: delta,\n                        min: -delta,\n                        angle: Math.PI / 2,\n                        frequency: frequency,\n                    });\n                }\n            }\n            else if (type === 'h') {\n                elems[i].animations\n                    .new()\n                    .pulse({\n                    delay: delay,\n                    duration: duration,\n                    translation: mag,\n                    min: -mag,\n                    angle: 0,\n                    frequency: frequency,\n                })\n                    .start();\n                if (elems[i].custom.toPulse != null) {\n                    elems[i].custom.toPulse({\n                        delay: delay,\n                        duration: duration,\n                        translation: mag,\n                        min: -mag,\n                        angle: 0,\n                        frequency: frequency,\n                    });\n                }\n            }\n        }\n    }\n    function getElementsArray(elems_def) {\n        var elems;\n        if (!Array.isArray(elems_def)) {\n            elems = [elems_def];\n        }\n        else {\n            elems = elems_def;\n        }\n        return elems;\n    }\n    function execMethodOnElements(elemNames, action) {\n        var elems;\n        if (!Array.isArray(elemNames)) {\n            elems = [elemNames];\n        }\n        else {\n            elems = elemNames;\n        }\n        for (var i = 0; i < elems.length; i += 1) {\n            var elem = void 0;\n            if (elems[i] === 'custom' || elems[i] === 'expression.custom') {\n                elem = figure.get('expression');\n                if (elem != null) {\n                    elem = elem.custom;\n                }\n            }\n            else {\n                elem = figure.get(elems[i]);\n            }\n            if (elem == null && elems[i] === 'answer_input') {\n                elem = getAnswerInput();\n            }\n            if (elem == null && elems[i] === 'helper') {\n                elem = figure.custom.helpers;\n            }\n            // The \"Don't know\" pill's controller (helper/dontKnowController.ts),\n            // e.g. |e:dont_know,wiggle| to wiggle it as it is named\n            if (elem == null && elems[i] === 'dont_know') {\n                elem = figure.custom.dontKnow;\n            }\n            if (elem == null) {\n                elem = figure.get(\"expression.\".concat(elems[i]));\n            }\n            if (elem == null) {\n                continue;\n            }\n            if (elem[action.method]) {\n                if (action.params != null) {\n                    if (!Array.isArray(action.params)) {\n                        elem[action.method](action.params);\n                    }\n                    else {\n                        elem[action.method].apply(elem, action.params);\n                    }\n                }\n                else {\n                    elem[action.method](action);\n                }\n            }\n        }\n    }\n    function executeAction(action) {\n        var _a, _b;\n        if (action.rect != null) {\n            if (action.rect === 'hide') {\n                speechRect.hide();\n            }\n            else {\n                speechRect.stop();\n                speechRect.show();\n                speechRect.surround(figure.get(action.rect), action.space == null ? 0.03 : action.space);\n                speechRect.pulse({\n                    scale: action.pulse == null ? 1.1 : action.pulse,\n                    duration: 0.4,\n                });\n                if (action.color) {\n                    speechRect.setColor(action.color);\n                }\n                if (action.duration) {\n                    speechRect.animations\n                        .new()\n                        .delay(action.duration)\n                        .dissolveOut(0.2)\n                        .start();\n                }\n            }\n        }\n        else if (action.right != null) {\n            showArrow('right', action.right, action.duration == null ? null : action.duration, action.pulse == null ? 1.1 : action.pulse, action.space == null ? 0.05 : action.space, action.color == null ? null : action.color);\n        }\n        else if (action.left != null) {\n            showArrow('left', action.left, action.duration == null ? null : action.duration, action.pulse == null ? 1.1 : action.pulse, action.space == null ? 0.05 : action.space, action.color == null ? null : action.color);\n        }\n        else if (action.bottom != null) {\n            showArrow('bottom', action.bottom, action.duration == null ? null : action.duration, action.pulse == null ? 1.1 : action.pulse, action.space == null ? 0.05 : action.space, action.color == null ? null : action.color);\n        }\n        else if (action.top != null) {\n            showArrow('top', action.top, action.duration == null ? null : action.duration, action.pulse == null ? 1.1 : action.pulse, action.space == null ? 0.05 : action.space, action.color == null ? null : action.color);\n        }\n        else if (action.fill != null && action.fill == 'hide') {\n            hideHighlight(action);\n            // This happens before action.pulse as action.fill may have a 'pulse' property\n        }\n        else if (action.fill != null) {\n            showFill(action);\n        }\n        else if (action.showContinue != null) {\n            getAnswerInput().showContinue(action.showContinue);\n        }\n        else if (action.pulse != null) {\n            var type = 'scale';\n            var mag = 1.7;\n            var delay = 0;\n            if (action.s != null) {\n                mag = action.s;\n            }\n            if (action.v != null) {\n                mag = action.v;\n                type = 'v';\n            }\n            if (action.h != null) {\n                mag = action.h;\n                type = 'h';\n            }\n            if (action.delay != null) {\n                delay = action.delay;\n            }\n            var duration = action.d != null ? action.d : 0.8;\n            var frequency = action.f != null ? action.f : 2.5;\n            pulseElement(action.pulse, mag, duration, type, frequency, delay);\n        }\n        else if (action.spulse != null) {\n            pulseElement(action.spulse, 1.3, 0.7, 'scale');\n        }\n        else if (action.vpulse != null) {\n            var duration = action.d != null ? action.d : 0.8;\n            var delay = action.delay != null ? action.delay : 0;\n            var stop_1 = action.stop != null ? action.stop : 'cancel';\n            pulseElement(action.vpulse, 0.03, duration, 'v', 2.5, delay, stop_1);\n        }\n        else if (action.vpulseCustom != null) {\n            var duration = action.d != null ? action.d : 0.8;\n            var delay = action.delay != null ? action.delay : 0;\n            var stop_2 = action.stop != null ? action.stop : 'cancel';\n            var mag = 0.03;\n            var frequency = 2.5;\n            var items = action.vpulseCustom;\n            if (!Array.isArray(items)) {\n                items = [items];\n            }\n            for (var i = 0; i < items.length; i += 1) {\n                var item = items[i];\n                // Split on the FIRST `.` so PARAM may itself contain dots\n                // (e.g. `numberline.tick.20` → element=`numberline`, param=`tick.20`).\n                var dotIndex = item.indexOf('.');\n                if (dotIndex < 0) {\n                    continue;\n                }\n                var elementName = item.substring(0, dotIndex);\n                var param = item.substring(dotIndex + 1);\n                var e = getElement(elementName);\n                // A separate scratchpad lives on its own figure, not `figure`.\n                if (e == null && elementName === 'workPad') {\n                    e = (_b = (_a = window.figureWP) === null || _a === void 0 ? void 0 : _a.elements) === null || _b === void 0 ? void 0 : _b._workPad;\n                }\n                if (e == null || e.custom == null || e.custom.getElement == null) {\n                    continue;\n                }\n                var result = e.custom.getElement(param);\n                if (result == null) {\n                    continue;\n                }\n                var targets = Array.isArray(result) ? result : [result];\n                for (var t = 0; t < targets.length; t += 1) {\n                    var pulseTarget = targets[t];\n                    if (pulseTarget == null) {\n                        continue;\n                    }\n                    pulseTarget.stop(stop_2);\n                    var p1 = pulseTarget.pointFromSpaceToSpace([0, 0], 'figure', 'draw');\n                    var p2 = pulseTarget.pointFromSpaceToSpace([0, mag], 'figure', 'draw');\n                    var delta = p2.y - p1.y;\n                    pulseTarget.animations\n                        .new()\n                        .pulse({\n                        delay: delay,\n                        duration: duration,\n                        translation: delta,\n                        min: -delta,\n                        angle: Math.PI / 2,\n                        frequency: frequency,\n                    })\n                        .start();\n                    if (pulseTarget.custom.toPulse != null) {\n                        pulseTarget.custom.toPulse({\n                            delay: delay,\n                            duration: duration,\n                            translation: delta,\n                            min: -delta,\n                            angle: Math.PI / 2,\n                            frequency: frequency,\n                        });\n                    }\n                }\n            }\n        }\n        else if (action.hpulse != null) {\n            var duration = action.d != null ? action.d : 0.8;\n            var delay = action.delay != null ? action.delay : 0;\n            var stop_3 = action.stop != null ? action.stop : 'cancel';\n            pulseElement(action.hpulse, 0.03, duration, 'h', 2.5, delay, stop_3);\n        }\n        else if (action.step_vpulse != null) {\n            var duration = action.d != null ? action.d : 0.8;\n            var delay = action.delay != null ? action.delay : 0;\n            var stop_4 = action.stop != null ? action.stop : 'cancel';\n            // const delayBetween = action.delayBetween != null ? action.delayBetween : 0.2;\n            var cumDelay = delay;\n            for (var i = 0; i < action.step_vpulse.length; i += 1) {\n                var step = action.step_vpulse[i];\n                var stepDuration = duration;\n                var stepDelay = delay;\n                // By default, the first delay is 0 - can be overridden by using\n                // {vpulse: [], delay: 1} for the first element of the step_vpulse list\n                if (i == 0) {\n                    stepDelay = 0;\n                }\n                if (!Array.isArray(step) && typeof step === 'object') {\n                    if (step.duration != null) {\n                        stepDuration = step.duration;\n                    }\n                    if (step.delay != null) {\n                        stepDelay = step.delay;\n                    }\n                    step = step.vpulse;\n                }\n                pulseElement(step, 0.03, stepDuration, 'v', 2.5, cumDelay + stepDelay, stop_4);\n                cumDelay += stepDuration + stepDelay;\n            }\n            // } else if (action.hpulse != null) {\n            //   const duration = action.d != null ? action.d : 0.8;\n            //   const delay = action.delay != null ? action.delay : 0;\n            //   pulseElement(action.hpulse, 0.04, duration, 'h', 2.5, delay);\n        }\n        else if (action.arrowDefaults != null) {\n            setArrowDefaults(action.arrowDefaults);\n        }\n        else if (action.arrow != null && action.arrow == 'hide') {\n            hideHighlight(action);\n        }\n        else if (action.arrow != null || action.arrowCustom != null) {\n            showArrowNew(action);\n        }\n        else if (action.hide != null) {\n            var hide = action.hide;\n            var duration = action.duration != null ? action.duration : 0.4;\n            if (!Array.isArray(action.hide)) {\n                hide = [action.hide];\n            }\n            for (var i = 0; i < hide.length; i += 1) {\n                var hideElem = getElement(hide[i]);\n                if (hideElem != null) {\n                    if (duration === 0) {\n                        hideElem.hide();\n                    }\n                    else {\n                        hideElem.animations.new()\n                            .dissolveOut(duration)\n                            .start();\n                    }\n                }\n            }\n            // const hideElem = getElement(action.hide);\n            // console.log(action.hide, hideElem)\n        }\n        else if (action.show != null) {\n            var showElemNames = action.show;\n            if (!Array.isArray(action.show)) {\n                showElemNames = [action.show];\n            }\n            for (var i = 0; i < showElemNames.length; i += 1) {\n                var showElem = getElement(showElemNames[i]);\n                showElem.show();\n                var showElemBounds = showElem.getBoundingRect('figure');\n                var showElemPosition = showElem.getPosition('figure');\n                var toElem = getElement(action.element);\n                var space = action.space != null ? action.space : 0.05;\n                var duration = action.duration != null ? action.duration : 0.4;\n                var offset = action.offset != null ? Fig.parsePoint(action.offset) : new Fig.Point(0, 0);\n                if (toElem != null) {\n                    var toElemBounds = toElem.getBoundingRect('figure');\n                    // const toElemPosition = toElem.getPosition('figure');\n                    if (action.position === 'left') {\n                        var p = showElemPosition.add(new Fig.Point(toElemBounds.left - (showElemBounds.right + space) + offset.x, toElemBounds.center().y - showElemBounds.center().y + offset.y));\n                        var pLocal = showElem.pointFromSpaceToSpace(p, 'figure', 'local');\n                        showElem.setPosition(pLocal);\n                    }\n                    else if (action.position === 'right') {\n                        var p = showElemPosition.add(new Fig.Point(toElemBounds.right - (showElemBounds.left - space) + offset.x, toElemBounds.center().y - showElemBounds.center().y + offset.y));\n                        var pLocal = showElem.pointFromSpaceToSpace(p, 'figure', 'local');\n                        showElem.setPosition(pLocal);\n                    }\n                    else if (action.position === 'top') {\n                        var p = showElemPosition.add(new Fig.Point(toElemBounds.center().x - showElemBounds.center().x + offset.x, toElemBounds.top - (showElemBounds.bottom - space) + offset.y));\n                        var pLocal = showElem.pointFromSpaceToSpace(p, 'figure', 'local');\n                        showElem.setPosition(pLocal);\n                    }\n                    else if (action.position === 'bottom') {\n                        var p = showElemPosition.add(new Fig.Point(toElemBounds.center().x - showElemBounds.center().x + offset.x, toElemBounds.bottom - (showElemBounds.top + space) + offset.y));\n                        var pLocal = showElem.pointFromSpaceToSpace(p, 'figure', 'local');\n                        showElem.setPosition(pLocal);\n                    }\n                }\n                if (action.duration !== 0) {\n                    showElem.animations.new()\n                        .dissolveIn(duration)\n                        .start();\n                }\n            }\n            // } else if (action.dim != null) {\n            //  // Dimming text does not work as if there is a form layout\n            //  // like after fonts load - it will reset the colors\n            //   const DIM_COLOR = [0.7, 0.7, 0.7, 1];\n            //   let elems;\n            //   if (!Array.isArray(action.dim)) {\n            //     elems = [action.dim];\n            //   } else {\n            //     elems = action.dim;\n            //   }\n            //   for (let i = 0; i < elems.length; i += 1) {\n            //     const elem = getElement(elems[i])\n            //     console.log(elem, action)\n            //     if (elem != null) {\n            //       elem.custom.undimmedColor = elem.color.slice();\n            //       if (elem.setColors != null) {\n            //         elem.setColors('dim', action.duration)\n            //       } else if (action.duration == 0) {\n            //         elem.setColor(DIM_COLOR);\n            //       } else {\n            //         elem.animations.new()\n            //           .color({ target: DIM_COLOR, duration: action.duration })\n            //           .start();\n            //       }\n            //     }\n            //   }\n            // } else if (action.undim != null) {\n            //   const UNDIM_COLOR = figure.defaultColor.slice() as FigureOneColor;\n            //   let elems;\n            //   if (!Array.isArray(action.dim)) {\n            //     elems = [action.dim];\n            //   } else {\n            //     elems = action.dim;\n            //   }\n            //   for (let i = 0; i < elems.length; i += 1) {\n            //     const elem = getElement(elems[i])\n            //     if (elem != null) {\n            //       const color = elem.custom.undimmedColor || UNDIM_COLOR;\n            //       if (elem.setColors != null) {\n            //         elem.setColors('undim', action.duration)\n            //       } else if (action.duration == 0) {\n            //         elem.setColor(color);\n            //       } else {\n            //         elem.animations.new()\n            //           .color({ target: color, duration: action.duration })\n            //           .start();\n            //       }\n            //     }\n            //   }\n        }\n        else if (action.hide_bubble) {\n            figure.custom.bubble.html.classList.add('fade_out');\n        }\n        else if (action.hide_unsnapped) {\n            var hideParent_1 = figure.get(action.hide_unsnapped);\n            if (hideParent_1 != null) {\n                var duration_1 = action.duration != null ? action.duration : 0.4;\n                var hideIfUnsnapped_1 = function (elem) {\n                    if (elem.custom.slot == null\n                        && elem.snappedSlot == null\n                        && elem.snappedFillSlot == null\n                        && !elem.custom.isSnapped\n                        // Tiles living in an answer_container are tracked via\n                        // `answerContainers`, not the tile-slot flags above. Treat them as\n                        // snapped so hide_unsnapped only hides tiles outside any container.\n                        && !(elem.answerContainers != null\n                            && elem.answerContainers.length > 0)) {\n                        elem.isTouchable = false;\n                        elem.custom.disableForm = true;\n                        elem.animations.new()\n                            .opacity({ target: 0, duration: duration_1 })\n                            .start();\n                    }\n                };\n                Object.keys(hideParent_1.elements).forEach(function (key) {\n                    var elem = hideParent_1.elements[key];\n                    if (elem.custom.arrangeTile\n                        || elem.custom.manipulativeType === 'manipulative_tile'\n                        || elem.custom.manipulativeType === 'simple_block'\n                        || elem.custom.manipulativeType === 'linear_blocks') {\n                        if (!action.force && elem.isAnimating()) {\n                            elem.notifications.add('animationFinished', function () {\n                                hideIfUnsnapped_1(elem);\n                            }, 1);\n                        }\n                        else {\n                            hideIfUnsnapped_1(elem);\n                        }\n                    }\n                });\n            }\n        }\n        else if (action.show_unsnapped) {\n            var showParent_1 = figure.get(action.show_unsnapped);\n            if (showParent_1 != null) {\n                var duration_2 = action.duration != null ? action.duration : 0.4;\n                Object.keys(showParent_1.elements).forEach(function (key) {\n                    var elem = showParent_1.elements[key];\n                    if ((elem.custom.arrangeTile\n                        || elem.custom.manipulativeType === 'manipulative_tile'\n                        || elem.custom.manipulativeType === 'simple_block'\n                        || elem.custom.manipulativeType === 'linear_blocks')\n                        && elem.custom.slot == null\n                        && elem.snappedSlot == null\n                        && elem.snappedFillSlot == null\n                        && !elem.custom.isSnapped\n                        // Don't re-show tiles that are sitting inside an answer_container\n                        // (tracked via `answerContainers`, not the tile-slot flags above).\n                        && !(elem.answerContainers != null\n                            && elem.answerContainers.length > 0)) {\n                        elem.isTouchable = true;\n                        elem.custom.disableForm = false;\n                        elem.animations.new()\n                            .opacity({ target: 1, duration: duration_2 })\n                            .start();\n                    }\n                });\n            }\n        }\n        else if (action.hide_keyboard) {\n            if (figure.custom.hideKeyboard) {\n                figure.custom.hideKeyboard(0);\n            }\n        }\n        else if (action.show_keyboard) {\n            if (figure.custom.showKeyboard) {\n                figure.custom.showKeyboard(action.show_keyboard === 0 ? 0 : 1);\n            }\n        }\n        else if (action.hide_answerinput) {\n            var ai = getAnyAnswerInput();\n            if (ai != null && ai.isShown) {\n                ai.hide();\n            }\n        }\n        else if (action.show_answerinput) {\n            var ai = getAnyAnswerInput();\n            if (ai != null) {\n                showAnswerInput(ai);\n            }\n        }\n        else if (action.disable_interactions) {\n            if (!figure.custom.disabled && figure.custom.disableInteraction) {\n                figure.custom.disableInteraction();\n            }\n        }\n        else if (action.enable_interactions) {\n            if (figure.custom.disabled && figure.custom.enableInteraction) {\n                figure.custom.enableInteraction();\n            }\n        }\n        else if (action.exec != null) {\n            execMethodOnElements(action.exec, action);\n        }\n        else if (action.form != null && action.steps != null) {\n            // hideHighlightElements();\n            var elems = void 0;\n            if (!Array.isArray(action.form)) {\n                elems = [action.form];\n            }\n            else {\n                elems = action.form;\n            }\n            for (var i = 0; i < elems.length; i += 1) {\n                var elem = figure.get(elems[i]);\n                var anim = elem.animations.new();\n                for (var j = 0; j < action.steps.length; j += 1) {\n                    var a = action.steps[j];\n                    if (typeof a === 'number') {\n                        anim = anim.delay(action.steps[j]);\n                    }\n                    else {\n                        if (a.animate == null) {\n                            a.animate = 'move';\n                        }\n                        anim = anim.goToForm(a);\n                    }\n                }\n                anim.start();\n            }\n        }\n        else if (action.form != null && typeof action.target == 'string') {\n            // hideHighlightElements();\n            var elems = void 0;\n            if (!Array.isArray(action.form)) {\n                elems = [action.form];\n            }\n            else {\n                elems = action.form;\n            }\n            if (action.animate == null) {\n                action.animate = 'move';\n            }\n            if (action.stop == null) {\n                action.stop = '_stiles_';\n            }\n            var _loop_1 = function (i) {\n                var elem = figure.get(elems[i]);\n                var elementsToStop = [];\n                // console.log(action.stop, action.stop === '_stiles_')\n                if (action.stop === '_tiles_') {\n                    Object.keys(elem.elements).forEach(function (key) {\n                        var stopElem = elem.elements[key];\n                        if (stopElem != null\n                            && stopElem.custom\n                            && (stopElem.custom.arrangeTile\n                                || stopElem.custom.manipulativeType === \"manipulative_tile\"\n                                || stopElem.custom.manipulativeType === \"simple_block\"\n                                || stopElem.custom.manipulativeType === \"linear_blocks\")) {\n                            elementsToStop.push([\n                                stopElem, stopElem.getPosition('local'),\n                            ]);\n                        }\n                    });\n                }\n                else if (action.stop === '_stiles_') {\n                    Object.keys(elem.elements).forEach(function (key) {\n                        var stopElem = elem.elements[key];\n                        if (stopElem != null\n                            && stopElem.custom\n                            && (stopElem.custom.arrangeTile\n                                || stopElem.custom.manipulativeType === \"manipulative_tile\"\n                                || stopElem.custom.manipulativeType === \"simple_block\"\n                                || stopElem.custom.manipulativeType === \"linear_blocks\")) {\n                            if (stopElem.custom.slot != null\n                                || stopElem.snappedSlot != null\n                                || stopElem.snappedFillSlot != null\n                                || stopElem.custom.isSnapped) {\n                                elementsToStop.push([\n                                    stopElem, stopElem.getPosition('local'),\n                                ]);\n                            }\n                            else {\n                                stopElem.custom.initialPosition = stopElem.custom.readyPosition;\n                            }\n                        }\n                    });\n                }\n                else if (action.stop != null) {\n                    for (var j = 0; j < action.stop.length; j += 1) {\n                        var stopElem = getElement(action.stop[j]);\n                        if (stopElem != null) {\n                            elementsToStop.push([stopElem, stopElem.getPosition('local')]);\n                        }\n                    }\n                }\n                var elementsToKeepTransparent = [];\n                Object.keys(elem.elements).forEach(function (key) {\n                    var _a;\n                    var stopElem = elem.elements[key];\n                    if (stopElem != null && ((_a = stopElem.custom) === null || _a === void 0 ? void 0 : _a.disableForm)) {\n                        if (!elementsToStop.some(function (_a) {\n                            var e = _a[0];\n                            return e === stopElem;\n                        })) {\n                            elementsToStop.push([stopElem, stopElem.getPosition('local')]);\n                        }\n                        if (stopElem.opacity === 0) {\n                            elementsToKeepTransparent.push(stopElem);\n                        }\n                    }\n                });\n                elem.animations.new()\n                    .goToForm(action)\n                    .trigger(function () {\n                    for (var j = 0; j < elementsToStop.length; j += 1) {\n                        var stopElem = elementsToStop[j][0];\n                        var pos = elementsToStop[j][1];\n                        if (stopElem.custom.slotPosition != null) {\n                            pos = stopElem.custom.slotPosition;\n                        }\n                        stopElem.animations.cancel('_Equation');\n                        // TODO Remove 'local' here as I don't think it does anything\n                        stopElem.setPosition(pos, 'local');\n                    }\n                    for (var j = 0; j < elementsToKeepTransparent.length; j += 1) {\n                        var stopElem = elementsToKeepTransparent[j];\n                        stopElem.notifications.remove('animated', stopElem.custom.animId);\n                        stopElem.setOpacity(0);\n                    }\n                })\n                    .start();\n                var _loop_2 = function (j) {\n                    var stopElem = elementsToStop[j][0];\n                    var pos = elementsToStop[j][1];\n                    stopElem.notifications.add('animated', function () {\n                        stopElem.animations.cancel('_Equation');\n                        stopElem.animations.cancel('_EquationColor');\n                        stopElem.animations.cancel('_EquationAnimateColor');\n                        // TODO Remove 'local' here as I don't think it does anything\n                        stopElem.setPosition(pos, 'local');\n                    }, 1);\n                };\n                for (var j = 0; j < elementsToStop.length; j += 1) {\n                    _loop_2(j);\n                }\n                var _loop_3 = function (j) {\n                    var stopElem = elementsToKeepTransparent[j];\n                    stopElem.custom.animId = stopElem.notifications.add('animated', function () {\n                        stopElem.setOpacity(0);\n                    });\n                };\n                for (var j = 0; j < elementsToKeepTransparent.length; j += 1) {\n                    _loop_3(j);\n                }\n            };\n            for (var i = 0; i < elems.length; i += 1) {\n                _loop_1(i);\n            }\n        }\n        else if (action.form != null && Array.isArray(action.target)) {\n            // hideHighlightElements();\n            var elems = void 0;\n            if (!Array.isArray(action.form)) {\n                elems = [action.form];\n            }\n            else {\n                elems = action.form;\n            }\n            for (var i = 0; i < elems.length; i += 1) {\n                var elem = figure.get(elems[i]);\n                var anim = elem.animations.new();\n                for (var j = 0; j < action.target.length; j += 1) {\n                    var act = action.target[j];\n                    if (typeof act === 'number') {\n                        anim = anim.delay(act);\n                    }\n                    else {\n                        if (act.animate == null) {\n                            act.animate = 'move';\n                        }\n                        anim = anim.goToForm(act);\n                    }\n                }\n                anim.start();\n            }\n        }\n        else if (action.seek != null) {\n            figure.speechManager.maxSeek = Math.max(figure.speechManager.maxSeek, action.index);\n            figure.speechManager.updateSeekEnabled(figure.speechManager.maxSeek);\n            figure.speechManager.seekPosition = action.index;\n            figure.speechManager.updateSeekPosition(0);\n        }\n        else if (action.continue != null) {\n            figure.speechManager.showContinueOnEnd = action.continue === 'show';\n        }\n        else if (action.addClass != null) {\n            addClassToElements(action.addClass, action.class);\n        }\n        else if (action.removeClass != null) {\n            addClassToElements(action.removeClass, action.class, false);\n        }\n        else if (action.pause != null) {\n            speechManager.actionIndex += 1;\n            figure.speechManager.pause();\n            if (action.method != null) {\n                execMethodOnElements(action.pause, action);\n            }\n        }\n        else if (action.clearTimeouts != null) {\n            window.__clearTimeouts();\n        }\n        else if (action.play_continue) {\n            stop();\n            figure.custom.disableInteraction();\n            if (figure.speechManager.playContainer) {\n                figure.speechManager.playContainer.style.display = 'none';\n            }\n            request('POST', 'alpha/decision', { goto: 'next_question', time: Fig.round(performance.now() - figure.loadTime, 0), speech: figure.custom.getSpeechStats(), id: figure.question_id }, function (response) { return processResponse(response, null); });\n        }\n    }\n    /*\n    .##.....##....###....##....##....###.....######...########.########.\n    .###...###...##.##...###...##...##.##...##....##..##.......##.....##\n    .####.####..##...##..####..##..##...##..##........##.......##.....##\n    .##.###.##.##.....##.##.##.##.##.....##.##...####.######...########.\n    .##.....##.#########.##..####.#########.##....##..##.......##...##..\n    .##.....##.##.....##.##...###.##.....##.##....##..##.......##....##.\n    .##.....##.##.....##.##....##.##.....##..######...########.##.....##\n    */\n    // Increment per-question generation counter.  Async callbacks (speech_urls\n    // POST, audio fetch/decode, marks fetch) capture this value and bail out if\n    // it no longer matches — preventing stale responses from a previous question\n    // from corrupting the current question's speech data.\n    figure._speechGeneration = (figure._speechGeneration || 0) + 1;\n    var speechGeneration = figure._speechGeneration;\n    figure.speechManager = {\n        currentAudio: null,\n        isPlaying: false,\n        chunkIndex: 0,\n        chunkDelayDone: false,\n        chunkDelayStart: 0,\n        chunkDelayRemaining: 0,\n        timeStart: null,\n        playDuration: 0,\n        completeCount: 0,\n        startCount: 0,\n        useCaptions: false,\n        actionIndex: 0,\n        initialActionIndex: 0,\n        actionTimeoutId: null,\n        captionIndex: 0,\n        captionTimeoutId: null,\n        delayTimeoutId: null,\n        playbackRate: 1,\n        showArrow: showArrow,\n        speechRect: speechRect,\n        speechArrow: speechArrow,\n        pulseElement: pulseElement,\n        executeAction: executeAction,\n        offlineSpeech: false,\n        maxSeek: 0,\n        seekPosition: 0,\n        freeze: null,\n        toPlayButton: function () { },\n        toPauseButton: function () { },\n        ctx: null,\n        soundCtx: null,\n        _soundBuffers: {},\n        _soundPreloadQueue: [],\n        _currentSoundSource: null,\n        rate: 1,\n        showContinueOnEnd: true,\n        playStartedTime: 0,\n        interruptedState: null,\n    };\n    var speechManager = figure.speechManager;\n    // Returns true if a new question has been loaded since this speech manager\n    // was created.  Used by async callbacks to bail out when their response\n    // belongs to a previous question.\n    function isStaleGeneration() {\n        return speechGeneration !== figure._speechGeneration;\n    }\n    var FETCH_LANE_CAPACITY = {\n        mp3: MP3_FETCH_MAX_CONCURRENT,\n        marks: MARKS_FETCH_MAX_CONCURRENT,\n    };\n    var fetchesInFlight = { mp3: [], marks: [] };\n    var fetchQueues = { mp3: [], marks: [] };\n    function startFetch(kind, entry) {\n        fetchesInFlight[kind].push(entry);\n        entry.start();\n    }\n    /**\n     * Runs `entry` now if its lane has a free slot (returns true), pre-empts a\n     * fetch of another speech if the entry belongs to the speech being played\n     * (true), or queues it (false).\n     */\n    function acquireFetchSlot(kind, entry) {\n        var inFlight = fetchesInFlight[kind];\n        if (inFlight.length < FETCH_LANE_CAPACITY[kind]) {\n            startFetch(kind, entry);\n            return true;\n        }\n        if (isActiveSpeechAudio(entry.audio)) {\n            var at = inFlight.findIndex(function (e) { return e.yieldSlot != null && !isActiveSpeechAudio(e.audio); });\n            if (at !== -1) {\n                var victim = inFlight.splice(at, 1)[0];\n                var yieldSlot = victim.yieldSlot;\n                victim.yieldSlot = null;\n                // The victim's abort settles asynchronously; its catch sees `yielded`\n                // and re-queues it via acquireFetchSlot. Its slot is ours now.\n                yieldSlot();\n                startFetch(kind, entry);\n                return true;\n            }\n        }\n        var queue = fetchQueues[kind];\n        if (entry.preload) {\n            queue.push(entry);\n        }\n        else {\n            var at = 0;\n            while (at < queue.length && !queue[at].preload)\n                at += 1;\n            queue.splice(at, 0, entry);\n        }\n        return false;\n    }\n    /**\n     * Forget a chunk whose download exhausted its retries, so the next\n     * loadAudio() downloads it afresh. Only called from a playback request\n     * (play(), or playChunk/playInner reaching the chunk): loadAudio() itself\n     * never re-queues a 'failed' chunk, because it also runs from every\n     * speech_urls response callback, and a late response for a later batch\n     * used to restart a chunk that had already failed and ended the speech -\n     * six attempts and two reports for one play instead of three and one.\n     */\n    function isChunkFailed(speech) {\n        var _a, _b;\n        // Needed marks that exhausted their retries fail the chunk as surely as\n        // its audio (see getMarks handleExhaustion).\n        return ((_a = speech === null || speech === void 0 ? void 0 : speech.audio) === null || _a === void 0 ? void 0 : _a.state) === 'failed' || ((_b = speech === null || speech === void 0 ? void 0 : speech.marks) === null || _b === void 0 ? void 0 : _b.state) === 'failed';\n    }\n    function resetFailedChunk(speech) {\n        if (!isChunkFailed(speech))\n            return;\n        speech.audio = null;\n        speech._audioLoading = false;\n        speech.onLoad = null;\n    }\n    function resetFailedChunks(speechId) {\n        var _a;\n        if (speechId == null)\n            return;\n        var chunks = (_a = figure.chunkedSpeech) === null || _a === void 0 ? void 0 : _a[speechId];\n        if (!chunks)\n            return;\n        for (var i = 0; i < chunks.length; i += 1) {\n            resetFailedChunk(chunks[i]);\n        }\n    }\n    /**\n     * Makes `speechId`'s loads the active speech's loads: its queued loads move\n     * to the front of their lanes, in chunk order, marked active, so a preloaded\n     * speech that is then played does not wait behind preloads of speeches that\n     * may never play. (Its in-flight competitors are handled by pre-emption when\n     * the next load of this speech needs a slot.) Called when playback of a\n     * speech begins (play(), which interrupts also route through) and again from\n     * playChunk when a chunk is found still loading. Idempotent.\n     */\n    function adoptSpeechLoads(speechId) {\n        var _a, _b;\n        if (speechId == null)\n            return;\n        var chunks = (_a = figure.chunkedSpeech) === null || _a === void 0 ? void 0 : _a[speechId];\n        if (!chunks)\n            return;\n        var audios = [];\n        for (var i = 0; i < chunks.length; i += 1) {\n            var audio = (_b = chunks[i]) === null || _b === void 0 ? void 0 : _b.audio;\n            if (audio == null)\n                continue;\n            audio._isPreload = false;\n            audios.push(audio);\n            leaveSharedWaits(audio);\n        }\n        if (audios.length === 0)\n            return;\n        Object.keys(fetchQueues).forEach(function (kind) {\n            var queue = fetchQueues[kind];\n            if (queue.length === 0)\n                return;\n            var promoted = [];\n            audios.forEach(function (audio) {\n                for (var at = 0; at < queue.length;) {\n                    if (queue[at].audio === audio) {\n                        var entry = queue.splice(at, 1)[0];\n                        entry.preload = false;\n                        promoted.push(entry);\n                    }\n                    else {\n                        at += 1;\n                    }\n                }\n            });\n            if (promoted.length > 0) {\n                queue.unshift.apply(queue, promoted);\n            }\n        });\n    }\n    /**\n     * A chunk of the speech now playing that is waiting on another speech's\n     * shared load (see sharedLeadFor) fetches for itself instead.\n     */\n    function leaveSharedWaits(audio) {\n        var _a, _b;\n        (_a = audio._leaveSharedWait) === null || _a === void 0 ? void 0 : _a.call(audio);\n        (_b = audio._leaveSharedMarksWait) === null || _b === void 0 ? void 0 : _b.call(audio);\n    }\n    /** True if `audio` belongs to a chunk of the speech currently playing. */\n    function isActiveSpeechAudio(audio) {\n        var _a, _b;\n        var chunks = (_a = figure.chunkedSpeech) === null || _a === void 0 ? void 0 : _a[figure.speechId];\n        if (!chunks)\n            return false;\n        for (var i = 0; i < chunks.length; i += 1) {\n            if (((_b = chunks[i]) === null || _b === void 0 ? void 0 : _b.audio) === audio)\n                return true;\n        }\n        return false;\n    }\n    /**\n     * Gives `entry`'s slot to the next queued fetch in its lane, or frees it.\n     * A no-op if the entry is not in flight -- already released, or yielded --\n     * so every exit path of a retry chain can call it without double-counting.\n     */\n    function releaseFetchSlot(kind, entry) {\n        var inFlight = fetchesInFlight[kind];\n        var at = inFlight.indexOf(entry);\n        if (at === -1)\n            return;\n        inFlight.splice(at, 1);\n        var next = fetchQueues[kind].shift();\n        if (next != null) {\n            // If `start` bails synchronously (stale token) it releases again and\n            // the queue keeps draining.\n            startFetch(kind, next);\n        }\n    }\n    /** One fetch's standing in a lane: its entry plus an idempotent release. */\n    function makeFetchSlot(kind, preload, audio) {\n        var entry = { start: function () { }, preload: preload, audio: audio, yieldSlot: null };\n        return {\n            entry: entry,\n            acquire: function (start) {\n                entry.start = start;\n                return acquireFetchSlot(kind, entry);\n            },\n            release: function () { releaseFetchSlot(kind, entry); },\n        };\n    }\n    // Stall watchdog: ticks every 1s while a speech is in flight.  isPlaying\n    // is NOT a reliable signal — playChunk sets it true before audio is verified\n    // ready, so a stuck speech.onLoad leaves isPlaying=true indefinitely.  We\n    // track real progress via (chunkIndex, currentAudio.getCurrentTime()) and\n    // fire playFinished if neither advances within STALL_THRESHOLD_MS while\n    // not paused.  Without this, a dead chunk leaves the question stuck with\n    // the answer input hidden and interactions disabled.\n    // Two-phase threshold.  The first chunk has to fetch + decode from a cold\n    // connection, so allow 10s before declaring a stall.  The MP3 fetch retry\n    // chain can legitimately run longer than that (~17s if every attempt hangs),\n    // but it does not race this clock: every attempt on the active speech's\n    // audio resets _stallLastProgressAt, so a live retry chain is progress and\n    // the watchdog only fires when nothing has happened for 10s -- a stuck\n    // speech_urls POST, a load queued behind hung preloads in the MP3 fetch\n    // limiter, a decode that never returns.  A chunk whose every attempt hangs\n    // is therefore ended by the retry path, with its \"Speech fetch hung\"\n    // telemetry, whatever the upstream latency.  Once any audio progress has\n    // been observed (chunkIndex bump or currentTime advance), the connection is\n    // warm and subsequent chunks should hand off quickly — shorten to 5s so a\n    // real stall doesn't leave the question stuck for longer than needed.  When\n    // the watchdog fires under either threshold, the restore path leaves the\n    // question fully usable so the learner can read and answer without the\n    // audio.\n    var INITIAL_LOAD_THRESHOLD_MS = 10000;\n    var STALL_THRESHOLD_MS = 5000;\n    var STALL_POLL_MS = 1000;\n    function stopStallWatchdog() {\n        if (speechManager._stallWatchdogId != null) {\n            clearInterval(speechManager._stallWatchdogId);\n            speechManager._stallWatchdogId = null;\n        }\n    }\n    // The play/pause button reflects state of the question's \"main\" speech —\n    // the auto/manual/default flow.  Custom speech IDs (e.g. touch-to-speak\n    // word audio preloaded under a content-defined id) should play through\n    // play() without flipping the icon, so the user's mental model of\n    // \"the button controls the question's speech\" stays intact.\n    function isMainSpeech(sid) {\n        var id = sid !== null && sid !== void 0 ? sid : figure.speechId;\n        return id === 'default'\n            || id === AUTO_SPEECH_ID\n            || id === MANUAL_SPEECH_ID;\n    }\n    speechManager.isMainSpeech = isMainSpeech;\n    // Cancel any pending download / load-callback for the current speech.\n    // Bumping loadToken invalidates the tokenValid() guards inside an\n    // in-flight load() so its continuations bail.  Nulling speech.onLoad\n    // prevents a download that eventually resolves from re-triggering\n    // playChunk (which would resurrect the speech after we've already\n    // declared it finished).\n    function abortCurrentSpeechLoads() {\n        var _a;\n        var chunks = (_a = figure.chunkedSpeech) === null || _a === void 0 ? void 0 : _a[figure.speechId];\n        if (!chunks)\n            return;\n        for (var i = 0; i < chunks.length; i += 1) {\n            var chunk = chunks[i];\n            if (!chunk)\n                continue;\n            chunk.onLoad = null;\n            if (chunk.audio != null) {\n                chunk.audio.loadToken = (chunk.audio.loadToken || 0) + 1;\n            }\n        }\n    }\n    function forceStall() {\n        abortCurrentSpeechLoads();\n        // Chunk-delay setTimeouts call playChunk() directly when they fire,\n        // bypassing the speech.onLoad gate.  If a delay is pending when we\n        // force-stall, clear it so it can't resurrect playback.\n        if (speechManager.delayTimeoutId) {\n            clearTimeout(speechManager.delayTimeoutId);\n            speechManager.delayTimeoutId = null;\n        }\n        stopStallWatchdog();\n        playFinished();\n    }\n    function startStallWatchdog() {\n        stopStallWatchdog();\n        var lastChunkIndex = speechManager.chunkIndex;\n        var lastCurrentTime = -1;\n        var hasMadeProgress = false;\n        speechManager._stallLastProgressAt = performance.now();\n        speechManager._stallWatchdogId = setInterval(function () {\n            var _a, _b, _c, _d, _e, _f, _g, _h;\n            if (isStaleGeneration()) {\n                stopStallWatchdog();\n                return;\n            }\n            // Paused via the speaker icon — don't penalize the wait.\n            if (speechManager.freeze != null) {\n                speechManager._stallLastProgressAt = performance.now();\n                return;\n            }\n            // Tab hidden — audio may legitimately not advance.  suspendWhileHidden\n            // deliberately leaves the context running mid-speech, but iOS freezes\n            // the graph clock in the background anyway (while ctx.state still\n            // reads 'running'), and background tabs throttle timers.  Counting\n            // this as a stall killed the speech for any learner who tabbed away\n            // for >5s instead of letting it carry on when they came back.  A\n            // real stall is still caught 5s after they return.\n            if (document.hidden) {\n                speechManager._stallLastProgressAt = performance.now();\n                return;\n            }\n            var chunkIndex = speechManager.chunkIndex;\n            var currentTime = (_c = (_b = (_a = speechManager.currentAudio) === null || _a === void 0 ? void 0 : _a.getCurrentTime) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : -1;\n            if (chunkIndex !== lastChunkIndex || currentTime !== lastCurrentTime) {\n                lastChunkIndex = chunkIndex;\n                lastCurrentTime = currentTime;\n                speechManager._stallLastProgressAt = performance.now();\n                hasMadeProgress = true;\n                return;\n            }\n            // A chunk whose audio is still downloading (or being re-fetched after\n            // an earlier failure) is waiting on the network, not stalled: give it\n            // the initial-load budget even mid-speech.  The attempt() stamps keep a\n            // live chain alive, but the 5s mid-speech threshold is shorter than the\n            // 8s third-attempt cap, so without this the chain was still cut for\n            // any chunk after the first.\n            var waitingChunk = (_e = (_d = figure.chunkedSpeech) === null || _d === void 0 ? void 0 : _d[figure.speechId]) === null || _e === void 0 ? void 0 : _e[chunkIndex];\n            var waitingOnLoad = waitingChunk != null && (waitingChunk.audio == null\n                || waitingChunk.audio.state === 'loading'\n                || waitingChunk.audio.state === 'failed'\n                || ((_f = waitingChunk.marks) === null || _f === void 0 ? void 0 : _f.state) === 'waiting'\n                || ((_g = waitingChunk.marks) === null || _g === void 0 ? void 0 : _g.state) === 'failed');\n            var threshold = (hasMadeProgress && !waitingOnLoad)\n                ? STALL_THRESHOLD_MS\n                : INITIAL_LOAD_THRESHOLD_MS;\n            var elapsed = performance.now() - (speechManager._stallLastProgressAt || 0);\n            if (elapsed > threshold) {\n                // eslint-disable-next-line no-console\n                console.log(\"speech stall watchdog: forcing playFinished after \".concat(Math.round(elapsed), \"ms with no progress (threshold=\").concat(threshold, \"ms, \").concat(hasMadeProgress ? 'mid-speech' : 'initial-load', \")\"));\n                var chunks = (_h = figure.chunkedSpeech) === null || _h === void 0 ? void 0 : _h[figure.speechId];\n                var totalChunks = chunks ? chunks.length : 0;\n                var chunk = chunks === null || chunks === void 0 ? void 0 : chunks[chunkIndex];\n                // Reporting must never block the stall recovery below.  logError can\n                // reach postJSError synchronously (this err has no stack), so an\n                // argument or serialization failure would otherwise leave the learner\n                // stuck with speech playing and the answer input hidden.\n                try {\n                    logError({\n                        msg: \"Speech stall: no progress for \".concat(Math.round(elapsed), \"ms\"),\n                        recovered: true,\n                    }, \"Speech stall watchdog fired (\".concat(hasMadeProgress ? 'mid-speech' : 'initial-load', \", chunk \").concat(chunkIndex, \"/\").concat(totalChunks, \", threshold=\").concat(threshold, \"ms, speechId=\").concat(figure.speechId, \")\"), speechStallSnapshot(speechManager, chunk, figure.speechId, (chunk === null || chunk === void 0 ? void 0 : chunk.ssml) != null ? hashSSML(chunk.ssml) : null, totalChunks));\n                }\n                catch ( /* reporting is best-effort */_j) { /* reporting is best-effort */ }\n                forceStall();\n            }\n        }, STALL_POLL_MS);\n    }\n    // Debug: window.sw() force-trips the stall watchdog so the current speech\n    // skips to playFinished within ~1s.  Useful for manually exercising the\n    // restore path without waiting for a real stall.\n    window.sw = function () {\n        if (speechManager._stallWatchdogId == null) {\n            // eslint-disable-next-line no-console\n            console.log('sw: no active speech stall watchdog');\n            return;\n        }\n        // Back-date past the larger threshold so this trips in either phase.\n        speechManager._stallLastProgressAt = performance.now() - (INITIAL_LOAD_THRESHOLD_MS + 1000);\n        // eslint-disable-next-line no-console\n        console.log('sw: stall watchdog will fire on next tick (<=1s)');\n    };\n    // Store per-question elements so teardown can release them.\n    speechManager.speechRect = speechRect;\n    speechManager.speechArrow = speechArrow;\n    speechManager.pulseElement = pulseElement;\n    speechManager.resetSpeechStats = function () {\n        speechManager.startCount = 0;\n        speechManager.completeCount = 0;\n        speechManager.playDuration = 0;\n    };\n    // Remove element(s) from freeze and interrupted state so they won't be\n    // restored on resume. Pass dot-separated paths like 'expression.voice1'.\n    // Converts to state path: elements.expression.elements.voice1\n    speechManager.removeFromState = function (elements) {\n        var names = typeof elements === 'string' ? [elements] : elements;\n        function removeFromObj(state) {\n            if (state == null)\n                return;\n            for (var n = 0; n < names.length; n += 1) {\n                var parts = names[n].split('.');\n                // Build path: each part is preceded by 'elements'\n                // e.g. 'expression.voice1' -> ['elements','expression','elements','voice1']\n                var obj = state;\n                for (var i = 0; i < parts.length - 1; i += 1) {\n                    if (obj == null || obj.elements == null || obj.elements[parts[i]] == null) {\n                        obj = null;\n                        break;\n                    }\n                    obj = obj.elements[parts[i]];\n                }\n                if (obj != null && obj.elements != null) {\n                    delete obj.elements[parts[parts.length - 1]];\n                }\n            }\n        }\n        if (speechManager.freeze != null) {\n            removeFromObj(speechManager.freeze.state.elements);\n        }\n        if (speechManager.interruptedState != null) {\n            removeFromObj(speechManager.interruptedState.figureState.elements);\n        }\n    };\n    speechManager.clearCachedSpeech = function () {\n        var allSpeech = figure.chunkedSpeech;\n        var currentId = figure.speechId;\n        for (var _i = 0, _a = Object.keys(allSpeech); _i < _a.length; _i++) {\n            var speechId = _a[_i];\n            // Signed hints belong to the old voice/settings, including unused\n            // hints on current or previously played chunks that might be replayed.\n            for (var _b = 0, _c = allSpeech[speechId]; _b < _c.length; _b++) {\n                var chunk = _c[_b];\n                delete chunk.cached_speech;\n            }\n            var startIdx = speechId === currentId ? speechManager.chunkIndex + 1 : 0;\n            for (var i = startIdx; i < allSpeech[speechId].length; i += 1) {\n                allSpeech[speechId][i].audio = null;\n                allSpeech[speechId][i]._audioLoading = false;\n                allSpeech[speechId][i].marks = {\n                    stamps: [], captionStamps: [], state: 'waiting', url: null,\n                };\n                allSpeech[speechId][i].onLoad = null;\n            }\n        }\n    };\n    /*\n    ..######..########..########.########..######..##.....##\n    .##....##.##.....##.##.......##.......##....##.##.....##\n    .##.......##.....##.##.......##.......##.......##.....##\n    ..######..########..######...######...##.......#########\n    .......##.##........##.......##.......##.......##.....##\n    .##....##.##........##.......##.......##....##.##.....##\n    ..######..##........########.########..######..##.....##\n  \n    .########.####.##.....##.####.##....##..######..\n    ....##.....##..###...###..##..###...##.##....##.\n    ....##.....##..####.####..##..####..##.##........\n    ....##.....##..##.###.##..##..##.##.##.##...####.\n    ....##.....##..##.....##..##..##..####.##....##.\n    ....##.....##..##.....##..##..##...###.##....##.\n    ....##....####.##.....##.####.##....##..######..\n    */\n    // Speech timing uses the generic timer module from ./question/timer.ts\n    // Timer ID is based on ssmlHash; audioHash is stored in data when available\n    // Threshold for sending timing data to backend (ms). Only a chunk whose\n    // load took at least this long posts a frontend_timing report; the timeout\n    // paths (hung fetch, slow decode, total timeout) report regardless. At 0\n    // every chunk reported: 96,105 requests on 2026-09-24, 99 % of them healthy,\n    // and frontend_timing was the busiest endpoint on the site (capacity.md).\n    var SPEECH_SLOW_THRESHOLD = 3000;\n    // Simple hash function for SSML content (creates a short identifier)\n    function hashSSML(ssml) {\n        var hash = 0;\n        for (var i = 0; i < ssml.length; i += 1) {\n            var char = ssml.charCodeAt(i);\n            hash = ((hash << 5) - hash) + char;\n            hash = hash & hash; // Convert to 32bit integer\n        }\n        return \"ssml_\".concat(Math.abs(hash).toString(16));\n    }\n    // Extract hash from audio URL (e.g., \"696d0fc5cd43c351ee620ea4dd88f852\" from the URL)\n    function extractHashFromUrl(url) {\n        var match = url.match(/\\/([a-f0-9]{32})\\.mp3/i);\n        return match ? match[1] : null;\n    }\n    // Each chunk load gets its own timer. Named by ssml hash alone, two chunks\n    // with the same text (e.g. \"Yes\" in two Yes/No prompts) shared one timer,\n    // and the first to finish deleted it from under the other.\n    var speechTimerSeq = 0;\n    // speech_<seq>_<ssml hash>: speechFetchSnapshot reads the hash back off the\n    // end of the id for its reports.\n    function speechTimerId(ssmlHash) {\n        speechTimerSeq += 1;\n        return \"speech_\".concat(speechTimerSeq, \"_\").concat(ssmlHash);\n    }\n    // A chunk's load timer covers its MP3 and, when it has one, its marks file:\n    // the chunk isn't ready until both are in. It is stopped once every part\n    // has settled. Stopped on the MP3 decode alone, the marks fetch - which has\n    // a single fetch slot and so usually finishes later - recorded its outcome\n    // on a timer that no longer existed.\n    var loadTimerParts = {};\n    function openLoadTimer(timerId, parts) {\n        loadTimerParts[timerId] = parts;\n    }\n    /** The load timer is still collecting: not stopped, cancelled or torn down. */\n    function loadTimerOpen(timerId) {\n        return timerId != null && loadTimerParts[timerId] != null && hasTimer(timerId);\n    }\n    function finishLoadTimerPart(timerId) {\n        if (!loadTimerOpen(timerId))\n            return;\n        loadTimerParts[timerId] -= 1;\n        if (loadTimerParts[timerId] > 0)\n            return;\n        delete loadTimerParts[timerId];\n        stopTimer({ timerId: timerId, threshold: SPEECH_SLOW_THRESHOLD });\n    }\n    function cancelLoadTimer(timerId) {\n        if (!loadTimerOpen(timerId))\n            return;\n        delete loadTimerParts[timerId];\n        cancelTimer(timerId);\n    }\n    var sharedAudio = {};\n    var sharedMarks = {};\n    /** A file's identity: its url without the query (presigned urls differ per request). */\n    function speechFileKey(url) {\n        if (!url)\n            return null;\n        return url.split('?')[0];\n    }\n    /** The load of `key` that `owner` may wait on, if any. */\n    function sharedLeadFor(shared, key, owner, preload) {\n        if (key == null)\n            return null;\n        var lead = shared[key];\n        if (lead == null || lead.owner === owner)\n            return null;\n        if (lead.done)\n            return lead;\n        if (lead.preload && !preload)\n            return null;\n        // Nor does a load for the playing speech wait on another speech's load\n        // (e.g. one it superseded): the limiter pre-empts only for loads that\n        // ask for a slot, so a hung superseded download would hold it up.\n        if (isActiveSpeechAudio(owner) && !isActiveSpeechAudio(lead.owner))\n            return null;\n        return lead;\n    }\n    /**\n     * Make `owner` the lead for `key`. Always a fresh lead: an abandoned chain\n     * of the same owner then fails only its own lead (failSharedLoad checks\n     * identity), never the one a new chain is loading.\n     */\n    function leadSharedLoad(shared, key, owner, preload) {\n        var settle = function () { };\n        var reject = function () { };\n        var promise = new Promise(function (res, rej) {\n            settle = res;\n            reject = function () { return rej(new Error('shared speech load failed')); };\n        });\n        // Waiters handle a failure themselves; don't let it surface as unhandled.\n        promise.catch(function () { });\n        var lead = {\n            owner: owner,\n            preload: preload,\n            done: false,\n            promise: promise,\n            resolve: function (value) { lead.done = true; settle(value); },\n            reject: reject,\n        };\n        if (key != null)\n            shared[key] = lead;\n        return lead;\n    }\n    function failSharedLoad(shared, key, lead) {\n        if (key != null && shared[key] === lead)\n            delete shared[key];\n        lead.reject();\n    }\n    /*\n    ....###....##.....##.########..####..#######.\n    ...##.##...##.....##.##.....##..##..##.....##\n    ..##...##..##.....##.##.....##..##..##.....##\n    .##.....##.##.....##.##.....##..##..##.....##\n    .#########.##.....##.##.....##..##..##.....##\n    .##.....##.##.....##.##.....##..##..##.....##\n    .##.....##..#######..########..####..#######.\n    */\n    // `timerId` is recorded only once loadAudio has opened it (openLoadTimer);\n    // a timer that was never opened gets no checkpoints (see loadTimerOpen).\n    function makeAudio(url, timerId) {\n        var ctx = speechManager.ctx;\n        var matchResult = url.match(/\\/AWS\\/(.*\\.mp3)/);\n        // let urlSimple: string | null = url.match(/\\/AWS\\/(.*\\.mp3)/);\n        var urlSimple;\n        if (matchResult != null) {\n            urlSimple = matchResult[1];\n        }\n        else {\n            urlSimple = null;\n        }\n        var audio = {\n            buffer: null,\n            duration: 0,\n            onEnd: null,\n            onLoad: null,\n            state: null,\n            startTime: 0,\n            pauseTime: 0,\n            playbackRate: 1,\n            url: url,\n            urlSimple: urlSimple,\n            timerId: timerId,\n        };\n        function playBuffer(atTime) {\n            if (atTime === void 0) { atTime = 0; }\n            var source = ctx.createBufferSource();\n            source.buffer = audio.buffer;\n            source.playbackRate.value = audio.playbackRate;\n            source.connect(ctx.destination);\n            source.addEventListener('ended', function () {\n                var notPaused = audio.pauseTime === 0;\n                audio.state = 'ready';\n                audio.startTime = 0;\n                if (notPaused) {\n                    audio.pauseTime = 0;\n                }\n                if (notPaused && audio.onEnd != null) {\n                    // eslint-disable-next-line\n                    // console.log('ended', audio.urlSimple)\n                    audio.onEnd();\n                }\n            });\n            audio.state = 'playing';\n            audio.pauseTime = 0;\n            audio.startTime = atTime;\n            audio.source = source;\n            audio.contextStartTime = source.context.currentTime;\n            source.start(0, atTime);\n            clearAudioFailed();\n        }\n        // Fetches the MP3 binary at audio.url, decodes it into an AudioBuffer, and\n        // hands the buffer to audio.onLoad (which playChunk has wired up to resume\n        // playback). Stores the buffer on audio.buffer and flips audio.state to\n        // 'ready'. On unrecoverable failure, calls playFinished() to end the whole\n        // speech and logs the error.\n        //\n        // Retry strategy: up to 3 attempts. Two distinct timings — don't conflate\n        // them:\n        //   - RETRY_ATTEMPT_TIMEOUTS_MS (3s, 5s, 8s): a *ceiling* on each attempt,\n        //     not a delay. AbortController kills the fetch if it hangs that long.\n        //     Real failures (5xx, TypeError, etc.) reject in tens of ms; the cap\n        //     only bites on stuck or very slow connections. It grows per attempt\n        //     so a slow-but-working link gets room on retry without making a dead\n        //     connection slow to detect on the first try.\n        //   - RETRY_BACKOFF_MS ([300, 900]): how long to wait *after* a failure before\n        //     starting the next attempt. Short because the learner is sitting in\n        //     silence — fail-fast paths total ~1.4s across all 3 attempts.\n        // Retryable: timeouts (our AbortController firing — whether mid-headers\n        // or mid-body, so a 200 whose body stalls still retries), 5xx, 408,\n        // TypeError (network-layer failure: DNS / TCP reset / CORS). Non-retryable\n        // (other 4xx, decode errors) fail immediately. Worst case before\n        // exhaustion is 3 + 0.3 + 5 + 0.9 + 8 ≈ 17.2s, only if every attempt\n        // hangs. That is longer than the initial-load stall watchdog's 10s, so\n        // each attempt on the active speech's audio resets the watchdog's\n        // progress clock: a live retry chain is progress, and the retry always\n        // exhausts first and ends the speech via this path with proper \"hung\"\n        // telemetry, whatever the speech_urls latency ahead of it. Attempts on a\n        // preload's audio do not reset it -- a hung preload must not hide a stall\n        // on the speech the learner is actually waiting for -- and the limiter\n        // pre-empts a preload's slot for the active speech, so an active load is\n        // never left queued, attempt-less, behind one.\n        //\n        // Two staleness guards prevent late callbacks from clobbering fresh state:\n        //   - isStaleGeneration(): module-level check against\n        //     figure._speechGeneration. Bumped on question teardown / interrupt, so\n        //     in-flight retries from the prior question silently bail.\n        //   - audio.loadToken: per-audio-object counter, incremented every time\n        //     load() is called on this same audio. Catches the (currently\n        //     theoretical) case of load() being re-invoked on the same audio\n        //     object — a stale retry from the earlier load() chain sees a mismatch\n        //     and bails instead of overwriting a buffer the new chain just\n        //     produced.\n        // Both checks are wrapped in tokenValid(); every async continuation\n        // (fetch.then, fetch.catch, the backoff setTimeout) calls it before\n        // touching audio.* or scheduling more work.\n        //\n        // Telemetry: each attempt records a `fetch_attempt_N` checkpoint on the\n        // speech timer; success records retry_count + fetch_outcome=\n        // succeeded_on_attempt_N; exhaustion records fetch_outcome=exhausted plus\n        // fetch_attempts (the per-attempt failure-kind list). The exhaustion\n        // logError context distinguishes pure-hang failures (`Speech fetch hung\n        // …`) from mixed/server failures (`Speech fetch exhausted [kinds…]`) so\n        // the backend can tell stuck-connection cases from transient 5xx storms.\n        // Slow-decode reporting still happens in decode() via stopTimer().\n        function load() {\n            audio.loadToken = (audio.loadToken || 0) + 1;\n            var loadToken = audio.loadToken;\n            var tokenValid = function () {\n                return !isStaleGeneration() && audio.loadToken === loadToken;\n            };\n            audio.state = 'loading';\n            var fileKey = speechFileKey(audio.url);\n            var preload = !!audio._isPreload;\n            function setLoaded(buffer) {\n                audio.buffer = buffer;\n                audio.duration = buffer.duration;\n                audio.state = 'ready';\n                if (audio.onLoad != null) {\n                    audio.onLoad();\n                }\n            }\n            function fetchOwn() {\n                // Read _isPreload now, not when load() began: a waiter whose speech\n                // started playing meanwhile (adoptSpeechLoads) is no longer a preload.\n                var own = leadSharedLoad(sharedAudio, fileKey, audio, !!audio._isPreload);\n                // tokenValid() for this chain. When the chain is abandoned - the\n                // question moved on, or the stall watchdog aborted this speech's loads\n                // (abortCurrentSpeechLoads) - it also gives up the shared lead, so a\n                // chunk waiting on this file fetches it for itself instead of waiting\n                // on a load that will never finish.\n                var stillValid = function () {\n                    if (tokenValid())\n                        return true;\n                    failSharedLoad(sharedAudio, fileKey, own);\n                    return false;\n                };\n                // Per-attempt failure kind, accumulated across retries so the final\n                // logError can describe the failure pattern (all hangs vs mixed vs all\n                // 5xx, etc.). Kinds: 'timeout' | 'status_<code>' | 'network' | err.name.\n                var attemptHistory = [];\n                // This load's slot in the MP3 fetch lane, held across retries.\n                var slot = makeFetchSlot('mp3', !!audio._isPreload, audio);\n                var releaseSlot = slot.release;\n                // Set when the limiter pre-empts this attempt for the active speech; the\n                // catch below then re-queues the same attempt instead of counting it.\n                var yielded = false;\n                function attempt(attemptNum) {\n                    if (!stillValid()) {\n                        releaseSlot();\n                        return;\n                    }\n                    // A new attempt is progress as far as the stall watchdog is concerned\n                    // -- but only for the speech being played (see startStallWatchdog).\n                    if (isActiveSpeechAudio(audio)) {\n                        speechManager._stallLastProgressAt = performance.now();\n                    }\n                    if (loadTimerOpen(timerId)) {\n                        checkpoint(\"fetch_attempt_\".concat(attemptNum), {\n                            timerId: timerId,\n                            nextTimeoutMs: attemptTimeoutMs(attemptNum) + 500,\n                        });\n                    }\n                    var controller = new AbortController();\n                    var didTimeout = false;\n                    var timeoutId = setTimeout(function () {\n                        didTimeout = true;\n                        controller.abort();\n                    }, attemptTimeoutMs(attemptNum));\n                    slot.entry.yieldSlot = function () {\n                        yielded = true;\n                        controller.abort();\n                    };\n                    // Only set for a bad STATUS.  Recording resp.status up-front made a\n                    // body-stream failure after good headers ('TypeError: Failed to\n                    // fetch' out of arrayBuffer()) indistinguishable from a server\n                    // status, so it classified as status_200 — and isRetryable() rejects\n                    // any non-5xx/408 status, so a retryable network drop was abandoned\n                    // on attempt 1.  Left null, the catch reaches its TypeError branch\n                    // and retries as intended.\n                    var respStatus = null;\n                    var readingBody = false;\n                    fetch(audio.url, { signal: controller.signal })\n                        .then(function (resp) {\n                        if (!resp.ok) {\n                            respStatus = resp.status;\n                            throw new Error(\"Speech fetch failed: \".concat(resp.status, \" \").concat(resp.statusText));\n                        }\n                        readingBody = true;\n                        return resp.arrayBuffer();\n                    })\n                        .then(function (buf) {\n                        clearTimeout(timeoutId);\n                        slot.entry.yieldSlot = null;\n                        // Network work is done; decode below is CPU only.\n                        releaseSlot();\n                        if (!stillValid())\n                            return;\n                        if (loadTimerOpen(timerId)) {\n                            addData('retry_count', attemptNum - 1, timerId);\n                            addData('fetch_outcome', \"succeeded_on_attempt_\".concat(attemptNum), timerId);\n                            checkpoint('fetch_response', { timerId: timerId, nextTimeoutMs: 5000 });\n                        }\n                        decode(buf);\n                    })\n                        .catch(function (err) {\n                        clearTimeout(timeoutId);\n                        slot.entry.yieldSlot = null;\n                        if (!stillValid()) {\n                            releaseSlot();\n                            return;\n                        }\n                        if (yielded) {\n                            // Pre-empted, not failed: the slot has already passed to the\n                            // active speech. Resume this same attempt when a slot is free.\n                            yielded = false;\n                            slot.acquire(function () { return attempt(attemptNum); });\n                            return;\n                        }\n                        var kind;\n                        if (didTimeout)\n                            kind = 'timeout';\n                        else if (respStatus != null)\n                            kind = \"status_\".concat(respStatus);\n                        // Distinct from 'network' so telemetry can separate a connection\n                        // that never delivered headers from one that dropped mid-body.\n                        else if (readingBody && err instanceof TypeError)\n                            kind = 'body';\n                        else if (err instanceof TypeError)\n                            kind = 'network';\n                        else\n                            kind = (err === null || err === void 0 ? void 0 : err.name) || 'unknown';\n                        attemptHistory.push(kind);\n                        if (attemptNum < RETRY_MAX_ATTEMPTS && (didTimeout || isRetryable(err, respStatus))) {\n                            var delay = retryDelay(attemptNum);\n                            setTimeout(function () {\n                                if (!stillValid()) {\n                                    releaseSlot();\n                                    return;\n                                }\n                                attempt(attemptNum + 1);\n                            }, delay);\n                            return;\n                        }\n                        // Exhausted: no more network work for this load.\n                        releaseSlot();\n                        // 'failed' (rather than leaving 'loading') lets loadAudio and\n                        // playChunk re-fetch this chunk on the next play() of the speech.\n                        // Left as 'loading', a replay waited on an onLoad that could never\n                        // come and the stall watchdog reported a bogus mid-speech stall.\n                        audio.state = 'failed';\n                        failSharedLoad(sharedAudio, fileKey, own);\n                        var errorData;\n                        if (loadTimerOpen(timerId)) {\n                            addData('retry_count', attemptNum - 1, timerId);\n                            addData('fetch_outcome', 'exhausted', timerId);\n                            addData('fetch_attempts', attemptHistory, timerId);\n                            // Record a closing checkpoint to clear the pending fetch_attempt_N\n                            // timeout, then cancel the timer so totalTimeoutMs doesn't fire\n                            // either. Without this, the prior attempt's nextTimeoutMs would\n                            // surface a phantom slow-fetch event ~8.5s after we gave up.\n                            checkpoint('fetch_exhausted', { timerId: timerId });\n                            // Capture after the outcome is recorded so the report carries it,\n                            // but before cancelTimer discards the load timer entirely.\n                            errorData = speechFetchSnapshot(audio.url, attemptHistory, timerId);\n                            cancelLoadTimer(timerId);\n                        }\n                        else {\n                            errorData = speechFetchSnapshot(audio.url, attemptHistory, timerId);\n                        }\n                        // Only the speech being played may be ended by its own failure.\n                        // A preload, or a speech superseded while this load was in flight,\n                        // isn't \"the current speech\": calling playFinished would flush\n                        // pending actions on figure.speechId, ending or resuming whatever\n                        // plays now.  Just log and bail.\n                        if (isActiveSpeechAudio(audio)) {\n                            playFinished();\n                            notifyAudioFailed();\n                        }\n                        var allTimeouts = attemptHistory.every(function (k) { return k === 'timeout'; });\n                        var context = allTimeouts\n                            ? \"Speech fetch hung (\".concat(attemptHistory.length, \" attempts, timeouts \").concat(attemptTimeoutsUsed(attemptHistory.length), \") at \").concat(audio.url)\n                            : \"Speech fetch exhausted [\".concat(attemptHistory.join(', '), \"] at \").concat(audio.url);\n                        // `recovered`: the speech has already been ended above, so the\n                        // question carries on without this audio. Telemetry only - the\n                        // server must not skip the question over it.\n                        logError({\n                            msg: err.message || String(err),\n                            stack: err.stack,\n                            recovered: true,\n                        }, context, errorData);\n                    });\n                }\n                function decode(resp) {\n                    try {\n                        var msg = \"Array Buffer: length: \".concat(resp.byteLength, \", url: \").concat(audio.urlSimple);\n                        if (window._grokkoli_silent_log) {\n                            window._grokkoli_silent_log(msg);\n                        }\n                        else {\n                            console.log(msg);\n                        }\n                        // Record decode_start checkpoint (no timeout - decode_complete has one)\n                        if (loadTimerOpen(timerId)) {\n                            checkpoint('decode_start', { timerId: timerId });\n                        }\n                        // Use callback-based API wrapped in Promise for maximum browser compatibility\n                        // (older Safari doesn't support the Promise-based decodeAudioData)\n                        new Promise(function (resolve, reject) {\n                            ctx.decodeAudioData(resp, resolve, reject);\n                        })\n                            .then(function (buffer) {\n                            if (!stillValid())\n                                return;\n                            // Record decode_complete; the timer stops (and reports if\n                            // slow) once the marks are in too.\n                            if (loadTimerOpen(timerId)) {\n                                checkpoint('decode_complete', { timerId: timerId });\n                            }\n                            finishLoadTimerPart(timerId);\n                            var bufMsg = \"Buffer: duration: \".concat(buffer.duration, \", length: \").concat(buffer.length, \", numberOfChannels: \").concat(buffer.numberOfChannels, \", sampleRate: \").concat(buffer.sampleRate, \", url: \").concat(audio.urlSimple);\n                            if (window._grokkoli_silent_log) {\n                                window._grokkoli_silent_log(bufMsg);\n                            }\n                            else {\n                                console.log(bufMsg);\n                            }\n                            own.resolve(buffer);\n                            setLoaded(buffer);\n                        })\n                            .catch(function (err) {\n                            if (!stillValid())\n                                return;\n                            failSharedLoad(sharedAudio, fileKey, own);\n                            if (isActiveSpeechAudio(audio)) {\n                                playFinished();\n                                notifyAudioFailed();\n                            }\n                            logError({\n                                msg: err.message || String(err),\n                                stack: err.stack,\n                                recovered: true,\n                            }, \"Speech decode INNER at \".concat(audio.url));\n                        });\n                    }\n                    catch (err) {\n                        if (!stillValid())\n                            return;\n                        failSharedLoad(sharedAudio, fileKey, own);\n                        if (isActiveSpeechAudio(audio)) {\n                            playFinished();\n                            notifyAudioFailed();\n                        }\n                        var errorStr = \"\";\n                        if (err.error != null) {\n                            errorStr = JSON.stringify(err.error, Object.getOwnPropertyNames(err.error));\n                        }\n                        logError({\n                            msg: err.message,\n                            filename: err.filename,\n                            lineno: err.lineno,\n                            colno: err.colno,\n                            error: errorStr,\n                            srcElement: err.srcElement,\n                            target: err.target,\n                            timestamp: err.timeStamp,\n                            stack: err.stack,\n                            recovered: true,\n                        }, \"Speech decode at \".concat(audio.url));\n                    }\n                }\n                var startedNow = slot.acquire(function () { return attempt(1); });\n                if (!startedNow && loadTimerOpen(timerId)) {\n                    // Clears the 10s expectation speech_urls_response set on fetch_attempt_1.\n                    // The wait shows up as the fetch_queued -> fetch_attempt_1 delta. The\n                    // timer's own 30s total still bounds a queue that never drains.\n                    checkpoint('fetch_queued', { timerId: timerId, nextTimeoutMs: 25000 });\n                }\n            }\n            var lead = sharedLeadFor(sharedAudio, fileKey, audio, preload);\n            if (lead != null) {\n                // Another chunk is already loading this file: use its buffer.\n                if (loadTimerOpen(timerId)) {\n                    // Stands in for fetch_attempt_1, clearing the 10s expectation\n                    // speech_urls_response set: the wait is on the lead's fetch, and\n                    // shows up as the fetch_shared_wait -> decode_complete delta.\n                    checkpoint('fetch_shared_wait', { timerId: timerId, nextTimeoutMs: 25000 });\n                }\n                var waiting_1 = true;\n                var stopWaiting_1 = function () {\n                    var was = waiting_1;\n                    waiting_1 = false;\n                    audio._leaveSharedWait = undefined;\n                    return was && tokenValid();\n                };\n                audio._leaveSharedWait = function () {\n                    if (lead.done || isActiveSpeechAudio(lead.owner))\n                        return;\n                    if (stopWaiting_1())\n                        fetchOwn();\n                };\n                lead.promise.then(function (buffer) {\n                    if (!stopWaiting_1())\n                        return;\n                    if (loadTimerOpen(timerId)) {\n                        addData('fetch_outcome', 'shared', timerId);\n                        checkpoint('decode_complete', { timerId: timerId });\n                    }\n                    finishLoadTimerPart(timerId);\n                    setLoaded(buffer);\n                }, function () {\n                    // The lead failed, and is no longer shared: fetch for ourselves.\n                    if (stopWaiting_1())\n                        fetchOwn();\n                });\n                return;\n            }\n            fetchOwn();\n        }\n        function getCurrentTime() {\n            if (audio.state === 'playing') {\n                return (audio.startTime +\n                    audio.source.context.currentTime -\n                    audio.contextStartTime);\n            }\n            return audio.pauseTime;\n        }\n        function pause() {\n            if (audio.source) {\n                audio.pauseTime =\n                    audio.source.context.currentTime - audio.contextStartTime;\n                audio.source.stop();\n                audio.source.disconnect();\n                audio.source = null;\n            }\n            audio.state = 'ready';\n            // console.log(\"Audio Pause\", audio.urlSimple, audio.pauseTime)\n        }\n        function resume() {\n            playBuffer(audio.pauseTime);\n        }\n        // function seek(seekTime) {\n        //   pause();\n        //   audio.pauseTime = seekTime;\n        // }\n        audio.play = playBuffer;\n        audio.pause = pause;\n        audio.resume = resume;\n        audio.getCurrentTime = getCurrentTime;\n        audio.load = load;\n        // audio.seek = seek;\n        return audio;\n    }\n    // Get the number of seek points in all actions\n    function getNumSeeks() {\n        if (figure.speechId == null) {\n            return 0;\n        }\n        var chunkedSpeech = figure.chunkedSpeech[figure.speechId];\n        var seekCount = 0;\n        for (var i = 0; i < figure.chunkedSpeech[figure.speechId].length; i += 1) {\n            var speech = chunkedSpeech[i];\n            for (var j = 0; j < speech.initial_actions.length; j += 1) {\n                var action = speech.initial_actions[j];\n                if (action.seek != null) {\n                    seekCount += 1;\n                }\n            }\n            var numActions = Object.keys(speech.actions).length;\n            for (var j = 0; j < numActions; j += 1) {\n                var action = speech.actions[j.toString()];\n                if (action.seek) {\n                    seekCount += 1;\n                }\n            }\n        }\n        return seekCount + 1;\n    }\n    speechManager.numSeeks = getNumSeeks();\n    // Amount of time spent playing speech\n    function getPlayDuration() {\n        var duration = speechManager.playDuration;\n        if (speechManager.timeStart != null\n            && (figure.speechId === 'default' || figure.speechId === AUTO_SPEECH_ID)) {\n            duration += performance.now() - speechManager.timeStart;\n        }\n        return duration / 1000;\n    }\n    speechManager.getPlayDuration = getPlayDuration;\n    /*\n    ....###.....######..########.####..#######..##....##..######.\n    ...##.##...##....##....##.....##..##.....##.###...##.##....##\n    ..##...##..##..........##.....##..##.....##.####..##.##......\n    .##.....##.##..........##.....##..##.....##.##.##.##..######.\n    .#########.##..........##.....##..##.....##.##..####.......##\n    .##.....##.##....##....##.....##..##.....##.##...###.##....##\n    .##.....##..######.....##....####..#######..##....##..######.\n    */\n    // Cancel action setTimeout callback\n    function cancelActions() {\n        if (speechManager.actionTimeoutId) {\n            clearTimeout(speechManager.actionTimeoutId);\n            speechManager.actionTimeoutId = null;\n        }\n    }\n    // Cancel the pending caption swap. Captions carry no figure state, so unlike\n    // actions there is nothing to flush - a cancelled caption just stops\n    // updating, and the next chunk sets its own.\n    function cancelCaptions() {\n        if (speechManager.captionTimeoutId) {\n            clearTimeout(speechManager.captionTimeoutId);\n            speechManager.captionTimeoutId = null;\n        }\n    }\n    speechManager.cancelCaptions = cancelCaptions;\n    // Dispatch any remaining actions synchronously and clear the pending timer.\n    // Called when audio ends naturally: if a mark's setTimeout fires after the\n    // audio's 'ended' event, getCurrentTime() returns audio.pauseTime (= 0) and\n    // the mark-time comparison stays true forever, rescheduling on a loop that\n    // outlives the question.  Flushing rather than cancelling ensures a legit\n    // near-end mark action still fires (just synchronously at speech end),\n    // and lands the figure in the content-author-intended final state.\n    //\n    // currentChunkOnly restricts the flush to the chunk that just finished.  It\n    // is used when advancing between chunks (playNextChunk), where the speech is\n    // continuing and the later chunks will play their own actions in time.  The\n    // default (false) also dispatches future chunks' actions, which is only\n    // correct for the terminal paths that route through playFinished.\n    function flushPendingActions(currentChunkOnly) {\n        if (currentChunkOnly === void 0) { currentChunkOnly = false; }\n        if (speechManager.actionTimeoutId) {\n            clearTimeout(speechManager.actionTimeoutId);\n            speechManager.actionTimeoutId = null;\n        }\n        var chunks = figure.chunkedSpeech[figure.speechId];\n        if (!chunks)\n            return;\n        var tryRun = function (action) {\n            if (!action)\n                return;\n            try {\n                executeAction(action);\n            }\n            catch (_) { /* skip misbehaving action */ }\n        };\n        // Current chunk: fire initial_actions if playActions never ran (e.g.\n        // force-stall during chunk delay or before audio loaded), then flush\n        // remaining regular actions.  _initialActionsFired is set by\n        // playActions when the chunk's audio begins.\n        var speech = chunks[speechManager.chunkIndex];\n        if (speech) {\n            if (Array.isArray(speech.initial_actions) && !speech._initialActionsFired) {\n                for (var i = speechManager.initialActionIndex; i < speech.initial_actions.length; i += 1) {\n                    tryRun(speech.initial_actions[i]);\n                }\n                speech._initialActionsFired = true;\n            }\n            if (speech.actions) {\n                var numActions = Object.keys(speech.actions).length;\n                while (speechManager.actionIndex < numActions) {\n                    tryRun(speech.actions[speechManager.actionIndex.toString()]);\n                    speechManager.actionIndex += 1;\n                }\n            }\n        }\n        // Future chunks: dispatch every action (initial + regular).  Force\n        // termination paths — stall watchdog, decode failure, fetch exhaustion\n        // — all route through playFinished, so this guarantees end-of-speech\n        // state (final form, re-enable input, etc.) still applies even when\n        // the speech dies mid-way.  Normal completion of the last chunk has\n        // no future chunks, so the loop is a no-op there.\n        if (currentChunkOnly)\n            return;\n        for (var c = speechManager.chunkIndex + 1; c < chunks.length; c += 1) {\n            var futureSpeech = chunks[c];\n            if (!futureSpeech)\n                continue;\n            if (Array.isArray(futureSpeech.initial_actions) && !futureSpeech._initialActionsFired) {\n                for (var i = 0; i < futureSpeech.initial_actions.length; i += 1) {\n                    tryRun(futureSpeech.initial_actions[i]);\n                }\n                futureSpeech._initialActionsFired = true;\n            }\n            if (futureSpeech.actions) {\n                var numActions = Object.keys(futureSpeech.actions).length;\n                for (var i = 0; i < numActions; i += 1) {\n                    tryRun(futureSpeech.actions[i.toString()]);\n                }\n            }\n        }\n    }\n    // Execute the next action\n    // If the time isn't right yet to execute the next action, then setTimeout\n    // till 20ms before the correct time\n    function nextAction() {\n        var _a;\n        speechManager.actionTimeoutId = null;\n        var speech = figure.chunkedSpeech[figure.speechId][speechManager.chunkIndex];\n        var numActions = Object.keys(speech.actions).length;\n        var index = speechManager.actionIndex;\n        // If no more actions, then don't set another callback\n        if (index > numActions - 1) {\n            return;\n        }\n        var indexStr = index.toString();\n        var action = speech.actions[indexStr];\n        var mark = speech.marks.stamps[index];\n        (_a = window._grokkoli_silent_log) === null || _a === void 0 ? void 0 : _a.call(window, \"Question ID: \".concat(window.grokkoli_question_id), \"Load 1: \".concat(window.__load_1), \"Next Action: \".concat(index), \"action: \".concat(JSON.stringify(action)), \"mark: \".concat(JSON.stringify(mark)), \"figure.speechId: \".concat(figure.speechId), \"chunkIndex: \".concat(speechManager.chunkIndex), \"speech.marks: \".concat(JSON.stringify(speech.marks)));\n        // If no mark exists for this action, execute immediately (or use action.duration if set)\n        // //////////////////////////\n        // This is required for this:\n        // //////////////////////////\n        //    Root cause: Look at the SSML for chunks 3 and 4:\n        // <speak><prosody rate=\"90%\">, <mark name=\"0\"/></prosody></speak>\n        // This is essentially just a comma with a mark. The audio is only 0.072 seconds long:\n        // \"Buffer: duration: 0.072, length: 3456...\"\n        // AWS Polly can't generate meaningful mark timing when there's virtually no speech after the mark tag. So Polly returns empty marks even though the SSML contains a <mark> tag\n        // //////////////////////////\n        if (mark == null) {\n            if (action.duration != null) {\n                speechManager.actionTimeoutId = setTimeout(function () {\n                    speechManager.actionTimeoutId = null;\n                    executeAction(action);\n                    speechManager.actionIndex += 1;\n                    nextAction();\n                }, action.duration * 1000);\n                return;\n            }\n            // No mark and no duration - execute immediately and continue\n            executeAction(action);\n            speechManager.actionIndex += 1;\n            nextAction();\n            return;\n        }\n        var markTime = mark.time / 1000;\n        var timeBuffer = 0.02; // Actions can execute up to 20ms before the action\n        if (action.buffer != null) {\n            timeBuffer = action.buffer;\n        }\n        // There is no audio to time against.  Either a stale timer from a\n        // previous chunk fired after that chunk ended but before the next\n        // chunk's audio started (currentAudio is null while waiting on a chunk\n        // delay or on load), or the question was torn down and loadQuestion\n        // nulled the audio's closure-bearing methods.  Either way this timer no\n        // longer owns the current chunk's actions — drop it rather than throw.\n        // The advancing paths (playNextChunk / playFinished) flush any actions\n        // the outgoing chunk still owed.\n        var audio = speechManager.currentAudio;\n        if (audio == null || typeof audio.getCurrentTime !== 'function') {\n            return;\n        }\n        var currentTime = audio.getCurrentTime();\n        if (markTime > currentTime + timeBuffer) {\n            speechManager.actionTimeoutId = setTimeout(function () {\n                speechManager.actionTimeoutId = null;\n                nextAction();\n            }, (markTime - timeBuffer - currentTime) * 1000);\n            return;\n        }\n        executeAction(action);\n        speechManager.actionIndex += 1;\n        nextAction();\n    }\n    // Show the caption segment at speechManager.captionIndex when its mark time\n    // arrives, then schedule the next one. Mirrors nextAction, but a caption\n    // that is late is simply shown - there is no figure state to keep in sync,\n    // so the only cost of a late swap is the text changing a little after the\n    // words it belongs to.\n    function nextCaption() {\n        var _a, _b, _c, _d, _e;\n        speechManager.captionTimeoutId = null;\n        var speech = (_a = figure.chunkedSpeech[figure.speechId]) === null || _a === void 0 ? void 0 : _a[speechManager.chunkIndex];\n        if (!speech || !speech.caption_segments) {\n            return;\n        }\n        var audio = speechManager.currentAudio;\n        if (audio == null || typeof audio.getCurrentTime !== 'function') {\n            return;\n        }\n        var segments = speech.caption_segments;\n        var currentTime = audio.getCurrentTime();\n        // Segment 0 shows when the chunk starts; segment n waits on caption mark\n        // n - 1. Walk past every mark that has already gone by - after a seek that\n        // can be a run of them - so the DOM is written once, for the one that wins.\n        var index = speechManager.captionIndex;\n        var due = null;\n        while (index <= segments.length - 1) {\n            var stamp = (_c = (_b = speech.marks) === null || _b === void 0 ? void 0 : _b.captionStamps) === null || _c === void 0 ? void 0 : _c[index - 1];\n            if (stamp == null || stamp.time / 1000 > currentTime) {\n                break;\n            }\n            due = segments[index].caption;\n            index += 1;\n        }\n        if (due != null) {\n            speechManager.updateCaption(due);\n            speechManager.captionIndex = index;\n        }\n        if (index > segments.length - 1) {\n            return;\n        }\n        var next = (_e = (_d = speech.marks) === null || _d === void 0 ? void 0 : _d.captionStamps) === null || _e === void 0 ? void 0 : _e[index - 1];\n        if (next == null) {\n            return;\n        }\n        speechManager.captionTimeoutId = setTimeout(function () {\n            speechManager.captionTimeoutId = null;\n            nextCaption();\n        }, (next.time / 1000 - currentTime) * 1000);\n    }\n    // Reveal any caption segments whose marks never fired, so the last thing on\n    // screen is the end of the sentence rather than wherever the timing stopped.\n    // Late marks are routine rather than exceptional: getCurrentTime measures\n    // wall-clock elapsed and is not scaled by playbackRate while the audio\n    // source is, so above 1x the audio ends before a late mark's due time.\n    function flushCaptions() {\n        var _a;\n        cancelCaptions();\n        var speech = (_a = figure.chunkedSpeech[figure.speechId]) === null || _a === void 0 ? void 0 : _a[speechManager.chunkIndex];\n        var segments = speech === null || speech === void 0 ? void 0 : speech.caption_segments;\n        if (!speechManager.useCaptions\n            || !Array.isArray(segments)\n            || segments.length < 2) {\n            return;\n        }\n        if (speechManager.captionIndex <= segments.length - 1) {\n            speechManager.updateCaption(segments[segments.length - 1].caption);\n            speechManager.captionIndex = segments.length;\n        }\n    }\n    // Show a chunk's caption and, when it was split into timed segments, start\n    // swapping them. Falls back to the whole caption whenever the segments\n    // cannot be timed - Polly returns no stamp for a mark with virtually no\n    // speech after it (see nextAction), and a partial set of stamps would strand\n    // the caption on an early segment for the rest of the chunk.\n    function startCaptions(speech) {\n        var _a;\n        cancelCaptions();\n        if (!speechManager.useCaptions || !speech.caption) {\n            return;\n        }\n        speechManager.showCaptions();\n        var segments = speech.caption_segments;\n        var stamps = (_a = speech.marks) === null || _a === void 0 ? void 0 : _a.captionStamps;\n        if (!Array.isArray(segments)\n            || segments.length < 2\n            || !Array.isArray(stamps)\n            || stamps.length !== segments.length - 1) {\n            speechManager.updateCaption(speech.caption);\n            return;\n        }\n        speechManager.updateCaption(segments[0].caption);\n        speechManager.captionIndex = 1;\n        nextCaption();\n    }\n    speechManager.startCaptions = startCaptions;\n    // Play initial actions from speechManager.initialActionIndex\n    // and standard actions from speechManager.actionIndex\n    function playActions() {\n        cancelActions();\n        var speech = figure.chunkedSpeech[figure.speechId][speechManager.chunkIndex];\n        for (var i = speechManager.initialActionIndex; i < speech.initial_actions.length; i += 1) {\n            executeAction(speech.initial_actions[i]);\n        }\n        // Mark this chunk's initial_actions as run so flushPendingActions\n        // (called from playFinished on force-stall / decode error / fetch\n        // exhaustion) doesn't double-execute them.  Seek paths set\n        // initialActionIndex to a target and fire forward from there — that's\n        // by-design partial-firing, not a re-fire.\n        speech._initialActionsFired = true;\n        // speechManager.actionIndex = 0;\n        nextAction();\n    }\n    /*\n    ..######..########....###....########.########\n    .##....##....##......##.##......##....##......\n    .##..........##.....##...##.....##....##......\n    ..######.....##....##.....##....##....######..\n    .......##....##....#########....##....##......\n    .##....##....##....##.....##....##....##......\n    ..######.....##....##.....##....##....########\n    */\n    function playFinished() {\n        stopStallWatchdog();\n        // Before the interrupt branch's early return, so no exit from here leaves\n        // the caption timer running. After audio ends naturally getCurrentTime()\n        // returns pauseTime (= 0), so a pending nextCaption would reschedule\n        // itself forever - the same trap flushPendingActions() covers for actions.\n        cancelCaptions();\n        // If an interrupt speech just finished, resume the original play\n        if (speechManager.interruptedState != null) {\n            var saved = speechManager.interruptedState;\n            speechManager.interruptedState = null;\n            // Restore original speech state\n            figure.speechId = saved.speechId;\n            speechManager.chunkIndex = saved.chunkIndex;\n            speechManager.showContinueOnEnd = saved.showContinueOnEnd;\n            speechManager.chunkDelayDone = saved.chunkDelayDone;\n            speechManager.chunkDelayRemaining = saved.chunkDelayRemaining;\n            speechManager.playFinishedCallback1 = saved.playFinishedCallback1;\n            speechManager.playFinishedCallback2 = saved.playFinishedCallback2;\n            speechManager.playFinishedCallback3 = saved.playFinishedCallback3;\n            // Restore play/pause button functions before any icon changes\n            speechManager.toPlayButton = saved.toPlayButton;\n            speechManager.toPauseButton = saved.toPauseButton;\n            // Clean up interrupt speech visual elements\n            hideHighlightElements();\n            speechArrow.hide();\n            speechRect.hide();\n            // Restore figure state\n            if (saved.figureState) {\n                figure.setState(saved.figureState, { how: 'instant' });\n            }\n            speechManager.isPlaying = false;\n            if (saved.onInterruptEnd != null) {\n                saved.onInterruptEnd(true);\n            }\n            // Resolve resumeFrom to a target chunk/time/action\n            var chunks = figure.chunkedSpeech[saved.speechId];\n            var numChunks = chunks ? chunks.length : 0;\n            var targetChunk = saved.chunkIndex;\n            var targetTime = saved.currentTime;\n            var targetAction = saved.actionIndex;\n            var rf = saved.resumeFrom;\n            if (rf === 'startChunk') {\n                targetTime = 0;\n                targetAction = 0;\n            }\n            else if (rf === 'nextChunk') {\n                if (targetChunk < numChunks - 1) {\n                    targetChunk += 1;\n                }\n                targetTime = 0;\n                targetAction = 0;\n            }\n            else if (typeof rf === 'number') {\n                targetChunk = Math.max(0, Math.min(rf, numChunks - 1));\n                targetTime = 0;\n                targetAction = 0;\n            }\n            else if (rf != null && typeof rf === 'object' && 'delta' in rf) {\n                targetChunk = Math.max(0, Math.min(saved.chunkIndex + rf.delta, numChunks - 1));\n                targetTime = 0;\n                targetAction = 0;\n            }\n            // else 'here' — keep saved values\n            if (saved.wasPlaying) {\n                speechManager.chunkIndex = targetChunk;\n                speechManager.freeze = {\n                    state: saved.figureState,\n                    currentTime: targetTime,\n                    actionIndex: targetAction,\n                };\n                if (saved.autoResume) {\n                    speechManager.resume();\n                }\n                else {\n                    // Icon was showing pause during interrupt, switch back to play\n                    speechManager.toPlayButton();\n                }\n            }\n            else if (saved.freeze) {\n                // Was paused — apply resumeFrom and restore freeze\n                speechManager.chunkIndex = targetChunk;\n                speechManager.freeze = {\n                    state: saved.freeze.state,\n                    currentTime: targetTime,\n                    actionIndex: targetAction,\n                };\n                // Icon was never changed (suppressed), no action needed\n            }\n            // else: was never started — no freeze needed, play button calls play() fresh\n            // An interrupt that ends without auto-resuming leaves the speech frozen\n            // and the context idle, so it needs the same release as a natural end.\n            suspendWhileHidden();\n            return;\n        }\n        // Flush any remaining unfired actions.  After audio ends naturally,\n        // getCurrentTime() returns audio.pauseTime (= 0), so any pending\n        // nextAction setTimeout would reschedule itself forever without ever\n        // advancing.  flushPendingActions() dispatches unfired actions (so a\n        // legit near-end mark's action still fires) and clears the timer.\n        flushPendingActions();\n        flushCaptions();\n        speechManager.isPlaying = false;\n        speechRect.hide();\n        speechArrow.hide();\n        if (speechManager.useCaptions) {\n            speechManager.hideCaptionsTimeoutId = setTimeout(function () {\n                speechManager.hideCaptions();\n            }, 2000);\n        }\n        figure.speechManager.maxSeek = 1000;\n        figure.speechManager.updateSeekEnabled(figure.speechManager.maxSeek);\n        speechManager.seekPosition = 1000;\n        speechManager.updateSeekPosition(0);\n        figure.notifications.publish('speechComplete');\n        if (isMainSpeech()) {\n            speechManager.toPlayButton();\n        }\n        if (figure.speechId === 'default' || figure.speechId === AUTO_SPEECH_ID) {\n            speechManager.completeCount += 1;\n        }\n        if (speechManager.timeStart != null\n            && (figure.speechId === 'default' || figure.speechId === AUTO_SPEECH_ID)) {\n            speechManager.playDuration += performance.now() - speechManager.timeStart;\n        }\n        speechManager.timeStart = null;\n        // if (speechManager.useCaptions) {\n        //   speechManager.hideCaptions();\n        // }\n        if (speechManager.playFinishedCallback1 != null) {\n            speechManager.playFinishedCallback1();\n        }\n        if (speechManager.playFinishedCallback2 != null) {\n            speechManager.playFinishedCallback2();\n        }\n        if (speechManager.playFinishedCallback3 != null) {\n            speechManager.playFinishedCallback3();\n        }\n        // A speech that finishes while the tab is already hidden would otherwise\n        // leave the context running until the tab is shown again — the exact state\n        // suspendWhileHidden() exists to avoid.  Called last so a callback that\n        // starts new speech sets isPlaying first and this becomes a no-op.\n        suspendWhileHidden();\n    }\n    speechManager.playFinished = playFinished;\n    function stopFigure() {\n        if (figure.elements._expression) {\n            figure.elements._expression.stop('complete');\n        }\n        if (figure.elements._instruction) {\n            figure.elements._instruction.stop('complete');\n        }\n    }\n    speechManager.stopFigure = stopFigure;\n    function stop() {\n        cancelActions();\n        cancelCaptions();\n        if (speechManager.currentAudio) {\n            speechManager.currentAudio.pause();\n            // audioManager.pause();\n        }\n        if (speechManager.delayTimeoutId) {\n            clearTimeout(speechManager.delayTimeoutId);\n            speechManager.delayTimeoutId = null;\n        }\n        stopFigure();\n        speechManager.isPlaying = false;\n        if (isMainSpeech()) {\n            speechManager.toPlayButton();\n        }\n        // stop() is the other way playback ends — pause, a new play() superseding\n        // the current speech, or question teardown, any of which can happen while\n        // the tab is hidden (a transition timer firing in a background tab).\n        // Without this the context would stay running until the tab is shown.\n        suspendWhileHidden();\n    }\n    speechManager.stopPlaying = stop;\n    /*\n    ..######..##.....##.##.....##.##....##.##....##..######.\n    .##....##.##.....##.##.....##.###...##.##...##..##....##\n    .##.......##.....##.##.....##.####..##.##..##...##......\n    .##.......#########.##.....##.##.##.##.#####.....######.\n    .##.......##.....##.##.....##.##..####.##..##.........##\n    .##....##.##.....##.##.....##.##...###.##...##..##....##\n    ..######..##.....##..#######..##....##.##....##..######.\n    */\n    /**\n     * Checks if a speech chunk is ready to play.\n     *\n     * Both audio and marks must be ready.\n     *\n     * @property {number} index index of speech chunk\n     * @return {boolean} true if ready\n     */\n    function isChunkReady(index, speechId) {\n        var _a;\n        var sid = speechId !== null && speechId !== void 0 ? speechId : figure.speechId;\n        var speech = (_a = figure.chunkedSpeech[sid]) === null || _a === void 0 ? void 0 : _a[index];\n        if (speech == null || speech.audio == null) {\n            return false;\n        }\n        if (speech.audio.state === 'ready' && speech.marks.state === 'ready') {\n            return true;\n        }\n        return false;\n    }\n    function playNextChunk() {\n        // Any action timer still pending belongs to the outgoing chunk, and\n        // currentAudio is about to be nulled.  Cancel it so it can't fire against\n        // the next chunk's state.  Callers that finished a chunk by playing it\n        // through flush the outgoing chunk's owed actions first.\n        cancelActions();\n        cancelCaptions();\n        speechManager.chunkIndex += 1;\n        speechManager.currentAudio = null;\n        speechManager.chunkDelayDone = false;\n        speechManager.delayTimeoutId = null;\n        speechManager.playChunk();\n    }\n    function playChunk(playFrom) {\n        var _a;\n        if (playFrom === void 0) { playFrom = 'start'; }\n        if (isMainSpeech()) {\n            speechManager.toPauseButton();\n        }\n        var index = speechManager.chunkIndex;\n        var speech = (_a = figure.chunkedSpeech[figure.speechId]) === null || _a === void 0 ? void 0 : _a[index];\n        if (speech == null) {\n            // The chunk for the current index is gone. playNextChunk advances\n            // chunkIndex before calling here, and an audio.onEnd callback can fire\n            // after the speech was torn down or replaced (figure.speechId changed),\n            // leaving index past the end of the live chunk list. Bail rather than\n            // dereference `speech.delay` on undefined (which threw\n            // \"Cannot read properties of undefined (reading 'delay')\" in prod).\n            return;\n        }\n        if (playFrom === 'start' &&\n            speech.delay > 0 &&\n            !speechManager.chunkDelayDone) {\n            speechManager.chunkDelayStart = performance.now() / 1000;\n            speechManager.chunkDelayRemaining = speech.delay;\n            speechManager.isPlaying = true;\n            speechManager.actionIndex = 0;\n            speechManager.delayTimeoutId = setTimeout(function () {\n                speechManager.chunkDelayDone = true;\n                speechManager.chunkDelayRemaining = 0;\n                speechManager.delayTimeoutId = null;\n                playChunk(playFrom);\n            }, speech.delay * 1000);\n            return;\n        }\n        if (Array.isArray(playFrom) && speechManager.chunkDelayRemaining > 0) {\n            speechManager.chunkDelayStart = performance.now() / 1000;\n            speechManager.isPlaying = true;\n            speechManager.delayTimeoutId = setTimeout(function () {\n                speechManager.chunkDelayDone = true;\n                speechManager.delayTimeoutId = null;\n                speechManager.chunkDelayRemaining = 0;\n                playChunk(playFrom);\n            }, speechManager.chunkDelayRemaining * 1000);\n            return;\n        }\n        // if (\n        //   speechManager.isChunkURLReady(index)\n        //   || (isChunkReady(index) && speech.audio.paused)\n        // ) {\n        //   speech.callback = () => playChunk(playFrom);\n        //   queueURL(speech);\n        //   return;\n        // }\n        if ((playFrom === 'start' || playFrom === 'initialActions') &&\n            speech.initial_actions.length > 0 &&\n            speech.initial_actions[0]) {\n            speechManager.actionIndex = 0;\n            var action = speech.initial_actions[0];\n            if (action.if_shown) {\n                var elems = getElementsArray(action.if_shown);\n                var isShown = true;\n                for (var i = 0; i < elems.length; i += 1) {\n                    var elem = figure.get(elems[i]);\n                    // A missing element counts as not shown: an answer input can\n                    // legitimately omit a button (e.g. guess's `see_another` once out\n                    // of repeats), and throwing here broke the speech.\n                    if (elem == null || !elem.isShown) {\n                        isShown = false;\n                        break;\n                    }\n                }\n                if (isShown === false) {\n                    if (speechManager.chunkIndex <\n                        figure.chunkedSpeech[figure.speechId].length - 1) {\n                        playNextChunk();\n                    }\n                    else {\n                        playFinished();\n                    }\n                    return;\n                }\n            }\n        }\n        speechManager.isPlaying = true;\n        if (isChunkReady(index)) {\n            var currentTime = 0;\n            var actionIndex = 0;\n            var initialActionIndex = 0;\n            if (Array.isArray(playFrom)) {\n                currentTime = playFrom[0];\n                initialActionIndex = playFrom[1];\n                actionIndex = playFrom[2];\n            }\n            // if speechManager\n            // if (speechManager.currentAudio != null) {\n            //   speechManager.currentAudio.pause();\n            // }\n            speechManager.currentAudio = speech.audio;\n            speechManager.currentAudio.playbackRate = speechManager.playbackRate;\n            // speechManager.currentAudio.src = speech.audioURL;\n            speechManager.actionIndex = actionIndex;\n            speechManager.initialActionIndex = initialActionIndex;\n            // This must go before play actions as play actions requires the\n            // audio to be playing to get the correct current time\n            speech.audio.play(currentTime);\n            speechManager.playStartedTime = performance.now();\n            // Which speech's audio started (playSpeechAndWait): playStartedTime\n            // alone can be a speech that replaced the one waited on\n            figure.notifications.publish('speechAudioStarted', figure.speechId);\n            playActions();\n            // Also after play() - caption segments are timed against the audio's\n            // current time, so they need it running for the same reason actions do.\n            startCaptions(speech);\n            // speechManager.speakerIcon.style.display = 'block';\n            if (speechManager.speechLoadingIcon) {\n                speechManager.speechLoadingIcon.style.display = 'none';\n            }\n            speechManager.speechLoaded();\n        }\n        else {\n            // 'failed': an earlier play exhausted this chunk's download. Forget it\n            // *before* arming the resume callback (the reset clears onLoad), then\n            // re-fetch rather than wait on an onLoad that could never fire.\n            resetFailedChunk(speech);\n            speech.onLoad = function () { return playChunk(playFrom); };\n            if (speech.audio == null) {\n                loadAudio();\n            }\n            else {\n                // Loading already; make sure it isn't waiting behind preloads.\n                adoptSpeechLoads(figure.speechId);\n            }\n        }\n    }\n    speechManager.playChunk = playChunk;\n    /*\n    .##........#######.....###....########.\n    .##.......##.....##...##.##...##.....##\n    .##.......##.....##..##...##..##.....##\n    .##.......##.....##.##.....##.##.....##\n    .##.......##.....##.#########.##.....##\n    .##.......##.....##.##.....##.##.....##\n    .########..#######..##.....##.########.\n    */\n    /**\n     * Get speech marks for a specific chunk from a url, and save it to the chunk.\n     * Uses the captured speechId so that marks are always written to the correct\n     * speech's chunks, even if figure.speechId changes (e.g. during an interrupt).\n     *\n     * @property {string} marksURL\n     * @property {number} index index of speech chunk\n     * @property {string} speechId the speechId that owns this chunk\n     * @property {function | null} callback called when complete (default: null)\n     */\n    // Polly returns one time-ordered stamp per <mark> in the ssml, so caption\n    // marks (named c0, c1, ...) arrive interleaved with the action marks (named\n    // 0, 1, ...). Actions are looked up positionally - stamps[actionIndex] - so\n    // the two have to be separated on load or every action's timing shifts.\n    // Marks files generated before captions existed contain only action marks\n    // and partition to the same array they always did.\n    // The server asks for a marks file only when marks_count > 0, so a chunk\n    // whose caption was split but which has no animations still needs its\n    // caption marks counted here or its segments would never be timed. A split\n    // caption has one mark per segment after the first.\n    var totalMarksCount = function (chunk) {\n        var segments = chunk.caption_segments;\n        var captionMarks = Array.isArray(segments) && segments.length > 1\n            ? segments.length - 1\n            : 0;\n        return Object.keys(chunk.actions).length + captionMarks;\n    };\n    // These links are response-only hints, consumed once. On replay/retry or\n    // after expiry use speech_urls to obtain fresh links as before.\n    var cachedSpeechUrls = function (chunk) {\n        var _a;\n        var cached = chunk.cached_speech;\n        if (!cached || !Number.isFinite(cached._expiresAt)\n            || cached._expiresAt <= Date.now())\n            return null;\n        var urls = cached.urls;\n        if (!Array.isArray(urls) || typeof urls[0] !== 'string'\n            || (totalMarksCount(chunk) > 0 && typeof urls[1] !== 'string'))\n            return null;\n        return [urls[0], (_a = urls[1]) !== null && _a !== void 0 ? _a : null];\n    };\n    var isCaptionMark = function (mark) { var _a; return /^c\\d+$/.test(String((_a = mark === null || mark === void 0 ? void 0 : mark.value) !== null && _a !== void 0 ? _a : '')); };\n    var actionStamps = function (marks) { return marks.filter(function (m) { return !isCaptionMark(m); }); };\n    var captionStamps = function (marks) { return marks.filter(isCaptionMark); };\n    function getMarks(marksURL, index, speechId, callback, timerId, \n    // The chunk's audio object: the fetch limiter keys on it to promote the\n    // chunk's fetches when its speech is played and to decide pre-emption,\n    // and the stall watchdog is only reset by attempts for the speech actually\n    // playing. Its _isPreload flag makes this a preload entry in the limiter\n    // -- the preload path uses this same loader, so a preload's marks fetch is\n    // bounded by the per-attempt caps like any other and cannot hold a slot\n    // indefinitely.\n    audio) {\n        var attemptHistory = [];\n        var fileKey = speechFileKey(marksURL);\n        var preload = !!audio._isPreload;\n        var owner = audio;\n        // Set when this call fetches for itself (see fetchOwn below).\n        var own = null;\n        // This fetch's slot in the marks fetch lane, held across retries.\n        var slot = makeFetchSlot('marks', !!audio._isPreload, audio);\n        var releaseSlot = slot.release;\n        var yielded = false;\n        function parseMarks(response) {\n            var marks_raw = response.trim().split('\\n');\n            var marks = [];\n            for (var i = 0; i < marks_raw.length; i += 1) {\n                if (marks_raw[i] === '') {\n                    continue;\n                }\n                marks.push(JSON.parse(marks_raw[i]));\n            }\n            return marks;\n        }\n        function handleResponse(marks) {\n            // The guard lives here rather than around the handleResponse() call\n            // because check() below can defer setMarks to a later tick, where a\n            // throw would escape any caller-side try/catch to the global handler.\n            // Delivering marks is not a transport concern: a throw from here (or\n            // from callback()) must not reach the fetch .catch, where it would be\n            // attributed to respStatus, retried, or allowed to run\n            // handleExhaustion over the stamps just set.\n            var setMarks = function () {\n                var _a, _b;\n                try {\n                    if (isStaleGeneration())\n                        return;\n                    var chunk = (_a = figure.chunkedSpeech[speechId]) === null || _a === void 0 ? void 0 : _a[index];\n                    if (!(chunk === null || chunk === void 0 ? void 0 : chunk.marks))\n                        return;\n                    chunk.marks.stamps = actionStamps(marks);\n                    chunk.marks.captionStamps = captionStamps(marks);\n                    chunk.marks.state = 'ready';\n                    (_b = window._grokkoli_silent_log) === null || _b === void 0 ? void 0 : _b.call(window, \"Marks Loaded: \".concat(JSON.stringify(marks)), \"for chunk index: \".concat(index, \", url: \").concat(marksURL));\n                    if (callback) {\n                        callback();\n                    }\n                }\n                catch (err) {\n                    logError({\n                        msg: err.message || String(err),\n                        stack: err.stack,\n                    }, \"Speech marks handling failed at \".concat(marksURL));\n                }\n            };\n            var count = 0;\n            var check = function () {\n                if (isStaleGeneration())\n                    return;\n                if (!figure.chunkedSpeech[speechId]) {\n                    return; // teardown cleared chunkedSpeech, stop polling\n                }\n                if (figure.chunkedSpeech[speechId][index]) {\n                    setMarks();\n                }\n                else {\n                    count += 1;\n                    if (count < 100) {\n                        setTimeout(check, 50);\n                    }\n                }\n            };\n            check();\n        }\n        function handleExhaustion(err) {\n            var _a;\n            var chunk = (_a = figure.chunkedSpeech[speechId]) === null || _a === void 0 ? void 0 : _a[index];\n            if (own != null)\n                failSharedLoad(sharedMarks, fileKey, own);\n            if (loadTimerOpen(timerId)) {\n                addData('marks_retry_count', attemptHistory.length - 1, timerId);\n                addData('marks_fetch_outcome', 'exhausted', timerId);\n                addData('marks_fetch_attempts', attemptHistory, timerId);\n            }\n            // Marks are needed when the chunk has actions: they time the\n            // animations the speech talks the learner through, so speech without\n            // them says \"this one\" while nothing moves. Then the chunk fails exactly\n            // like an exhausted audio download - see below.\n            var marksNeeded = chunk != null && Object.keys(chunk.actions || {}).length > 0;\n            if (!marksNeeded) {\n                // Caption timing only: play on silently, captions falling back to the\n                // whole caption. Nothing the learner needs is missing, so no error\n                // report - but the load timer is closed normally, so a chunk that\n                // waited this long on its marks still shows in slow-load timing.\n                if (chunk === null || chunk === void 0 ? void 0 : chunk.marks) {\n                    chunk.marks.stamps = [];\n                    chunk.marks.captionStamps = [];\n                    chunk.marks.state = 'ready';\n                }\n                finishLoadTimerPart(timerId);\n                if (callback) {\n                    callback();\n                }\n                return;\n            }\n            // 'failed' keeps the chunk from playing (isChunkReady needs 'ready') and,\n            // like audio.state 'failed', makes playback that reaches it fetch the\n            // chunk afresh (resetFailedChunk).\n            if (chunk === null || chunk === void 0 ? void 0 : chunk.marks) {\n                chunk.marks.state = 'failed';\n            }\n            // End the speech only if playback is waiting on this very chunk. A\n            // later chunk of the playing speech (fetched ahead) must not cut off\n            // the chunk that is playing fine: it gets another fetch when playback\n            // reaches it, and ends the speech then if that fails too.\n            if (figure.speechId === speechId && speechManager.chunkIndex === index) {\n                playFinished();\n                notifyAudioFailed();\n            }\n            var allTimeouts = attemptHistory.length > 0\n                && attemptHistory.every(function (k) { return k === 'timeout'; });\n            var context = allTimeouts\n                ? \"Speech marks fetch hung (\".concat(attemptHistory.length, \" attempts, timeouts \").concat(attemptTimeoutsUsed(attemptHistory.length), \") at \").concat(marksURL)\n                : \"Speech marks fetch exhausted [\".concat(attemptHistory.join(', '), \"] at \").concat(marksURL);\n            // `recovered`: the question carries on (the speech is ended above only\n            // if it was waiting on this chunk), as for failed audio.\n            logError({\n                msg: err.message || String(err),\n                stack: err.stack,\n                recovered: true,\n            }, context, speechFetchSnapshot(marksURL, attemptHistory, timerId));\n            // Cancelled (not stopped) like an exhausted MP3: the error report above\n            // covers this failure, so no slow-load timing report as well. Only now,\n            // because the snapshot above has to carry what the timer recorded.\n            cancelLoadTimer(timerId);\n        }\n        function attempt(attemptNum) {\n            if (isStaleGeneration()) {\n                releaseSlot();\n                return;\n            }\n            // A new attempt is progress for the stall watchdog -- for the speech\n            // being played only (see startStallWatchdog).\n            if (isActiveSpeechAudio(audio)) {\n                speechManager._stallLastProgressAt = performance.now();\n            }\n            var controller = new AbortController();\n            var didTimeout = false;\n            var timeoutId = setTimeout(function () {\n                didTimeout = true;\n                controller.abort();\n            }, attemptTimeoutMs(attemptNum));\n            slot.entry.yieldSlot = function () {\n                yielded = true;\n                controller.abort();\n            };\n            // Set only for a bad status — see the audio fetch above; a body-stream\n            // failure here classified as status_200 and skipped its retries too.\n            var respStatus = null;\n            var httpStatus = null;\n            var parseFailed = false;\n            var readingBody = false;\n            // eslint-disable-next-line\n            fetch(marksURL, { method: 'GET', signal: controller.signal })\n                .then(function (response) {\n                httpStatus = response.status;\n                if (!response.ok) {\n                    respStatus = response.status;\n                    throw new Error(\"Marks fetch failed: \".concat(response.status, \" \").concat(response.statusText));\n                }\n                readingBody = true;\n                return response.text();\n            })\n                .then(function (response) {\n                clearTimeout(timeoutId);\n                slot.entry.yieldSlot = null;\n                if (isStaleGeneration()) {\n                    releaseSlot();\n                    return;\n                }\n                // Parse before recording success. A 200 whose body isn't marks -\n                // a service worker offline page, a captive portal login page - is a\n                // failed fetch wearing a success status, so it has to reach the\n                // retry path below rather than be counted as succeeded_on_attempt_N.\n                // The slot is held until the parse settles for the same reason: a\n                // parse failure retries, and that retry must run inside the limiter\n                // -- a portal page answers every pending marks URL at once, which is\n                // exactly the burst the limiter exists to prevent.\n                var marks;\n                try {\n                    marks = parseMarks(response);\n                }\n                catch (err) {\n                    parseFailed = true;\n                    throw err;\n                }\n                if (loadTimerOpen(timerId)) {\n                    addData('marks_retry_count', attemptNum - 1, timerId);\n                    addData('marks_fetch_outcome', \"succeeded_on_attempt_\".concat(attemptNum), timerId);\n                }\n                finishLoadTimerPart(timerId);\n                own === null || own === void 0 ? void 0 : own.resolve(marks);\n                // Cannot throw into this chain: setMarks carries its own guard, so\n                // handler failures stay out of the fetch failure path below.\n                handleResponse(marks);\n                // Released last, so nothing above can throw into .catch and retry\n                // while the slot is already someone else's.\n                releaseSlot();\n            })\n                .catch(function (err) {\n                clearTimeout(timeoutId);\n                slot.entry.yieldSlot = null;\n                if (isStaleGeneration()) {\n                    releaseSlot();\n                    return;\n                }\n                if (yielded) {\n                    // Pre-empted for the active speech, not failed: resume this same\n                    // attempt when a slot is free.\n                    yielded = false;\n                    slot.acquire(function () { return attempt(attemptNum); });\n                    return;\n                }\n                var kind;\n                if (didTimeout)\n                    kind = 'timeout';\n                else if (parseFailed)\n                    kind = \"parse_error_\".concat(httpStatus);\n                else if (respStatus != null)\n                    kind = \"status_\".concat(respStatus);\n                else if (readingBody && err instanceof TypeError)\n                    kind = 'body';\n                else if (err instanceof TypeError)\n                    kind = 'network';\n                else\n                    kind = (err === null || err === void 0 ? void 0 : err.name) || 'unknown';\n                attemptHistory.push(kind);\n                if (attemptNum < RETRY_MAX_ATTEMPTS\n                    && (didTimeout || parseFailed || isRetryable(err, respStatus))) {\n                    var delay = retryDelay(attemptNum);\n                    setTimeout(function () {\n                        if (isStaleGeneration()) {\n                            releaseSlot();\n                            return;\n                        }\n                        attempt(attemptNum + 1);\n                    }, delay);\n                    return;\n                }\n                // Exhausted: no more network work for this fetch.\n                releaseSlot();\n                handleExhaustion(err);\n            });\n        }\n        function fetchOwn() {\n            // The slot was made when getMarks was called; if this chunk has waited\n            // on a shared load since, its speech may have started playing\n            // (adoptSpeechLoads cleared _isPreload), so its queue priority must\n            // follow. Same for the lead it now becomes.\n            var nowPreload = !!audio._isPreload;\n            slot.entry.preload = nowPreload;\n            own = leadSharedLoad(sharedMarks, fileKey, owner, nowPreload);\n            slot.acquire(function () { return attempt(1); });\n        }\n        var lead = sharedLeadFor(sharedMarks, fileKey, owner, preload);\n        if (lead != null) {\n            // Another chunk is already fetching this marks file: use its marks.\n            var waiting_2 = true;\n            var stopWaiting_2 = function () {\n                var was = waiting_2;\n                waiting_2 = false;\n                audio._leaveSharedMarksWait = undefined;\n                return was && !isStaleGeneration();\n            };\n            audio._leaveSharedMarksWait = function () {\n                if (lead.done || isActiveSpeechAudio(lead.owner))\n                    return;\n                if (stopWaiting_2())\n                    fetchOwn();\n            };\n            lead.promise.then(function (marks) {\n                if (!stopWaiting_2())\n                    return;\n                if (loadTimerOpen(timerId)) {\n                    addData('marks_fetch_outcome', 'shared', timerId);\n                }\n                finishLoadTimerPart(timerId);\n                handleResponse(marks);\n            }, function () {\n                // The lead failed, and is no longer shared: fetch for ourselves.\n                if (stopWaiting_2())\n                    fetchOwn();\n            });\n            return;\n        }\n        fetchOwn();\n    }\n    speechManager.speechLoaded = function () {\n        if (speechManager.speechLoadedCallback != null) {\n            speechManager.speechLoadedCallback();\n        }\n    };\n    /**\n     * How many chunks each speech_urls/ POST asks for, as a speech is worked through.\n     *\n     * Chunk 0 goes on its own. That request is on the critical path for every\n     * question -- nothing can be heard until it returns -- and the server resolves a\n     * batch chunk by chunk, so bundling four more chunks in with it would delay the\n     * first audio by the time taken to resolve all of them. Once chunk 0 is away\n     * nothing is waiting: chunk 1 is not needed until chunk 0 has finished playing,\n     * which is seconds off, so later requests can be larger and trade a little\n     * latency for far fewer of them.\n     *\n     * This is worth doing because speech_urls/ is the busiest endpoint on the site --\n     * 73,922 requests on 2026-09-21 against `answer`'s 19,999 -- precisely because it\n     * used to be one POST per chunk. A ten-chunk speech was ten POSTs and is now four\n     * (1 + 2 + 5 + 2).\n     *\n     * The old comment here said parallel POSTs slow the server down, and that is why\n     * the requests are still issued one after another rather than all at once. Batching\n     * is the opposite trade: fewer requests, each carrying more, so the server does the\n     * same synthesis work behind one lot of middleware instead of five.\n     */\n    var SPEECH_BATCH_RAMP = [1, 2];\n    var SPEECH_BATCH_STEADY = 5;\n    /**\n     * `precedingChunks` is the index of the first chunk still to be requested, not a\n     * count of loaded chunks. The two differ when a chunk was loaded out of order --\n     * a preload having fetched chunk 2, say -- and the count would then read as\n     * \"one is already away\" and bundle chunk 0 in with chunk 1, delaying the first\n     * audio on the strength of a chunk nobody is waiting for. The index asks the\n     * question that actually matters: how much speech plays before this batch is\n     * needed.\n     */\n    function speechBatchSize(precedingChunks) {\n        var seen = 0;\n        for (var i = 0; i < SPEECH_BATCH_RAMP.length; i += 1) {\n            seen += SPEECH_BATCH_RAMP[i];\n            if (precedingChunks < seen)\n                return SPEECH_BATCH_RAMP[i];\n        }\n        return SPEECH_BATCH_STEADY;\n    }\n    /**\n     * The 'ended' handoff for a chunk's audio: advance to the next chunk or\n     * finish the speech.  Every audio object that can be played through\n     * playChunk must carry this -- the ended event is the ONLY thing that\n     * ends a speech naturally, and without it the speech stays isPlaying\n     * until the stall watchdog force-finishes it ~6s later.  Shared by\n     * loadAudio and processPreloadQueue for exactly that reason: the preload\n     * path used to build audio without it, so every preloaded word/count\n     * speech (say_word_*, one..five) \"stalled\" after playing correctly.\n     */\n    function makeChunkOnEnd(speechId) {\n        return function () {\n            var _a, _b;\n            if (speechManager.chunkIndex <\n                ((_b = (_a = figure.chunkedSpeech[speechId]) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) - 1) {\n                // A mark's timer can still be pending here if it fired late\n                // (or was scheduled past the end of the audio).  Dispatch the\n                // actions this chunk still owes before advancing — the same\n                // reasoning as playFinished, scoped to this chunk since the\n                // speech continues.\n                flushPendingActions(true);\n                playNextChunk();\n            }\n            else {\n                playFinished();\n            }\n        };\n    }\n    /**\n     * Goes through each speech chunk and loads audio/marks if not already\n     * loaded.  Captures figure.speechId at entry so that async callbacks\n     * always target the correct speech, even if figure.speechId changes\n     * during an interrupt.\n     *\n     * Importantly, each POST is still sent only after the previous one comes back --\n     * sending them all at once considerably slows down the response from the server.\n     * What changed is how much each POST carries: see speechBatchSize above.\n     *\n     * @property {function | null} callback called when the first chunk is loaded and\n     * ready (default: null)\n     */\n    function loadAudio(forSpeechId) {\n        if (isStaleGeneration())\n            return;\n        var speechId = forSpeechId !== null && forSpeechId !== void 0 ? forSpeechId : figure.speechId;\n        var chunkedSpeech = figure.chunkedSpeech[speechId];\n        if (!chunkedSpeech)\n            return; // teardown cleared chunkedSpeech\n        // The chunks not yet loaded or in flight, in order. Empty makes a re-entrant\n        // call a no-op once the whole speech is under way.\n        var pending = [];\n        for (var i = 0; i < chunkedSpeech.length; i += 1) {\n            var speech = chunkedSpeech[i];\n            // If audio load has already been attempted, then don't do it again.\n            // That includes a chunk whose attempt exhausted its retries ('failed'):\n            // this runs from every speech_urls response callback, so a late batch\n            // must not restart a chunk that already failed. A playback request\n            // clears 'failed' first (resetFailedChunk), and then this picks it up.\n            if (speech.audio == null && !speech._audioLoading) {\n                pending.push(i);\n            }\n        }\n        if (pending.length === 0)\n            return;\n        // Preserve the first pending chunk's priority. Starting later cached\n        // chunks first could occupy both MP3 slots while its URL request is pending.\n        var useCached = cachedSpeechUrls(chunkedSpeech[pending[0]]) != null;\n        var batch = pending\n            .filter(function (index) { return (cachedSpeechUrls(chunkedSpeech[index]) != null) === useCached; })\n            .slice(0, speechBatchSize(pending[0]))\n            .map(function (index) {\n            var speech = chunkedSpeech[index];\n            var marks_count = totalMarksCount(speech);\n            speech._audioLoading = true;\n            speech.callback = null;\n            speech.marks = {\n                stamps: [],\n                captionStamps: [],\n                state: marks_count > 0 ? 'waiting' : 'ready',\n                url: null,\n            };\n            // Create timer ID and start timing. Every chunk keeps its own timer even\n            // when it shares a request, so the timing records stay per chunk.\n            var ssmlHash = hashSSML(speech.ssml);\n            var timerId = speechTimerId(ssmlHash);\n            startTimer(timerId, { totalTimeoutMs: 30000, timerName: 'speech' });\n            addData('ssmlHash', ssmlHash, timerId);\n            // Record speech_urls_start checkpoint (timeout for speech_urls_response)\n            if (!useCached)\n                checkpoint('speech_urls_start', { timerId: timerId, nextTimeoutMs: 10000 });\n            return { speech: speech, index: index, marks_count: marks_count, ssmlHash: ssmlHash, timerId: timerId };\n        });\n        var receiveUrls = function (response) {\n            var _a, _b;\n            // Stale response from a previous question — discard.\n            if (isStaleGeneration())\n                return;\n            var _loop_4 = function (b) {\n                // Per chunk, so that one malformed entry cannot abandon the chunks after\n                // it in the same response — nor skip the recursion that requests the\n                // next batch, which would strand the rest of the speech unloaded.\n                var _c = batch[b], speech = _c.speech, index = _c.index, timerId = _c.timerId;\n                try {\n                    var urlPair = response.urls != null ? response.urls[b] : null;\n                    if (urlPair == null) {\n                        throw new Error(\"speech_urls returned \".concat((_b = (_a = response.urls) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0, \" urls for \")\n                            + \"\".concat(batch.length, \" chunks\"));\n                    }\n                    var audioURL = urlPair[0];\n                    var marksURL = urlPair[1];\n                    // Add audioHash to data for later identification\n                    var audioHash = extractHashFromUrl(audioURL);\n                    if (audioHash) {\n                        addData('audioHash', audioHash, timerId);\n                        // Record speech_urls_response checkpoint (timeout for fetch_start)\n                        checkpoint(useCached ? 'inline_urls_ready' : 'speech_urls_response', {\n                            timerId: timerId,\n                            nextTimeoutMs: 10000,\n                        });\n                        // Store chars from the response. chunk_chars is the per-chunk split;\n                        // response.chars is the whole request's total, so it is only this\n                        // chunk's figure when the request held one chunk. A server that\n                        // predates batching sends no chunk_chars at all.\n                        var chars = response.chunk_chars != null\n                            ? response.chunk_chars[b]\n                            : (batch.length === 1 ? response.chars : null);\n                        if (chars != null) {\n                            addData('chars', chars, timerId);\n                        }\n                    }\n                    else {\n                        // No audio hash found, just cancel the tracking\n                        cancelTimer(timerId);\n                    }\n                    delete speech.cached_speech;\n                    speech.marks.url = marksURL;\n                    // The timer stops once the MP3 and the marks file (if any) are in.\n                    // (Not if it was just cancelled for want of an audio hash.)\n                    if (hasTimer(timerId))\n                        openLoadTimer(timerId, marksURL != null ? 2 : 1);\n                    speech.audio = makeAudio(audioURL, timerId);\n                    speech.audio.onEnd = makeChunkOnEnd(speechId);\n                    speech.audio.onLoad = function () {\n                        // Only trigger the onLoad playback callback if this speech\n                        // is still the active one.  During an interrupt, the audio\n                        // finishes loading but playChunk() reads figure.speechId\n                        // live — calling it now would interfere with the interrupt\n                        // speech.  The loaded audio stays ready for when the\n                        // original speech resumes.\n                        if (speech.onLoad\n                            && isChunkReady(index, speechId)\n                            && figure.speechId === speechId) {\n                            var onLoad = speech.onLoad;\n                            speech.onLoad = null;\n                            onLoad();\n                        }\n                    };\n                    speech.audio.load();\n                    if (marksURL != null) {\n                        getMarks(marksURL, index, speechId, function () {\n                            if (speech.onLoad\n                                && isChunkReady(index, speechId)\n                                && figure.speechId === speechId) {\n                                var onLoad = speech.onLoad;\n                                speech.onLoad = null;\n                                onLoad();\n                            }\n                        }, timerId, speech.audio);\n                    }\n                }\n                catch (err) {\n                    var errorStr = \"\";\n                    if (err.error != null) {\n                        errorStr = JSON.stringify(err.error, Object.getOwnPropertyNames(err.error));\n                    }\n                    logError({\n                        msg: err.message,\n                        filename: err.filename,\n                        lineno: err.lineno,\n                        colno: err.colno,\n                        error: errorStr,\n                        srcElement: err.srcElement,\n                        target: err.target,\n                        timestamp: err.timeStamp,\n                        stack: err.stack,\n                    }, 'response');\n                    // throw err;\n                }\n            };\n            for (var b = 0; b < batch.length; b += 1) {\n                _loop_4(b);\n            }\n            // Run load audio again to load any remaining unloaded audio/marks\n            // components. Only now the previous POST is back: the requests stay\n            // one-at-a-time, it is the size of each that has changed.\n            loadAudio(speechId);\n        };\n        if (useCached) {\n            batch.forEach(function (_a) {\n                var timerId = _a.timerId;\n                return addData('urlSource', 'inline', timerId);\n            });\n            receiveUrls({\n                urls: batch.map(function (_a) {\n                    var speech = _a.speech;\n                    return cachedSpeechUrls(speech);\n                }),\n            });\n        }\n        else {\n            // eslint-disable-next-line\n            request('POST', 'speech_urls/', withSpeechToken({\n                // A list now that a request can carry several chunks; the server joins it\n                // for its log line and tolerates the old bare string.\n                ssml_hash: batch.map(function (entry) { return entry.ssmlHash; }),\n                speech_chunks: batch.map(function (entry) { return ({\n                    ssml: entry.speech.ssml,\n                    marks_count: entry.marks_count,\n                }); }),\n            }), receiveUrls);\n        }\n    }\n    /*\n    .########.....###....##.....##..######..########\n    .##.....##...##.##...##.....##.##....##.##......\n    .##.....##..##...##..##.....##.##.......##......\n    .########..##.....##.##.....##..######..######..\n    .##........#########.##.....##.......##.##......\n    .##........##.....##.##.....##.##....##.##......\n    .##........##.....##..#######...######..########\n    */\n    speechManager.pause = function () {\n        // eslint-disable-next-line\n        // console.log('pause')\n        var currentAudio = speechManager.currentAudio;\n        var currentTime = currentAudio == null ? 0 : currentAudio.getCurrentTime();\n        speechManager.isPlaying = false;\n        speechManager.freeze = {\n            state: figure.getState(),\n            currentTime: currentTime,\n            actionIndex: speechManager.actionIndex,\n        };\n        figure.stop('freeze');\n        if (currentAudio) {\n            speechManager.currentAudio.pause();\n        }\n        cancelActions();\n        // Otherwise the pending swap fires while paused and runs the caption ahead\n        // of the audio. Resuming replays the chunk, which restarts the segments.\n        cancelCaptions();\n        if (speechManager.delayTimeoutId) {\n            // const speech = figure.chunkedSpeech[figure.speechId][speechManager.chunkIndex];\n            speechManager.chunkDelayRemaining =\n                speechManager.chunkDelayRemaining -\n                    (performance.now() / 1000 - speechManager.chunkDelayStart);\n            clearTimeout(speechManager.delayTimeoutId);\n            speechManager.delayTimeoutId = null;\n        }\n        if (isMainSpeech()) {\n            speechManager.toPlayButton();\n        }\n    };\n    /*\n    .########..########..######..##.....##.##.....##.########\n    .##.....##.##.......##....##.##.....##.###...###.##......\n    .##.....##.##.......##.......##.....##.####.####.##......\n    .########..######....######..##.....##.##.###.##.######..\n    .##...##...##.............##.##.....##.##.....##.##......\n    .##....##..##.......##....##.##.....##.##.....##.##......\n    .##.....##.########..######...#######..##.....##.########\n    */\n    speechManager.resume = function () {\n        // eslint-disable-next-line\n        // console.log('resume')\n        var freeze = speechManager.freeze;\n        if (freeze != null) {\n            ensureAudioContext().then(function () {\n                if (isStaleGeneration())\n                    return;\n                playChunk([freeze.currentTime, 0, freeze.actionIndex]);\n                figure.setState(freeze.state, { how: 'instant' });\n                speechManager.freeze = null;\n            }).catch(function () { });\n            // speechManager.isPlaying = true;\n        }\n        else {\n            speechManager.play();\n        }\n    };\n    /*\n    .####.##....##.########.########.########..########..##.....##.########..########\n    ..##..###...##....##....##.......##.....##.##.....##.##.....##.##.....##....##...\n    ..##..####..##....##....##.......##.....##.##.....##.##.....##.##.....##....##...\n    ..##..##.##.##....##....######...########..########..##.....##.########.....##...\n    ..##..##..####....##....##.......##...##...##...##...##.....##.##...........##...\n    ..##..##...###....##....##.......##....##..##....##..##.....##.##...........##...\n    .####.##....##....##....########.##.....##.##.....##..#######..##...........##...\n    */\n    speechManager.interruptPlay = function (speechId, autoResume, resumeFrom, onInterruptStart, onInterruptEnd) {\n        if (autoResume === void 0) { autoResume = false; }\n        if (resumeFrom === void 0) { resumeFrom = 'here'; }\n        if (onInterruptStart === void 0) { onInterruptStart = null; }\n        if (onInterruptEnd === void 0) { onInterruptEnd = null; }\n        var wasPlaying = speechManager.isPlaying;\n        if (speechManager.interruptedState == null) {\n            // First interrupt — save original play state\n            var currentAudio = speechManager.currentAudio;\n            var currentTime = 0;\n            var actionIndex = speechManager.actionIndex;\n            var figureState = null;\n            if (wasPlaying && currentAudio) {\n                // Currently playing — capture live state\n                currentTime = currentAudio.getCurrentTime();\n                figureState = figure.getState();\n                figure.stop('freeze');\n                currentAudio.pause();\n            }\n            else if (speechManager.freeze) {\n                // Already paused — use freeze for audio position, but capture\n                // current figure state (user may have changed things since pausing)\n                currentTime = speechManager.freeze.currentTime;\n                actionIndex = speechManager.freeze.actionIndex;\n                figureState = figure.getState();\n            }\n            speechManager.interruptedState = {\n                speechId: figure.speechId,\n                chunkIndex: speechManager.chunkIndex,\n                actionIndex: actionIndex,\n                currentTime: currentTime,\n                figureState: figureState,\n                chunkDelayDone: speechManager.chunkDelayDone,\n                chunkDelayRemaining: speechManager.chunkDelayRemaining,\n                showContinueOnEnd: speechManager.showContinueOnEnd,\n                wasPlaying: wasPlaying,\n                freeze: speechManager.freeze,\n                playFinishedCallback1: speechManager.playFinishedCallback1 || null,\n                playFinishedCallback2: speechManager.playFinishedCallback2 || null,\n                playFinishedCallback3: speechManager.playFinishedCallback3 || null,\n                toPlayButton: speechManager.toPlayButton,\n                toPauseButton: speechManager.toPauseButton,\n                autoResume: autoResume,\n                resumeFrom: resumeFrom,\n                onInterruptEnd: onInterruptEnd,\n            };\n            // If original was paused, suppress play/pause icon changes during interrupt\n            if (!wasPlaying) {\n                speechManager.toPlayButton = function () { };\n                speechManager.toPauseButton = function () { };\n            }\n        }\n        else {\n            // Already interrupted — keep existing interruptedState (points to original play)\n            // Fire the previous interrupt's onInterruptEnd with false (it didn't complete)\n            if (speechManager.interruptedState.onInterruptEnd != null) {\n                speechManager.interruptedState.onInterruptEnd(false);\n            }\n            // Update onInterruptEnd to the new interrupt's callback\n            speechManager.interruptedState.onInterruptEnd = onInterruptEnd;\n            // Just stop the current interrupt speech\n            if (speechManager.currentAudio && speechManager.currentAudio.state === 'playing') {\n                speechManager.currentAudio.pause();\n            }\n        }\n        // Cancel actions and delays\n        cancelActions();\n        cancelCaptions();\n        if (speechManager.delayTimeoutId) {\n            clearTimeout(speechManager.delayTimeoutId);\n            speechManager.delayTimeoutId = null;\n        }\n        // Clear state for the interrupt speech\n        speechManager.playFinishedCallback1 = null;\n        speechManager.playFinishedCallback2 = null;\n        speechManager.playFinishedCallback3 = null;\n        speechManager.freeze = null;\n        speechManager.showContinueOnEnd = false;\n        speechManager.isPlaying = false;\n        speechManager.currentAudio = null;\n        speechManager.seekPosition = 0;\n        // Play the interrupt speech — set speechId directly and call play()\n        // without arguments to avoid play()'s guard that clears interruptedState\n        figure.speechId = speechId;\n        speechManager.play();\n        if (onInterruptStart != null) {\n            onInterruptStart();\n        }\n    };\n    // ── Sound effects (separate AudioContext) ──────────────────────────\n    function ensureSoundContext() {\n        if (!speechManager.soundCtx) {\n            speechManager.soundCtx = new (window.AudioContext || window.webkitAudioContext)();\n        }\n        var state = speechManager.soundCtx.state;\n        if (state === 'suspended' || state === 'interrupted') {\n            return speechManager.soundCtx.resume();\n        }\n        if (state === 'closed') {\n            speechManager.soundCtx = new (window.AudioContext || window.webkitAudioContext)();\n            return speechManager.soundCtx.resume();\n        }\n        return Promise.resolve();\n    }\n    function decodeSoundBuffer(speechId, arrayBuffer) {\n        if (speechManager._soundBuffers[speechId])\n            return;\n        if (!speechManager.soundCtx)\n            return;\n        var copy = arrayBuffer.slice(0);\n        speechManager.soundCtx.decodeAudioData(copy, function (buffer) {\n            if (isStaleGeneration())\n                return;\n            speechManager._soundBuffers[speechId] = buffer;\n        }, function () { });\n    }\n    function fetchAndDecodeSoundAudio(speechId) {\n        var chunks = figure.chunkedSpeech[speechId];\n        if (!chunks || chunks.length === 0)\n            return;\n        var speech = chunks[0];\n        if (speech._soundFetching)\n            return;\n        speech._soundFetching = true;\n        var ssmlHash = hashSSML(speech.ssml);\n        request('POST', 'speech_urls/', withSpeechToken({\n            ssml_hash: ssmlHash,\n            speech_chunks: [{ ssml: speech.ssml, marks_count: 0 }],\n        }), function (response) {\n            if (isStaleGeneration())\n                return;\n            try {\n                var audioURL = response.urls[0][0];\n                fetch(audioURL)\n                    .then(function (resp) {\n                    if (!resp.ok)\n                        throw new Error(\"Sound fetch failed: \".concat(resp.status));\n                    return resp.arrayBuffer();\n                })\n                    .then(function (arrayBuffer) {\n                    if (isStaleGeneration())\n                        return;\n                    if (speechManager.soundCtx) {\n                        decodeSoundBuffer(speechId, arrayBuffer);\n                    }\n                    // If playSound is waiting, try again now that we might have the buffer\n                    if (speech._playSoundWhenReady) {\n                        speech._playSoundWhenReady = false;\n                        // decodeAudioData is async, so poll briefly for the buffer\n                        var checkReady = function () {\n                            if (speechManager._soundBuffers[speechId]) {\n                                speechManager.playSound(speechId);\n                            }\n                        };\n                        setTimeout(checkReady, 100);\n                    }\n                })\n                    .catch(function () { speech._soundFetching = false; });\n            }\n            catch (e) {\n                speech._soundFetching = false;\n            }\n        });\n    }\n    /**\n     * Preload a short audio clip for later use with playSound().\n     * Creates a dedicated soundCtx (separate from speechManager.ctx) so\n     * it never unblocks the deferred play('default').  decodeAudioData\n     * works on a suspended context, so preloading works before any gesture.\n     */\n    speechManager.preloadSound = function (speechId) {\n        if (speechManager._soundBuffers[speechId])\n            return;\n        if (!speechManager.soundCtx) {\n            speechManager.soundCtx = new (window.AudioContext || window.webkitAudioContext)();\n        }\n        fetchAndDecodeSoundAudio(speechId);\n    };\n    /**\n     * Play a short audio clip without touching any speech state.\n     * Uses a dedicated soundCtx so resuming it never triggers the\n     * deferred play('default') on speechManager.ctx.\n     */\n    speechManager.playSound = function (speechId) {\n        var chunks = figure.chunkedSpeech[speechId];\n        if (!chunks || chunks.length === 0)\n            return;\n        // Stop any currently playing sound effect\n        if (speechManager._currentSoundSource) {\n            try {\n                speechManager._currentSoundSource.stop();\n            }\n            catch (e) { /* ignore */ }\n            speechManager._currentSoundSource = null;\n        }\n        ensureSoundContext().then(function () {\n            if (isStaleGeneration())\n                return;\n            var buffer = speechManager._soundBuffers[speechId];\n            if (buffer) {\n                var source_1 = speechManager.soundCtx.createBufferSource();\n                source_1.buffer = buffer;\n                source_1.connect(speechManager.soundCtx.destination);\n                speechManager._currentSoundSource = source_1;\n                source_1.addEventListener('ended', function () {\n                    if (speechManager._currentSoundSource === source_1) {\n                        speechManager._currentSoundSource = null;\n                    }\n                });\n                source_1.start(0);\n                return;\n            }\n            // Not loaded yet — request load, play when ready\n            var speech = chunks[0];\n            speech._playSoundWhenReady = true;\n            fetchAndDecodeSoundAudio(speechId);\n        }).catch(function () { });\n    };\n    /*\n    .########..##..........###....##....##\n    .##.....##.##.........##.##....##..##.\n    .##.....##.##........##...##....####..\n    .########..##.......##.....##....##...\n    .##........##.......#########....##...\n    .##........##.......##.....##....##...\n    .##........########.##.....##....##...\n    */\n    // speechManager.ctx = new (window.AudioContext || window.webkitAudioContext)();\n    // speechManager.blankAudio = makeAudio(`${window.location.origin}/static/speech/pause.mp3`);\n    // speechManager.blankAudio.load();\n    function ensureAudioContext() {\n        if (speechManager.ctx == null) {\n            speechManager.ctx = new (window.AudioContext ||\n                window.webkitAudioContext)();\n        }\n        // iOS sets state to 'interrupted' when the device sleeps; other browsers\n        // use 'suspended'.  In either case we need to resume before playback.\n        var state = speechManager.ctx.state;\n        if (state === 'suspended' || state === 'interrupted') {\n            return speechManager.ctx.resume();\n        }\n        // If the context was closed (e.g. by the OS reclaiming resources),\n        // create a fresh one.\n        if (state === 'closed') {\n            speechManager.ctx = new (window.AudioContext ||\n                window.webkitAudioContext)();\n            return speechManager.ctx.resume();\n        }\n        return Promise.resolve();\n    }\n    // Safari accumulates unbounded output latency on an AudioContext left running\n    // while its tab is hidden (WebKit bug 276687).  The graph clock keeps\n    // advancing normally while audible output falls further and further behind,\n    // so marks and animations — scheduled from getCurrentTime(), i.e. the graph\n    // clock — stay on time while the speech itself lags, then stops being audible\n    // at all once the lag exceeds a chunk's duration (playFinished stops the\n    // source before its samples ever reach the speakers).\n    //\n    // The state is unrecoverable and undetectable from the page: every exposed\n    // value (ctx.state, currentTime, getOutputTimestamp, baseLatency,\n    // outputLatency, destination channel counts) reads identically to a healthy\n    // tab, closing and recreating the context does not clear it, and a brand-new\n    // AudioContext in the same process is equally silent.  Only a new WebContent\n    // process escapes — a reload or a back-navigation reuses the wedged one, so a\n    // learner who hits this cannot recover by any means available to them.\n    //\n    // So the only defence is prevention: never hold a running context while\n    // hidden.  Suspending is safe because ensureAudioContext()/ensureSoundContext()\n    // resume before any playback, and the visible branch here resumes eagerly.\n    function suspendWhileHidden() {\n        if (!document.hidden || speechManager.isPlaying) {\n            return;\n        }\n        if (speechManager.ctx != null && speechManager.ctx.state === 'running') {\n            speechManager.ctx.suspend().catch(function () { });\n        }\n        if (speechManager.soundCtx != null\n            && speechManager.soundCtx.state === 'running') {\n            speechManager.soundCtx.suspend().catch(function () { });\n        }\n    }\n    // When the page becomes visible again (e.g. after iOS sleep/wake), try to\n    // resume the AudioContext immediately so it's ready when playback is needed.\n    // When it becomes hidden, release it (see suspendWhileHidden above).\n    var visibilityHandler = function () {\n        if (document.hidden) {\n            suspendWhileHidden();\n            return;\n        }\n        if (speechManager.ctx != null) {\n            var state = speechManager.ctx.state;\n            if (state === 'suspended' || state === 'interrupted') {\n                speechManager.ctx.resume().catch(function () { });\n            }\n        }\n        if (speechManager.soundCtx != null) {\n            var soundState = speechManager.soundCtx.state;\n            if (soundState === 'suspended' || soundState === 'interrupted') {\n                speechManager.soundCtx.resume().catch(function () { });\n            }\n        }\n    };\n    document.addEventListener('visibilitychange', visibilityHandler);\n    if (!figure._docListeners)\n        figure._docListeners = [];\n    figure._docListeners.push({ target: document, event: 'visibilitychange', handler: visibilityHandler });\n    speechManager.play = function (speechId) {\n        if (speechId === void 0) { speechId = null; }\n        if (speechId) {\n            // Starting new normal speech — discard any in-progress interrupt\n            if (speechManager.interruptedState != null) {\n                speechManager.toPlayButton = speechManager.interruptedState.toPlayButton;\n                speechManager.toPauseButton = speechManager.interruptedState.toPauseButton;\n                speechManager.interruptedState = null;\n            }\n            stop();\n            figure.speechId = speechId;\n        }\n        if (figure.speechId == null) {\n            return;\n        }\n        // A new playback request is the one moment an exhausted chunk gets\n        // another download; see resetFailedChunk.\n        resetFailedChunks(figure.speechId);\n        // A preloaded speech's loads may be queued behind other preloads, and\n        // still flagged as preloads for failure handling.\n        adoptSpeechLoads(figure.speechId);\n        startStallWatchdog();\n        // Ensure the AudioContext is alive and running before starting playback.\n        // On iOS after sleep/wake the context may be 'interrupted' or 'suspended'\n        // and resume() is async — we must wait for it before touching audio nodes.\n        ensureAudioContext().then(function () {\n            if (isStaleGeneration())\n                return;\n            speechManager.playInner();\n        }).catch(function () { });\n    };\n    speechManager.playInner = function () {\n        hideHighlightElements();\n        if (speechManager.seekPosition === 0 ||\n            speechManager.seekPosition >= speechManager.numSeeks) {\n            var speechChunks = figure.chunkedSpeech[figure.speechId];\n            if (speechChunks == null || speechChunks.length === 0) {\n                // speechManager.speechLoadingIcon.style.display = 'none';\n                if (speechManager.speechLoadingIcon) {\n                    speechManager.speechLoadingIcon.style.display = 'none';\n                }\n                speechManager.speechLoaded();\n                return;\n            }\n            var speech = speechChunks[0];\n            speechArrow.hide();\n            speechRect.hide();\n            speechManager.chunkIndex = 0;\n            speechManager.chunkDelayRemaining = 0;\n            speechManager.chunkDelayDone = false;\n            stop();\n            // Publish after the last synchronous teardown (stop() → stopFigure()\n            // has just fired), so subscribers starting animations in response\n            // won't be killed by the teardown.  Gated by a flag set in\n            // loadQuestion.ts on the autospeak path only, and scoped to the\n            // default/auto speech IDs so a preguide played before autospeak\n            // doesn't consume the flag and fire the notification early.\n            if (figure._pendingAutoSpeakNotification\n                && (figure.speechId === 'default' || figure.speechId === AUTO_SPEECH_ID)) {\n                figure._pendingAutoSpeakNotification = false;\n                figure.notifications.publish('startAutoSpeak', true);\n            }\n            if (isMainSpeech()) {\n                speechManager.toPauseButton();\n            }\n            if (speech.audio == null || isChunkFailed(speech)) {\n                resetFailedChunk(speech);\n                speech.onLoad = function () {\n                    playChunk();\n                };\n                loadAudio();\n            }\n            else {\n                speechManager.resumePlayChunkTimeoutId = setTimeout(function () {\n                    speechManager.resumePlayChunkTimeoutId = null;\n                    playChunk();\n                }, 50);\n            }\n            speechManager.timeStart = performance.now();\n            if (figure.speechId === 'default' || figure.speechId === AUTO_SPEECH_ID) {\n                speechManager.startCount += 1;\n            }\n            speechManager.updateSeekEnabled(speechManager.maxSeek);\n            speechManager.seekPosition = 0;\n            speechManager.updateSeekPosition(0);\n        }\n        else {\n            speechManager.seek(speechManager.seekPosition, true);\n        }\n    };\n    /*\n    .########.####.##.....##.########\n    ....##.....##..###...###.##......\n    ....##.....##..####.####.##......\n    ....##.....##..##.###.##.######..\n    ....##.....##..##.....##.##......\n    ....##.....##..##.....##.##......\n    ....##....####.##.....##.########\n    */\n    function getCurrentTime() {\n        var chunkedSpeech = figure.chunkedSpeech[figure.speechId];\n        var total = 0;\n        for (var i = 0; i < chunkedSpeech.length; i += 1) {\n            var speech = chunkedSpeech[i];\n            total += speech.delay;\n        }\n    }\n    /*\n    ..######..########.########.##....##\n    .##....##.##.......##.......##...##.\n    .##.......##.......##.......##..##..\n    ..######..######...######...#####...\n    .......##.##.......##.......##..##..\n    .##....##.##.......##.......##...##.\n    ..######..########.########.##....##\n    */\n    function getSeekActions() {\n        if (figure.speechId == null) {\n            return [];\n        }\n        var chunkedSpeech = figure.chunkedSpeech[figure.speechId];\n        if (chunkedSpeech == null || chunkedSpeech.length === 0) {\n            return [];\n        }\n        var seekActions = [\n            // [chunkIndex, chunkTime, seekLabel]\n            [0, 0, 'Start'],\n        ];\n        for (var i = 0; i < figure.chunkedSpeech[figure.speechId].length; i += 1) {\n            var speech = chunkedSpeech[i];\n            for (var j = 0; j < speech.initial_actions.length; j += 1) {\n                var action = speech.initial_actions[j];\n                if (action.seek != null) {\n                    action.index = seekActions.length;\n                    seekActions.push([i, 0, action.seek]);\n                }\n            }\n            var numActions = Object.keys(speech.actions).length;\n            for (var j = 0; j < numActions; j += 1) {\n                var action = speech.actions[j.toString()];\n                if (action.seek) {\n                    var markTime = null;\n                    if (speech.marks != null && speech.marks.stamps.length > j) {\n                        markTime = speech.marks.stamps[j].time / 1000;\n                    }\n                    action.index = seekActions.length;\n                    seekActions.push([i, markTime, action.seek]);\n                }\n            }\n        }\n        return seekActions;\n    }\n    speechManager.getSeekActions = getSeekActions;\n    // Go through each action up until the seek time, execute and stop('finish') them\n    function seek(index, play) {\n        if (play === void 0) { play = false; }\n        // eslint-disable-next-line\n        // console.log('seek', index)\n        speechManager.freeze = null;\n        speechManager.chunkDelayRemaining = 0;\n        speechManager.chunkDelayDone = false;\n        // if (speechManager.maxSeek === 0) {\n        //   return;\n        // }\n        if (speechManager.isPlaying) {\n            stop();\n        }\n        if (figure.speech.inUse) {\n            figure.cancelSpeech();\n        }\n        speechArrow.hide();\n        speechRect.hide();\n        var chunkedSpeech = figure.chunkedSpeech[figure.speechId];\n        if (chunkedSpeech == null || chunkedSpeech.length === 0) {\n            return;\n        }\n        var seekActions = getSeekActions();\n        var chunkIndex = chunkedSpeech.length - 1;\n        var seekTime = 0;\n        if (index < seekActions.length) {\n            var seekAction = seekActions[index];\n            chunkIndex = seekAction[0];\n            seekTime = seekAction[1];\n        }\n        speechManager.seekPosition = Math.min(index, speechManager.maxSeek, seekActions.length);\n        speechManager.updateSeekPosition(0);\n        var currentSeekIndex = 0;\n        var seekFound = false;\n        var initialActionIndex = 0;\n        for (var i = 0; i <= chunkIndex; i += 1) {\n            var speech = chunkedSpeech[i];\n            speechManager.chunkIndex = i;\n            for (var j = 0; j < speech.initial_actions.length; j += 1) {\n                var action = speech.initial_actions[j];\n                if (action.seek == null) {\n                    executeAction(action);\n                    stopFigure();\n                }\n                else {\n                    currentSeekIndex += 1;\n                }\n                if (currentSeekIndex === index) {\n                    seekFound = true;\n                    break;\n                }\n                initialActionIndex += 1;\n            }\n            speechManager.actionIndex = 0;\n            if (seekFound === false) {\n                var numActions = Object.keys(speech.actions).length;\n                for (var j = 0; j < numActions; j += 1) {\n                    var action = speech.actions[j.toString()];\n                    if (action.seek == null) {\n                        executeAction(action);\n                        stopFigure();\n                        speechManager.actionIndex += 1;\n                    }\n                    else {\n                        currentSeekIndex += 1;\n                    }\n                    if (currentSeekIndex === index) {\n                        seekFound = true;\n                        break;\n                    }\n                }\n            }\n            if (play && seekFound) {\n                playChunk([seekTime, initialActionIndex, speechManager.actionIndex]);\n            }\n            if (seekFound) {\n                return;\n            }\n        }\n    }\n    speechManager.seek = seek;\n    speechManager.seek = seek;\n    speechManager.seekOverride = function (index) {\n        var seekActions = getSeekActions();\n        speechManager.maxSeek = seekActions.length;\n        speechManager.seek(index);\n    };\n    /*\n    .########..#######..########..##.....##\n    .##.......##.....##.##.....##.###...###\n    .##.......##.....##.##.....##.####.####\n    .######...##.....##.########..##.###.##\n    .##.......##.....##.##...##...##.....##\n    .##.......##.....##.##....##..##.....##\n    .##........#######..##.....##.##.....##\n  \n    .########..########.##.....##.####.########.##......##\n    .##.....##.##.......##.....##..##..##.......##..##..##\n    .##.....##.##.......##.....##..##..##.......##..##..##\n    .########..######...##.....##..##..######...##..##..##\n    .##...##...##........##...##...##..##.......##..##..##\n    .##....##..##.........##.##....##..##.......##..##..##\n    .##.....##.########....###....####.########..###..###.\n    */\n    speechManager._formReview = null;\n    // Get the sub-steps array from a multi-step form action, or null for\n    // single-target form actions.\n    function getFormSteps(action) {\n        if (action.steps != null && Array.isArray(action.steps)) {\n            return action.steps;\n        }\n        if (Array.isArray(action.target)) {\n            return action.target;\n        }\n        return null;\n    }\n    // Find the next non-number (i.e. actual form change) index in steps,\n    // starting from startIndex. Returns -1 if none found.\n    function nextFormStepIndex(steps, startIndex) {\n        for (var i = startIndex; i < steps.length; i += 1) {\n            if (typeof steps[i] !== 'number') {\n                return i;\n            }\n        }\n        return -1;\n    }\n    // Process a form action for form review. Returns the target form name if\n    // a form step was executed (pausing here), or null if the action's steps\n    // are exhausted and the caller should continue to the next action.\n    function processFormAction(action, review) {\n        var steps = getFormSteps(action);\n        if (steps == null) {\n            // Single-target form action — execute and return target\n            executeAction(action);\n            stopFigure();\n            return typeof action.target === 'string' ? action.target : null;\n        }\n        // Multi-step form action — find the next form step\n        var idx = nextFormStepIndex(steps, review.formStepIndex);\n        if (idx === -1) {\n            // All steps consumed — reset and signal caller to continue\n            review.formStepIndex = 0;\n            return null;\n        }\n        var step = steps[idx];\n        // Execute a single form step as a synthetic single-target action\n        executeAction({ form: action.form, target: step.target });\n        stopFigure();\n        review.formStepIndex = idx + 1;\n        return step.target;\n    }\n    function advanceToNextForm() {\n        var review = speechManager._formReview;\n        if (review == null)\n            return null;\n        var chunkedSpeech = figure.chunkedSpeech[figure.speechId];\n        if (chunkedSpeech == null)\n            return null;\n        for (var i = review.chunkIndex; i < chunkedSpeech.length; i += 1) {\n            var speech = chunkedSpeech[i];\n            speechManager.chunkIndex = i;\n            // Process initial_actions\n            var startInitial = i === review.chunkIndex ? review.initialActionIndex : 0;\n            for (var j = startInitial; j < speech.initial_actions.length; j += 1) {\n                var action = speech.initial_actions[j];\n                if (action.form != null) {\n                    var target = processFormAction(action, review);\n                    if (target != null) {\n                        review.chunkIndex = i;\n                        // If steps remain, stay on this action\n                        review.initialActionIndex = review.formStepIndex > 0\n                            ? j : j + 1;\n                        review.actionIndex = 0;\n                        return target;\n                    }\n                    // Steps exhausted — fall through to continue\n                }\n                else {\n                    executeAction(action);\n                    stopFigure();\n                }\n            }\n            // Process actions\n            var numActions = Object.keys(speech.actions).length;\n            var startAction = i === review.chunkIndex ? review.actionIndex : 0;\n            for (var j = startAction; j < numActions; j += 1) {\n                var action = speech.actions[j.toString()];\n                if (action.form != null) {\n                    var target = processFormAction(action, review);\n                    if (target != null) {\n                        review.chunkIndex = i;\n                        review.initialActionIndex = speech.initial_actions.length;\n                        // If steps remain, stay on this action\n                        review.actionIndex = review.formStepIndex > 0\n                            ? j : j + 1;\n                        speechManager.actionIndex = review.actionIndex;\n                        return target;\n                    }\n                    // Steps exhausted — fall through to continue\n                }\n                else {\n                    executeAction(action);\n                    stopFigure();\n                    speechManager.actionIndex = j + 1;\n                }\n            }\n            // Done with this chunk, reset for next\n            review.initialActionIndex = 0;\n            review.actionIndex = 0;\n        }\n        // No more form actions\n        speechManager._formReview = null;\n        return null;\n    }\n    speechManager.playFormReviewSpeech = function (speechId) {\n        stop();\n        figure.speechId = speechId;\n        hideHighlightElements();\n        speechArrow.hide();\n        speechRect.hide();\n        speechManager._formReview = {\n            chunkIndex: 0,\n            initialActionIndex: 0,\n            actionIndex: 0,\n            formStepIndex: 0,\n        };\n        return advanceToNextForm();\n    };\n    speechManager.resumeFormReviewSpeech = function () {\n        if (speechManager._formReview == null)\n            return null;\n        return advanceToNextForm();\n    };\n    /*\n    Debug: step through speech CHUNK BY CHUNK, executing every action along the\n    way so the figure lands in the exact state it would have at that point — like\n    seek(), but stopping at chunk boundaries instead of author `seek:` labels.\n  \n    From the console:\n      sp()                                  // next chunk, then START PLAYING\n      sp(3)                                 // go to chunk 3, then START PLAYING\n      figure.speechManager.debugChunk(3)    // jump to the start of chunk 3 (paused)\n      figure.speechManager.debugNextChunk() // step forward one chunk (paused)\n      figure.speechManager.debugPrevChunk() // step back one chunk (paused)\n  \n    Pass `true` as the last arg to the debug* methods to also start playing\n    (that's what the `sp` shortcut does).\n  \n    It replays from chunk 0 every call (so cumulative state is always correct\n    regardless of where playback was), running each prior chunk's initial_actions\n    and mark-timed actions through executeAction + stopFigure (which snaps figure\n    animations to their end state). It then runs the TARGET chunk's\n    initial_actions only — leaving the figure at that chunk's opening state,\n    before its narration/transitions. It then stays paused, or (when `play` is\n    true) resumes audio from that chunk.\n    */\n    function debugChunk(target, play) {\n        if (play === void 0) { play = false; }\n        if (figure.speechId == null) {\n            // eslint-disable-next-line no-console\n            console.log('debugChunk: no active speech');\n            return null;\n        }\n        var chunkedSpeech = figure.chunkedSpeech[figure.speechId];\n        if (chunkedSpeech == null || chunkedSpeech.length === 0) {\n            // eslint-disable-next-line no-console\n            console.log('debugChunk: no chunks loaded for', figure.speechId);\n            return null;\n        }\n        // Tear down any in-flight playback / pending speech (mirrors seek()).\n        speechManager.freeze = null;\n        speechManager.chunkDelayRemaining = 0;\n        speechManager.chunkDelayDone = false;\n        if (speechManager.isPlaying) {\n            stop();\n        }\n        if (figure.speech.inUse) {\n            figure.cancelSpeech();\n        }\n        speechArrow.hide();\n        speechRect.hide();\n        var clamped = Math.max(0, Math.min(target, chunkedSpeech.length - 1));\n        var runAll = function (speech) {\n            var initial = speech.initial_actions || [];\n            for (var j = 0; j < initial.length; j += 1) {\n                executeAction(initial[j]);\n                stopFigure();\n            }\n            var actions = speech.actions || {};\n            var numActions = Object.keys(actions).length;\n            for (var j = 0; j < numActions; j += 1) {\n                executeAction(actions[j.toString()]);\n                stopFigure();\n            }\n        };\n        // Every chunk before the target: fire fully so the figure carries the\n        // accumulated state of all their actions.\n        for (var i = 0; i < clamped; i += 1) {\n            speechManager.chunkIndex = i;\n            runAll(chunkedSpeech[i]);\n        }\n        // Target chunk: fire its initial_actions only, landing at its opening\n        // state (before any mark-timed narration action).\n        var speech = chunkedSpeech[clamped];\n        speechManager.chunkIndex = clamped;\n        var initial = speech.initial_actions || [];\n        for (var j = 0; j < initial.length; j += 1) {\n            executeAction(initial[j]);\n            stopFigure();\n        }\n        speech._initialActionsFired = true;\n        speechManager.initialActionIndex = initial.length;\n        speechManager.actionIndex = 0;\n        // eslint-disable-next-line no-console\n        console.log(\"debugChunk: at chunk \".concat(clamped, \"/\").concat(chunkedSpeech.length - 1), typeof speech.ssml === 'string' ? speech.ssml.slice(0, 120) : '');\n        if (play) {\n            // Resume audio from this chunk, skipping its already-run initial_actions.\n            // Route through ensureAudioContext() exactly like the normal play() path:\n            // from a stopped/paused state the AudioContext is 'suspended', so a bare\n            // playChunk() runs silently — the actions still fire (the figure just\n            // \"wiggles\") but no audio plays. Resuming the context first (it's already\n            // running mid-playback, which is why it only broke when stopped) makes\n            // playback actually start.\n            ensureAudioContext().then(function () {\n                if (isStaleGeneration())\n                    return;\n                playChunk([0, initial.length, 0]);\n            }).catch(function () { });\n        }\n        return clamped;\n    }\n    speechManager.debugChunk = debugChunk;\n    speechManager.debugNextChunk = function (play) {\n        if (play === void 0) { play = false; }\n        return debugChunk(speechManager.chunkIndex + 1, play);\n    };\n    speechManager.debugPrevChunk = function (play) {\n        if (play === void 0) { play = false; }\n        return debugChunk(speechManager.chunkIndex - 1, play);\n    };\n    // sp() — step to the next chunk and play; sp(index) — go to that chunk and\n    // play. (Single console command; `pc` is taken by the play-continue click\n    // shortcut in initQuestionFinalize.ts, so it's not reused here.)\n    window.sp = function (index) {\n        return debugChunk(index == null ? speechManager.chunkIndex + 1 : index, true);\n    };\n    function toConsole(text, isMarked, mark) {\n        if (isMarked === void 0) { isMarked = false; }\n        if (mark === void 0) { mark = ''; }\n        if (isMarked) {\n            console.log(\"-> \".concat(mark, \" \").concat(text));\n        }\n        else {\n            console.log(\"   \".concat(mark, \" \").concat(text));\n        }\n    }\n    // List the question's guides with their indexes (no playback):\n    // figure.speechManager.debugGuide()\n    //\n    // Play guide at index 0:\n    // figure.speechManager.debugGuide(0)\n    //\n    // Play guide with id 'point_out_1':\n    // figure.speechManager.debugGuide('point_out_1')\n    //\n    // Also define the random index choices\n    // figure.speechManager.debugGuide('point_out_1', [0, 0, 1])\n    // dgc(): colour a guide's comment block (from the source YAML) by section:\n    // the guide name bold, When blue, Story yellow (spoken text, as speech()\n    // shows it), Note grey. A line starting a section (\"When:\", \"Story (for\n    // 44):\", \"Note:\") or a story branch (\"Light:\", \"If ...:\", \"Otherwise ...:\")\n    // has its label in bold; lines under it keep their section's colour. Text is\n    // passed as %s arguments so a \"%\" in a comment can't be read as a format.\n    var COMMENT_NAME_STYLE = 'font-weight:bold';\n    var COMMENT_STYLES = {\n        When: 'color:#3b82f6',\n        Story: 'color:#d4b106',\n        Note: 'color:#888;font-style:italic',\n        '': '',\n    };\n    var COMMENT_SECTION = /^(When|Story|Note)\\b[^:]*:/;\n    var COMMENT_LABEL = /^(When\\b[^:]*:|Story\\b[^:]*:|Note\\b[^:]*:|Light:|Mid:|Strong:|If [^:]*:|Otherwise[^:]*:)/;\n    function commentToConsole(title, comment, indent) {\n        var format = '%c%s';\n        var args = [COMMENT_NAME_STYLE, title];\n        var section = '';\n        comment.split('\\n').forEach(function (line) {\n            var text = line.replace(/^ +/, '');\n            var lead = line.slice(0, line.length - text.length);\n            var sectionMatch = text.match(COMMENT_SECTION);\n            if (sectionMatch) {\n                section = sectionMatch[1];\n            }\n            else if (/^\\w+$/.test(text)) {\n                // A generated guide's name heading its part of a helper block\n                format += '\\n%c%s';\n                args.push(COMMENT_NAME_STYLE, \"\".concat(indent).concat(lead).concat(text));\n                section = '';\n                return;\n            }\n            var style = COMMENT_STYLES[section];\n            var label = text.match(COMMENT_LABEL);\n            if (label) {\n                format += '\\n%c%s%c%s';\n                args.push(\"\".concat(style, \";font-weight:bold\"), \"\".concat(indent).concat(lead).concat(label[0]), style, text.slice(label[0].length));\n            }\n            else {\n                format += '\\n%c%s';\n                args.push(style, \"\".concat(indent).concat(lead).concat(text));\n            }\n        });\n        console.log.apply(console, __spreadArray([format], args, false));\n    }\n    // A helper-generated guide's block starts with its own name (its part of the\n    // helper's comment); drop that line, as the name is already the title.\n    function withoutNameHeading(guideName, comment) {\n        var lines = comment.split('\\n');\n        if (lines[0].trim() !== guideName) {\n            return comment;\n        }\n        return lines.slice(1).map(function (line) { return line.replace(/^ {2}/, ''); }).join('\\n');\n    }\n    // dgc(): the comment block of the guide about to play\n    function playingCommentToConsole(guideName, response) {\n        if (response.comment) {\n            commentToConsole(\"Playing \".concat(guideName), withoutNameHeading(guideName, response.comment), '  ');\n        }\n    }\n    // dg() / dgc(): the words the guide is about to speak, one line per chunk\n    // (ssml tags, marks and breaks stripped). speech(n) has the full breakdown.\n    function speechTextToConsole(guideName, chunks) {\n        if (!Array.isArray(chunks)) {\n            return;\n        }\n        var format = '%c%s';\n        var args = [COMMENT_NAME_STYLE, \"Speech \".concat(guideName)];\n        chunks.forEach(function (chunk, i) {\n            format += '\\n%c%s%c%s';\n            args.push(META_STYLE, \"  [\".concat(i, \"] \"), SPEECH_STYLE, chunkSpokenText(chunk));\n        });\n        console.log.apply(console, __spreadArray([format], args, false));\n    }\n    speechManager.debugGuide = function (guide_id, options, submitted_answer) {\n        if (guide_id === void 0) { guide_id = null; }\n        if (options === void 0) { options = {}; }\n        if (submitted_answer === void 0) { submitted_answer = null; }\n        // Both forms play with the answer on screen when none is passed, reshaped the\n        // way the server expects (dg(0) and dg('guide_id') used to differ here).\n        if (submitted_answer == null && figure.custom.getSubmittedAnswer) {\n            var enteredAnswer = figure.custom.getSubmittedAnswer();\n            if (enteredAnswer.slots && enteredAnswer.slots.RNR) {\n                enteredAnswer = enteredAnswer.slots;\n            }\n            if (enteredAnswer.slots && enteredAnswer.slots.CLOCK) {\n                enteredAnswer = enteredAnswer.slots;\n            }\n            if (typeof enteredAnswer === 'object'\n                && Object.keys(enteredAnswer).length === 0) {\n                submitted_answer = null;\n            }\n            else {\n                submitted_answer = enteredAnswer;\n                console.log(\"dg(\".concat(guide_id, \", \").concat(JSON.stringify(options), \", \").concat(JSON.stringify(submitted_answer), \")\"));\n            }\n        }\n        var sub_ans = duplicate(submitted_answer);\n        var answer_input = getAnswerInput();\n        console.log(sub_ans, answer_input.custom._answer_input);\n        if (answer_input.custom._answer_input == \"manipulative\") {\n            if (sub_ans != null && sub_ans.slots != null && sub_ans.manips != null) {\n                // Already in {slots, manips} shape (manipulative_slots)\n            }\n            else {\n                if (sub_ans != null) {\n                    Object.keys(sub_ans).forEach(function (key) {\n                        var e = figure.elements._expression.getElement(key);\n                        console.log(\"e\", e, key);\n                        if (e != null) {\n                            console.log(e.custom.manipulativeType);\n                            if (e.custom.manipulativeType == \"entryFieldSlot\") {\n                                sub_ans[key] = {\n                                    full: sub_ans[key].toString().split(''),\n                                    partial: [],\n                                };\n                            }\n                        }\n                    });\n                }\n                sub_ans = { slots: sub_ans, manips: {} };\n            }\n        }\n        if (answer_input.custom._answer_input == \"arrange_submit\") {\n            if (Array.isArray(sub_ans)) {\n                var sub_ans_obj = {};\n                var used_tiles = [];\n                // @ts-expect-error: TS2552\n                var elementNames = Object.keys(elements);\n                for (var i = 0; i < sub_ans.length; i += 1) {\n                    for (var j = 0; j < elementNames.length; j += 1) {\n                        var elementName = elementNames[j];\n                        // @ts-expect-error: TS2552\n                        var element = elements[elementName];\n                        if (typeof (element) === 'object'\n                            && element.make === 'text_tile'\n                            && used_tiles.indexOf(elementName) === -1\n                            && (element.label === sub_ans[i]\n                                || element.label === sub_ans[i].toString())) {\n                            sub_ans_obj[\"Slot\".concat(i + 1)] = elementName;\n                            used_tiles.push(elementName);\n                            break;\n                        }\n                    }\n                }\n                sub_ans = sub_ans_obj;\n            }\n        }\n        if (typeof guide_id === 'number' || guide_id == null) {\n            request('POST', 'debug_get_guides/', {\n                submitted_answer: sub_ans,\n                options: options,\n            }, function (response) {\n                var guide_name = null;\n                if (response.guides.length === 0) {\n                    console.log('No guides found for this question');\n                    return;\n                }\n                // dgc() (options.comments): the comment block above each guide in the\n                // source YAML (When / Story). A split guide's levels share one block,\n                // so it's printed once.\n                var comments = options.comments ? (response.comments || {}) : {};\n                for (var i = 0; i < response.guides.length; i += 1) {\n                    var guide = response.guides[i];\n                    var comment = comments[guide];\n                    var prev = i > 0 ? response.guides[i - 1] : null;\n                    var title = \"\".concat(i === guide_id ? '->' : '  ', \" \").concat(i, \" \").concat(guide);\n                    if (comment && prev != null && comments[prev] === comment) {\n                        console.log('%c%s%c%s', COMMENT_NAME_STYLE, title, 'color:#888', \"\\n       (same as \".concat(prev, \")\"));\n                    }\n                    else if (comment) {\n                        commentToConsole(title, withoutNameHeading(guide, comment), '       ');\n                    }\n                    else {\n                        toConsole(guide, i === guide_id, i);\n                    }\n                    if (i === guide_id) {\n                        guide_name = guide;\n                    }\n                }\n                // No guide selected (dg() with no index, or an out-of-range index):\n                // just list them, don't play anything.\n                if (guide_name == null) {\n                    console.log('dg(index) to play a guide');\n                    return;\n                }\n                request('POST', 'debug_speech_guide/', {\n                    guide_id: guide_name,\n                    submitted_answer: sub_ans,\n                    options: options,\n                }, function (response) {\n                    playingCommentToConsole(guide_name, response);\n                    speechTextToConsole(guide_name, response.chunked_speech);\n                    figure.chunkedSpeech[response.guide_hash] =\n                        response.chunked_speech;\n                    figure.speechManager.play(response.guide_hash);\n                });\n            });\n        }\n        else {\n            request('POST', 'debug_speech_guide/', {\n                guide_id: guide_id,\n                submitted_answer: sub_ans,\n                options: options,\n            }, function (response) {\n                playingCommentToConsole(guide_id, response);\n                speechTextToConsole(guide_id, response.chunked_speech);\n                figure.chunkedSpeech[response.guide_hash] = response.chunked_speech;\n                figure.speechManager.play(response.guide_hash);\n            });\n        }\n    };\n    // Collect the equation forms an action moves to, in order. Handles the three\n    // form-action shapes executeAction understands: single string target, a\n    // `steps` array, and an array `target` (each entry either a delay number or a\n    // goToForm object carrying its own `.target`).\n    var collectFormsFromAction = function (action, out) {\n        if (action == null || action.form == null) {\n            return;\n        }\n        var elems = Array.isArray(action.form) ? action.form : [action.form];\n        var element = elems.join(', ');\n        var push = function (target) {\n            if (target == null) {\n                return;\n            }\n            if (typeof target === 'string') {\n                out.push({ element: element, form: target });\n            }\n            else if (typeof target === 'object' && target.target != null) {\n                out.push({ element: element, form: target.target });\n            }\n        };\n        if (action.steps != null) {\n            action.steps.forEach(function (s) { if (typeof s !== 'number')\n                push(s); });\n        }\n        else if (Array.isArray(action.target)) {\n            action.target.forEach(function (t) { if (typeof t !== 'number')\n                push(t); });\n        }\n        else {\n            push(action.target);\n        }\n    };\n    // Flatten a chunkedSpeech array into the ordered list of forms it shows:\n    // per chunk, initial_actions first, then the keyed actions in index order.\n    var formsFromChunks = function (chunks) {\n        var out = [];\n        if (!Array.isArray(chunks)) {\n            return out;\n        }\n        chunks.forEach(function (chunk) {\n            if (Array.isArray(chunk.initial_actions)) {\n                chunk.initial_actions.forEach(function (a) { return collectFormsFromAction(a, out); });\n            }\n            if (chunk.actions) {\n                var n = Object.keys(chunk.actions).length;\n                for (var j = 0; j < n; j += 1) {\n                    collectFormsFromAction(chunk.actions[j.toString()], out);\n                }\n            }\n        });\n        return out;\n    };\n    var logForms = function (label, list) {\n        console.log(\"\".concat(label, \" (\").concat(list.length, \"):\"));\n        list.forEach(function (f, i) { return console.log(\"  [\".concat(i, \"] \").concat(f.element, \" -> \").concat(f.form)); });\n    };\n    // Walk the figure element tree, collecting every equation element and the\n    // forms defined on it.\n    var allDefinedForms = function () {\n        var results = [];\n        var seen = new Set();\n        var walk = function (el) {\n            if (el == null || typeof el !== 'object' || seen.has(el)) {\n                return;\n            }\n            seen.add(el);\n            if (el.eqn && el.eqn.forms) {\n                results.push({\n                    element: el.name || '(unnamed)',\n                    forms: Object.keys(el.eqn.forms),\n                });\n            }\n            if (el.elements) {\n                Object.keys(el.elements).forEach(function (k) { walk(el.elements[k]); });\n            }\n        };\n        walk(figure.elements);\n        return results;\n    };\n    // Shared guide fetch for the forms/speech debug helpers: auto-fills the\n    // entered answer the way dg does (but skips the manipulative / arrange_submit\n    // reshaping — the guide these helpers summarize is answer-independent for the\n    // questions they target), pulls a guide's chunked speech from the server\n    // without playing it, then hands (label, chunkedSpeech) to `onChunks`. A\n    // numeric arg is a guide index; a string is a guide name.\n    var fetchGuideChunks = function (arg, options, submitted_answer, onChunks) {\n        if (submitted_answer == null && figure.custom.getSubmittedAnswer) {\n            var enteredAnswer = figure.custom.getSubmittedAnswer();\n            if (enteredAnswer.slots && enteredAnswer.slots.RNR) {\n                enteredAnswer = enteredAnswer.slots;\n            }\n            if (enteredAnswer.slots && enteredAnswer.slots.CLOCK) {\n                enteredAnswer = enteredAnswer.slots;\n            }\n            if (typeof enteredAnswer === 'object'\n                && Object.keys(enteredAnswer).length === 0) {\n                submitted_answer = null;\n            }\n            else {\n                submitted_answer = enteredAnswer;\n            }\n        }\n        var sub_ans = duplicate(submitted_answer);\n        if (typeof arg === 'number') {\n            request('POST', 'debug_get_guides/', { submitted_answer: sub_ans, options: options }, function (response) {\n                if (response.guides.length === 0) {\n                    console.log('No guides found for this question');\n                    return;\n                }\n                if (arg < 0 || arg >= response.guides.length) {\n                    console.log(\"Guide index \".concat(arg, \" out of range (0..\").concat(response.guides.length - 1, \")\"));\n                    return;\n                }\n                var guide_name = response.guides[arg];\n                request('POST', 'debug_speech_guide/', { guide_id: guide_name, submitted_answer: sub_ans, options: options }, function (r) { onChunks(\"guide [\".concat(arg, \"] \").concat(guide_name), r.chunked_speech); });\n            });\n        }\n        else {\n            request('POST', 'debug_speech_guide/', { guide_id: arg, submitted_answer: sub_ans, options: options }, function (r) { onChunks(\"guide \\\"\".concat(arg, \"\\\"\"), r.chunked_speech); });\n        }\n    };\n    // Console-log the equation forms in three modes:\n    //   forms()             every form defined on every equation element\n    //   forms('speech')     forms shown by the currently loaded speech, in order\n    //   forms(guideIndex)   forms shown by guide N (fetched from the server, not\n    //   forms('guideName')  played); a guide name may be passed directly\n    // Each speech/guide entry logs as \"element -> form\".\n    speechManager.debugForms = function (arg, options, submitted_answer) {\n        if (arg === void 0) { arg = null; }\n        if (options === void 0) { options = {}; }\n        if (submitted_answer === void 0) { submitted_answer = null; }\n        if (arg == null) {\n            var groups = allDefinedForms();\n            if (groups.length === 0) {\n                console.log('No equation elements with forms found');\n                return;\n            }\n            groups.forEach(function (g) {\n                console.log(\"\".concat(g.element, \" \\u2014 \").concat(g.forms.length, \" form(s):\"));\n                g.forms.forEach(function (f, i) { return console.log(\"  [\".concat(i, \"] \").concat(f)); });\n            });\n            return;\n        }\n        if (arg === 'speech') {\n            if (figure.speechId == null) {\n                console.log('No speech loaded (figure.speechId is null). Play a guide first, or use forms(guideIndex).');\n                return;\n            }\n            logForms(\"Forms in speech \\\"\".concat(figure.speechId, \"\\\"\"), formsFromChunks(figure.chunkedSpeech[figure.speechId]));\n            return;\n        }\n        // Guide index / name — fetch and list the forms it shows.\n        fetchGuideChunks(arg, options, submitted_answer, function (label, chunkedSpeech) {\n            logForms(\"Forms in \".concat(label), formsFromChunks(chunkedSpeech));\n        });\n    };\n    var truncate = function (s, n) {\n        if (n === void 0) { n = 200; }\n        return (s.length > n ? \"\".concat(s.slice(0, n - 1), \"\\u2026\") : s);\n    };\n    // One-line summary of an action dict: form changes read as \"elem → form(s)\",\n    // everything else as compact (truncated) JSON.\n    var summarizeAction = function (action) {\n        if (action == null) {\n            return String(action);\n        }\n        if (action.form != null) {\n            var out = [];\n            collectFormsFromAction(action, out);\n            if (out.length > 0) {\n                var elems = Array.isArray(action.form) ? action.form.join(', ') : action.form;\n                return \"form  \".concat(elems, \" \\u2192 \").concat(out.map(function (o) { return o.form; }).join(', '));\n            }\n        }\n        return truncate(JSON.stringify(action));\n    };\n    // Break an ssml string into its ordered items: spoken-text runs, action\n    // marks (each maps to a keyed action), caption marks (each swaps the\n    // caption) and breaks (pauses). Residual ssml sub-tags are stripped from\n    // the text so it reads as plain words.\n    var parseSsmlItems = function (ssml) {\n        var items = [];\n        var body = (ssml || '').replace(/^\\s*<speak>/, '').replace(/<\\/speak>\\s*$/, '');\n        var clean = function (t) { return t.replace(/<[^>]*>/g, '').replace(/\\s+/g, ' ').trim(); };\n        var re = /<mark\\s+name=\"([^\"]+)\"\\s*\\/?>|<break\\s+time=\"([^\"]*)\"\\s*\\/?>/g;\n        var last = 0;\n        var m = re.exec(body);\n        while (m !== null) {\n            var text = clean(body.slice(last, m.index));\n            if (text) {\n                items.push({ type: 'speech', text: text });\n            }\n            if (m[1] != null) {\n                // Action marks are named 0, 1, ...; anything else is a caption mark\n                // (c0, c1, ...) - test for the action form so an unrecognised name\n                // can't parseInt to NaN and print as an action that does not exist.\n                if (/^\\d+$/.test(m[1])) {\n                    items.push({ type: 'mark', index: parseInt(m[1], 10) });\n                }\n                else {\n                    items.push({ type: 'caption', index: parseInt(m[1].slice(1), 10) });\n                }\n            }\n            else {\n                items.push({ type: 'break', time: m[2] });\n            }\n            last = re.lastIndex;\n            m = re.exec(body);\n        }\n        var tail = clean(body.slice(last));\n        if (tail) {\n            items.push({ type: 'speech', text: tail });\n        }\n        return items;\n    };\n    var SPEECH_STYLE = 'color:#d4b106'; // spoken text\n    var ACTION_STYLE = 'color:#3fa45b'; // actions\n    var META_STYLE = 'color:#888'; // headers, breaks, mark/init labels\n    var FORM_STYLE = 'color:#c678dd;font-weight:bold'; // form changes in transcripts\n    // Print a chunked-speech array as an ordered, colored per-chunk summary:\n    // initial actions first, then the spoken text interleaved with the actions\n    // that fire at each mark, in play order.\n    var summarizeChunks = function (label, chunks) {\n        if (!Array.isArray(chunks)) {\n            console.log(\"No speech found for \".concat(label));\n            return;\n        }\n        console.log(\"%c=== \".concat(label, \" \\u2014 \").concat(chunks.length, \" chunk(s) ===\"), 'font-weight:bold');\n        chunks.forEach(function (chunk, i) {\n            var delay = chunk.delay ? \" (delay \".concat(chunk.delay, \"s)\") : '';\n            console.log(\"%cChunk [\".concat(i, \"]\").concat(delay), \"font-weight:bold;\".concat(META_STYLE));\n            if (Array.isArray(chunk.initial_actions)) {\n                chunk.initial_actions.forEach(function (a) {\n                    console.log(\"  %c\\u25B8 init %c\".concat(summarizeAction(a)), META_STYLE, ACTION_STYLE);\n                });\n            }\n            parseSsmlItems(chunk.ssml).forEach(function (item) {\n                var _a;\n                if (item.type === 'speech') {\n                    console.log(\"  %c\".concat(item.text), SPEECH_STYLE);\n                }\n                else if (item.type === 'mark') {\n                    var action = chunk.actions ? chunk.actions[String(item.index)] : null;\n                    if (action != null) {\n                        console.log(\"  %c\\u25B8 @\".concat(item.index, \" %c\").concat(summarizeAction(action)), META_STYLE, ACTION_STYLE);\n                    }\n                    else {\n                        console.log(\"  %c\\u25B8 @\".concat(item.index, \" (no action)\"), META_STYLE);\n                    }\n                }\n                else if (item.type === 'caption') {\n                    var segments = chunk.caption_segments;\n                    // Caption mark n reveals segment n + 1\n                    var segment = Array.isArray(segments)\n                        ? segments[((_a = item.index) !== null && _a !== void 0 ? _a : 0) + 1]\n                        : null;\n                    console.log(\"  %c\\u25B8 caption \".concat(segment ? \"\\\"\".concat(segment.caption, \"\\\"\") : '(no segment)'), META_STYLE);\n                }\n                else if (item.type === 'break') {\n                    console.log(\"  %c\\u23F8 \".concat(item.time), META_STYLE);\n                }\n            });\n        });\n    };\n    // Summarize a speech to the console (chunks → initial actions, spoken text\n    // items, and the actions that fire at each mark; actions orange, text green):\n    //   speech()            the default speech (figure.chunkedSpeech.default)\n    //   speech(guideIndex)  guide N (fetched from the server, not played)\n    //   speech('guideName') a guide by name\n    speechManager.debugSpeech = function (arg, options, submitted_answer) {\n        if (arg === void 0) { arg = null; }\n        if (options === void 0) { options = {}; }\n        if (submitted_answer === void 0) { submitted_answer = null; }\n        if (arg == null) {\n            summarizeChunks('speech \"default\"', figure.chunkedSpeech.default);\n            return;\n        }\n        fetchGuideChunks(arg, options, submitted_answer, function (label, chunkedSpeech) {\n            summarizeChunks(label, chunkedSpeech);\n        });\n    };\n    // The words a chunk speaks, as plain text (ssml tags, marks and breaks\n    // stripped). Used for timing - it is what the audio actually says.\n    var chunkSpokenText = function (chunk) { return parseSsmlItems(chunk === null || chunk === void 0 ? void 0 : chunk.ssml)\n        .filter(function (item) { return item.type === 'speech'; })\n        .map(function (item) { return item.text; })\n        .join(' '); };\n    // The on-screen prose form of a chunk (its caption), falling back to the\n    // spoken text when the chunk has no caption.\n    var chunkCaptionText = function (chunk) {\n        var caption = typeof (chunk === null || chunk === void 0 ? void 0 : chunk.caption) === 'string' ? chunk.caption.trim() : '';\n        return caption || chunkSpokenText(chunk);\n    };\n    // Split text into sentences, keeping each one's start offset. A run of two\n    // or more dots is a blank to fill in (\"is ...\"), not a full stop. No regex\n    // lookbehind - it is above the Safari 14.1 floor.\n    var leadingSpace = function (t) { return (/^\\s*/.exec(t) || [''])[0].length; };\n    var splitSentences = function (text) {\n        var out = [];\n        var re = /([.!?]+)[\"')\\]]*(\\s+|$)/g;\n        var start = 0;\n        var m = re.exec(text);\n        while (m !== null) {\n            if (m[0] === '') {\n                break;\n            }\n            if (!/^\\.{2,}$/.test(m[1])) {\n                var end = m.index + m[0].length;\n                var sentence = text.slice(start, end).trim();\n                if (sentence) {\n                    out.push({ text: sentence, start: start + leadingSpace(text.slice(start)) });\n                }\n                start = end;\n            }\n            m = re.exec(text);\n        }\n        var tail = text.slice(start).trim();\n        if (tail) {\n            out.push({ text: tail, start: start + leadingSpace(text.slice(start)) });\n        }\n        return out;\n    };\n    var fmtTime = function (s) {\n        if (s == null || !Number.isFinite(s)) {\n            return '?';\n        }\n        var m = Math.floor(s / 60);\n        var sec = s - m * 60;\n        return \"\".concat(m, \":\").concat(sec < 10 ? '0' : '').concat(sec.toFixed(1));\n    };\n    // Estimate how far through a chunk's spoken text the audio is at `time`\n    // (seconds), as a 0..1 fraction. Anchors are the start (0s, offset 0), every\n    // action / caption mark whose stamp has loaded (stamp time, its offset in the\n    // text), and the end (audio duration, full length); the position between two\n    // anchors is linearly interpolated.\n    var chunkFractionAt = function (chunk, time) {\n        var _a, _b, _c;\n        var items = parseSsmlItems(chunk === null || chunk === void 0 ? void 0 : chunk.ssml);\n        var stamps = ((_a = chunk === null || chunk === void 0 ? void 0 : chunk.marks) === null || _a === void 0 ? void 0 : _a.stamps) || [];\n        var captionStamps = ((_b = chunk === null || chunk === void 0 ? void 0 : chunk.marks) === null || _b === void 0 ? void 0 : _b.captionStamps) || [];\n        var anchors = [[0, 0]];\n        var offset = 0;\n        items.forEach(function (item) {\n            if (item.type === 'speech') {\n                offset += (offset > 0 ? 1 : 0) + (item.text || '').length;\n            }\n            else if (item.type === 'mark' || item.type === 'caption') {\n                var name_2 = item.type === 'mark' ? String(item.index) : \"c\".concat(item.index);\n                var list = item.type === 'mark' ? stamps : captionStamps;\n                var stamp = list.find(function (s) { return String(s === null || s === void 0 ? void 0 : s.value) === name_2; });\n                if (stamp != null && Number.isFinite(stamp.time)) {\n                    anchors.push([stamp.time / 1000, offset]);\n                }\n            }\n        });\n        var total = offset;\n        if (total === 0) {\n            return 0;\n        }\n        var duration = (_c = chunk === null || chunk === void 0 ? void 0 : chunk.audio) === null || _c === void 0 ? void 0 : _c.duration;\n        if (duration > 0) {\n            anchors.push([duration, total]);\n        }\n        anchors.sort(function (a, b) { return a[0] - b[0]; });\n        var pos = anchors[anchors.length - 1][1];\n        for (var i = 0; i < anchors.length - 1; i += 1) {\n            var _d = anchors[i], t0 = _d[0], o0 = _d[1];\n            var _e = anchors[i + 1], t1 = _e[0], o1 = _e[1];\n            if (time <= t1) {\n                pos = t1 > t0 ? o0 + ((time - t0) / (t1 - t0)) * (o1 - o0) : o1;\n                break;\n            }\n        }\n        return Math.max(0, Math.min(1, pos / total));\n    };\n    // sc() - speech cursor. Where the playing (or paused) speech is: the chunk\n    // index to hand to sp() to get back here (sp jumps to the START of a chunk,\n    // so this is the closest sp can land at or before the current point), the\n    // time elapsed in the chunk and in the whole speech, and the sentence being\n    // spoken. Times for chunks whose audio hasn't loaded yet are unknown, so a\n    // total that includes them is a lower bound (shown with ≥).\n    speechManager.debugCursor = function (log) {\n        var _a, _b, _c;\n        if (log === void 0) { log = true; }\n        var speechId = figure.speechId;\n        var chunks = speechId == null ? null : figure.chunkedSpeech[speechId];\n        if (!Array.isArray(chunks) || chunks.length === 0) {\n            if (log) {\n                console.log('sc: no active speech');\n            }\n            return null;\n        }\n        var index = Math.max(0, Math.min(speechManager.chunkIndex || 0, chunks.length - 1));\n        var chunk = chunks[index];\n        var delay = chunk.delay > 0 ? chunk.delay : 0;\n        // Time into this chunk's audio. While paused, freeze.currentTime is the\n        // position pause() captured (audio.pauseTime alone is wrong after a\n        // resume-then-pause, as it drops audio.startTime).\n        var audio = chunk.audio;\n        var isCurrentAudio = audio != null && audio === speechManager.currentAudio;\n        var audioTime = 0;\n        if (speechManager.freeze != null && Number.isFinite(speechManager.freeze.currentTime)) {\n            audioTime = speechManager.freeze.currentTime;\n        }\n        else if (isCurrentAudio && !speechManager.isPlaying && audio.state === 'ready'\n            && audio.pauseTime === 0 && audio.duration > 0) {\n            // Played through to the end: the audio resets its position to 0 when it\n            // ends, so report the end of the chunk instead.\n            audioTime = audio.duration;\n        }\n        else if (isCurrentAudio && typeof audio.getCurrentTime === 'function') {\n            audioTime = audio.getCurrentTime();\n        }\n        // The chunk's leading delay: still counting down, or done.\n        var delayElapsed = delay;\n        var inDelay = false;\n        if (delay > 0 && !isCurrentAudio && speechManager.chunkDelayRemaining > 0) {\n            inDelay = true;\n            var remaining = speechManager.chunkDelayRemaining;\n            if (speechManager.delayTimeoutId) {\n                remaining -= performance.now() / 1000 - speechManager.chunkDelayStart;\n            }\n            delayElapsed = Math.max(0, Math.min(delay, delay - remaining));\n            audioTime = 0;\n        }\n        var chunkDuration = (audio === null || audio === void 0 ? void 0 : audio.duration) > 0 ? audio.duration : null;\n        var before = 0;\n        var beforeKnown = true;\n        for (var i = 0; i < index; i += 1) {\n            var c = chunks[i];\n            before += c.delay > 0 ? c.delay : 0;\n            if (((_a = c.audio) === null || _a === void 0 ? void 0 : _a.duration) > 0) {\n                before += c.audio.duration;\n            }\n            else {\n                beforeKnown = false;\n            }\n        }\n        var total = 0;\n        var totalKnown = true;\n        chunks.forEach(function (c) {\n            var _a;\n            total += c.delay > 0 ? c.delay : 0;\n            if (((_a = c.audio) === null || _a === void 0 ? void 0 : _a.duration) > 0) {\n                total += c.audio.duration;\n            }\n            else {\n                totalKnown = false;\n            }\n        });\n        var elapsed = before + delayElapsed + audioTime;\n        // Locate the sentence: estimate the fraction through the spoken text, map\n        // it onto the caption (the prose may be worded slightly differently), and\n        // find the sentence containing that point.\n        var caption = chunkCaptionText(chunk);\n        var fraction = inDelay ? 0 : chunkFractionAt(chunk, audioTime);\n        var sentences = splitSentences(caption);\n        var at = Math.round(fraction * caption.length);\n        var sentenceIndex = 0;\n        for (var i = 0; i < sentences.length; i += 1) {\n            if (sentences[i].start <= at) {\n                sentenceIndex = i;\n            }\n        }\n        var sentence = (_c = (_b = sentences[sentenceIndex]) === null || _b === void 0 ? void 0 : _b.text) !== null && _c !== void 0 ? _c : '';\n        // Current form of the expression, plus any other equation element this\n        // speech changes the form of.\n        var formElements = ['expression'];\n        formsFromChunks(chunks).forEach(function (f) {\n            f.element.split(', ').forEach(function (name) {\n                if (formElements.indexOf(name) === -1) {\n                    formElements.push(name);\n                }\n            });\n        });\n        var forms = {};\n        formElements.forEach(function (name) {\n            var _a, _b;\n            var currentForm = (_b = (_a = figure.get(name)) === null || _a === void 0 ? void 0 : _a.eqn) === null || _b === void 0 ? void 0 : _b.currentForm;\n            if (currentForm != null) {\n                forms[name] = currentForm;\n            }\n        });\n        var result = {\n            speechId: speechId,\n            sp: index,\n            chunk: index,\n            chunks: chunks.length,\n            playing: !!speechManager.isPlaying,\n            inDelay: inDelay,\n            chunkTime: delayElapsed + audioTime,\n            chunkDuration: chunkDuration == null ? null : delay + chunkDuration,\n            elapsed: elapsed,\n            elapsedIsLowerBound: !beforeKnown,\n            total: total,\n            totalIsLowerBound: !totalKnown,\n            sentence: sentence,\n            sentenceIndex: sentenceIndex,\n            sentencesInChunk: sentences.length,\n            chunkCaption: caption,\n            forms: forms,\n        };\n        if (log) {\n            var state = speechManager.isPlaying ? 'playing' : 'paused/stopped';\n            console.log(\"%cSpeech cursor \\u2014 \\\"\".concat(speechId, \"\\\" (\").concat(state, \")\"), 'font-weight:bold');\n            console.log(\"  %cchunk %c\".concat(index, \"%c of \").concat(chunks.length - 1, \"  \\u2192  sp(\").concat(index, \") restarts this chunk\"), META_STYLE, 'font-weight:bold;color:#3b9dd6', META_STYLE);\n            console.log(\"  %celapsed \".concat(beforeKnown ? '' : '≥').concat(fmtTime(elapsed), \" of \").concat(totalKnown ? '' : '≥').concat(fmtTime(total))\n                + \"   (in chunk: \".concat(fmtTime(result.chunkTime), \" of \").concat(fmtTime(result.chunkDuration))\n                + \"\".concat(inDelay ? ', in leading delay' : '', \")\"), META_STYLE);\n            if (sentences.length === 0) {\n                console.log('  %csentence: (no text in this chunk)', META_STYLE);\n            }\n            else {\n                console.log(\"  %csentence \".concat(sentenceIndex + 1, \"/\").concat(sentences.length, \" in chunk: %c\").concat(sentence), META_STYLE, SPEECH_STYLE);\n            }\n            var formNames_1 = Object.keys(forms);\n            if (formNames_1.length === 0) {\n                console.log('  %cform: (no expression found)', META_STYLE);\n            }\n            formNames_1.forEach(function (name) {\n                console.log(\"  %cform\".concat(formNames_1.length > 1 || name !== 'expression' ? \" (\".concat(name, \")\") : '', \": %c\").concat(forms[name]), META_STYLE, FORM_STYLE);\n            });\n        }\n        return result;\n    };\n    // Print a chunked speech as a readable transcript: the captions joined and\n    // re-split into full sentences (a sentence can span chunks), each tagged\n    // with the chunk it starts in, i.e. the sp() index that plays it. Returns\n    // the joined text.\n    var printTranscript = function (label, chunks) {\n        if (!Array.isArray(chunks)) {\n            console.log(\"No speech found for \".concat(label));\n            return '';\n        }\n        var text = '';\n        var chunkStarts = [];\n        // Form changes, positioned in `text`. Initial-action forms sit at the\n        // chunk start; a mark's forms are placed by how far through the spoken\n        // text the mark is, mapped onto the caption and snapped to a word gap.\n        var formMarks = [];\n        var formLabel = function (f) { return (f.element === 'expression' ? f.form : \"\".concat(f.element, \": \").concat(f.form)); };\n        chunks.forEach(function (chunk) {\n            var caption = chunkCaptionText(chunk);\n            if (text && caption) {\n                text += ' ';\n            }\n            var chunkStart = text.length;\n            chunkStarts.push(chunkStart);\n            text += caption;\n            if (Array.isArray(chunk.initial_actions)) {\n                var initial_1 = [];\n                chunk.initial_actions.forEach(function (a) { return collectFormsFromAction(a, initial_1); });\n                initial_1.forEach(function (f) { return formMarks.push({ pos: chunkStart, label: formLabel(f) }); });\n            }\n            var items = parseSsmlItems(chunk === null || chunk === void 0 ? void 0 : chunk.ssml);\n            var offset = 0;\n            var markOffsets = [];\n            items.forEach(function (item) {\n                if (item.type === 'speech') {\n                    offset += (offset > 0 ? 1 : 0) + (item.text || '').length;\n                }\n                else if (item.type === 'mark') {\n                    markOffsets.push({ offset: offset, index: item.index });\n                }\n            });\n            var spokenLength = offset;\n            markOffsets.forEach(function (m) {\n                var _a;\n                var marked = [];\n                collectFormsFromAction((_a = chunk.actions) === null || _a === void 0 ? void 0 : _a[String(m.index)], marked);\n                if (marked.length === 0) {\n                    return;\n                }\n                var pos = spokenLength > 0\n                    ? Math.round((m.offset / spokenLength) * caption.length)\n                    : 0;\n                // Snap to the nearest word gap so a form never splits a word.\n                if (pos > 0 && pos < caption.length && /\\S/.test(caption[pos - 1]) && /\\S/.test(caption[pos])) {\n                    var back = pos;\n                    while (back > 0 && /\\S/.test(caption[back - 1])) {\n                        back -= 1;\n                    }\n                    var fwd = pos;\n                    while (fwd < caption.length && /\\S/.test(caption[fwd])) {\n                        fwd += 1;\n                    }\n                    pos = pos - back <= fwd - pos ? back : fwd;\n                }\n                marked.forEach(function (f) { return formMarks.push({ pos: chunkStart + pos, label: formLabel(f) }); });\n            });\n        });\n        // ▶ only while this speech is playing or paused part way - a stopped\n        // speech's chunkIndex is just wherever it was left (often 0).\n        var active = speechManager.isPlaying || speechManager.freeze != null;\n        var current = active && figure.speechId != null\n            && figure.chunkedSpeech[figure.speechId] === chunks\n            ? speechManager.chunkIndex\n            : null;\n        console.log(\"%c=== Transcript: \".concat(label, \" \\u2014 \").concat(chunks.length, \" chunk(s) ===\"), 'font-weight:bold');\n        var sentences = splitSentences(text);\n        // Form changes that fall in no sentence (e.g. a speech with no text)\n        // print on their own line.\n        if (sentences.length === 0 && formMarks.length > 0) {\n            var fmt = formMarks.map(function () { return '%c|%s|'; }).join(' ');\n            console.log.apply(console, __spreadArray([\"%c [0] \".concat(fmt), META_STYLE], formMarks.reduce(function (acc, f) { return acc.concat([FORM_STYLE, f.label]); }, []), false));\n        }\n        sentences.forEach(function (s, si) {\n            var chunkIndex = 0;\n            for (var i = 0; i < chunkStarts.length; i += 1) {\n                if (chunkStarts[i] <= s.start) {\n                    chunkIndex = i;\n                }\n            }\n            var marker = chunkIndex === current ? '▶' : ' ';\n            // Forms from this sentence's start up to the next sentence's start (the\n            // first sentence also takes any before it).\n            var lo = si === 0 ? -Infinity : s.start;\n            var hi = si + 1 < sentences.length ? sentences[si + 1].start : Infinity;\n            var inSentence = formMarks\n                .filter(function (f) { return f.pos >= lo && f.pos < hi; })\n                .sort(function (a, b) { return a.pos - b.pos; });\n            var end = s.start + s.text.length;\n            var fmt = \"%c\".concat(marker, \"[\").concat(chunkIndex, \"] \");\n            var args = [META_STYLE];\n            var parts = [];\n            var cursor = s.start;\n            inSentence.forEach(function (f) {\n                var at = Math.max(s.start, Math.min(end, f.pos));\n                var piece = text.slice(cursor, at).trim();\n                if (piece) {\n                    parts.push('speech');\n                    args.push(SPEECH_STYLE, piece);\n                }\n                parts.push('form');\n                args.push(FORM_STYLE, \"|\".concat(f.label, \"|\"));\n                cursor = at;\n            });\n            var tail = text.slice(cursor, end).trim();\n            if (tail) {\n                parts.push('speech');\n                args.push(SPEECH_STYLE, tail);\n            }\n            fmt += parts.map(function () { return '%c%s'; }).join(' ');\n            console.log.apply(console, __spreadArray([fmt], args, false));\n        });\n        return text;\n    };\n    // st() - transcript of the active speech (or the default one if none is\n    // active); st(guideIndex) / st('guideName') - a guide's, fetched from the\n    // server without playing it. Returns the full text (for the arg-less form).\n    speechManager.debugTranscript = function (arg, options, submitted_answer) {\n        if (arg === void 0) { arg = null; }\n        if (options === void 0) { options = {}; }\n        if (submitted_answer === void 0) { submitted_answer = null; }\n        if (arg == null) {\n            var speechId = figure.speechId != null && figure.chunkedSpeech[figure.speechId]\n                ? figure.speechId\n                : 'default';\n            return printTranscript(\"speech \\\"\".concat(speechId, \"\\\"\"), figure.chunkedSpeech[speechId]);\n        }\n        fetchGuideChunks(arg, options, submitted_answer, function (label, chunkedSpeech) {\n            printTranscript(label, chunkedSpeech);\n        });\n        return undefined;\n    };\n    window.sc = function () { return speechManager.debugCursor(); };\n    window.st = speechManager.debugTranscript;\n    speechManager.testGuide = function (guide, index, submitted_answer, playAll) {\n        if (submitted_answer === void 0) { submitted_answer = null; }\n        if (playAll === void 0) { playAll = false; }\n        request('POST', 'debug_test_guide/', {\n            submitted_answer: submitted_answer,\n            guide: guide,\n            index: index\n        }, function (response) {\n            for (var i = 0; i < response.phrases.length; i += 1) {\n                toConsole(\"[\".concat(i, \"] \").concat(response.phrases[i]['text']), i === index);\n            }\n            if (playAll) {\n                var i_3 = 0;\n                figure.speechManager.playFinishedCallback3 = function () {\n                    i_3 += 1;\n                    if (i_3 < response.phrases.length) {\n                        toConsole(\"[\".concat(i_3, \"] \").concat(response.phrases[i_3]['text']), i_3 === index);\n                        figure.chunkedSpeech[response.phrases[i_3]['hash']] = response.phrases[i_3]['chunked_speech'];\n                        figure.speechManager.play(response.phrases[i_3]['hash']);\n                    }\n                };\n                figure.chunkedSpeech[response.phrases[i_3]['hash']] = response.phrases[i_3]['chunked_speech'];\n                figure.speechManager.play(response.phrases[i_3]['hash']);\n            }\n            else {\n                figure.chunkedSpeech[response.hash] =\n                    response.chunked_speech;\n                figure.speechManager.play(response.hash);\n            }\n        });\n    };\n    // Play all indexes:\n    // figure.speechManager.debugHelperGuide('get_select_guide_speech', [0])\n    //\n    // Play only index 1:\n    // figure.speechManager.debugHelperGuide('get_select_guide_speech', [0], 1)\n    speechManager.debugHelperGuide = function (helper, rand_indexes, index, submitted_answer) {\n        if (rand_indexes === void 0) { rand_indexes = []; }\n        if (index === void 0) { index = null; }\n        if (submitted_answer === void 0) { submitted_answer = null; }\n        request('POST', 'debug_guide_helper/', {\n            submitted_answer: submitted_answer,\n            helper: helper,\n            rand_indexes: rand_indexes,\n        }, function (response) {\n            var speeches = response.results;\n            // Setup all chunked speeches\n            for (var i = 0; i < speeches.length; i += 1) {\n                figure.chunkedSpeech[\"\".concat(i)] = speeches[i].info.chunked_speech;\n            }\n            // If specific index to play, then just play that index\n            if (index != null) {\n                for (var i = 0; i < speeches.length; i += 1) {\n                    toConsole(speeches[i].cleaned, i === index, i);\n                }\n                figure.say(\"Index \".concat(index));\n                setTimeout(function () {\n                    figure.speechManager.play(\"\".concat(index));\n                }, 1000);\n                return;\n            }\n            // If no index, then play through all indexes\n            figure.speechManager.playFinishedCallback3 = function () {\n                if (figure.speechManager.currentDebugIndex < speeches.length - 1) {\n                    figure.speechManager.currentDebugIndex += 1;\n                    setTimeout(function () {\n                        console.log(\"Index: \".concat(figure.speechManager.currentDebugIndex));\n                        for (var i = 0; i < speeches.length; i += 1) {\n                            toConsole(speeches[i].cleaned, i === figure.speechManager.currentDebugIndex, i);\n                        }\n                        figure.say(\"Index \".concat(figure.speechManager.currentDebugIndex));\n                        setTimeout(function () {\n                            figure.speechManager.play(\"\".concat(figure.speechManager.currentDebugIndex));\n                        }, 1000);\n                    }, 1000);\n                }\n            };\n            figure.speechManager.currentDebugIndex = 0;\n            for (var i = 0; i < speeches.length; i += 1) {\n                toConsole(speeches[i].cleaned, i === 0, i);\n            }\n            figure.say(\"Index 0\");\n            setTimeout(function () {\n                figure.speechManager.play('0');\n            }, 1000);\n        });\n    };\n    speechManager.checkGuides = function () {\n        request('POST', 'debug_spellcheck_guides/', {}, function (response) {\n            console.log(response.errors);\n            console.log(\"Errors: \".concat(Object.keys(response.errors).length));\n        });\n    };\n    // Play all phrases in a speech_defs block consecutively:\n    // figure.speechManager.debugSpeechDefs('REMEMBER')\n    //\n    // Play only the phrase at index 3:\n    // figure.speechManager.debugSpeechDefs('REMEMBER', 3)\n    //\n    // Also define the random indexes used for sub-choices:\n    // figure.speechManager.debugSpeechDefs('REMEMBER', 3, [0, 1])\n    speechManager.debugSpeechDefs = function (name, index, rand_indexes) {\n        if (index === void 0) { index = null; }\n        if (rand_indexes === void 0) { rand_indexes = null; }\n        var payload = { name: name };\n        if (rand_indexes != null) {\n            payload.rand_indexes = rand_indexes;\n        }\n        request('POST', 'debug_speech_defs/', payload, function (response) {\n            if (response.error) {\n                console.log(response.error);\n                return;\n            }\n            var phrases = response.phrases;\n            if (phrases.length === 0) {\n                console.log(\"No phrases found for \".concat(name));\n                return;\n            }\n            for (var i = 0; i < phrases.length; i += 1) {\n                figure.chunkedSpeech[\"\".concat(name, \"/\").concat(i)] = phrases[i].chunked_speech;\n                toConsole(phrases[i].text, i === index, i);\n            }\n            if (index != null) {\n                if (index < 0 || index >= phrases.length) {\n                    console.log(\"Index \".concat(index, \" out of range (0..\").concat(phrases.length - 1, \")\"));\n                    return;\n                }\n                figure.speechManager.play(\"\".concat(name, \"/\").concat(index));\n                return;\n            }\n            // No index — play all consecutively.\n            figure.speechManager.currentDebugIndex = 0;\n            figure.say(\"0\");\n            setTimeout(function () {\n                figure.speechManager.play(\"\".concat(name, \"/0\"));\n            }, 1000);\n            figure.speechManager.playFinishedCallback3 = function () {\n                if (figure.speechManager.currentDebugIndex < phrases.length - 1) {\n                    figure.speechManager.currentDebugIndex += 1;\n                    setTimeout(function () {\n                        var idx = figure.speechManager.currentDebugIndex;\n                        console.log(\"Index: \".concat(idx));\n                        figure.say(\"\".concat(idx));\n                        setTimeout(function () {\n                            figure.speechManager.play(\"\".concat(name, \"/\").concat(idx));\n                        }, 1000);\n                    }, 1000);\n                }\n            };\n        });\n    };\n    speechManager.getGuides = function (submitted_answer) {\n        if (submitted_answer === void 0) { submitted_answer = null; }\n        request('POST', 'debug_get_guides/', {\n            submitted_answer: submitted_answer,\n        }, function (response) {\n            console.log(response.guides);\n        });\n    };\n    /*\n    .##.....##.########.##.....##.##......\n    .##.....##....##....###...###.##......\n    .##.....##....##....####.####.##......\n    .#########....##....##.###.##.##......\n    .##.....##....##....##.....##.##......\n    .##.....##....##....##.....##.##......\n    .##.....##....##....##.....##.########\n    */\n    // eslint-disable-next-line\n    function makeCaptions() {\n        var captions = document.createElement('div');\n        captions.id = 'speech_captions';\n        captions.classList.add('figureone_captions');\n        captions.classList.add('hide');\n        var text = document.createTextNode('');\n        captions.appendChild(text);\n        // text.childNodes[0].nodeValue = message;\n        var f1_text_container = \n        // document.getElementsByClassName('navbar')[0];\n        document.getElementById('navbarNavDropdown');\n        f1_text_container.appendChild(captions);\n        speechManager.updateCaption = function (newCaption) {\n            text.nodeValue = newCaption;\n        };\n        speechManager.showCaptions = function () {\n            if (speechManager.hideCaptionsTimeoutId) {\n                clearTimeout(speechManager.hideCaptionsTimeoutId);\n                speechManager.hideCaptionsTimeoutId = null;\n            }\n            captions.classList.remove('hide');\n        };\n        speechManager.hideCaptions = function () {\n            captions.classList.add('hide');\n        };\n    }\n    makeCaptions();\n    var speechDebounce = false;\n    function createSpeechIcon() {\n        var speakerContainer = document.createElement('div');\n        speakerContainer.id = 'speaker_container';\n        var speakerDiv = document.createElement('div');\n        speakerDiv.id = 'speaker';\n        speakerContainer.appendChild(speakerDiv);\n        speakerContainer.classList.add('speaker_container');\n        speakerDiv.classList.add('speaker');\n        // speakerDiv.classList.add('hide');\n        var f1_text_container = document.getElementsByClassName('figureone__html')[0];\n        f1_text_container.appendChild(speakerContainer);\n        var speechLoadingDiv = document.createElement('div');\n        speechLoadingDiv.classList.add('speaker-ring');\n        speechLoadingDiv.appendChild(document.createElement('div'));\n        speechLoadingDiv.appendChild(document.createElement('div'));\n        speechLoadingDiv.appendChild(document.createElement('div'));\n        speechLoadingDiv.appendChild(document.createElement('div'));\n        speechLoadingDiv.style.display = 'none';\n        speakerContainer.appendChild(speechLoadingDiv);\n        speechManager.speakerIcon = speakerDiv;\n        speechManager.speechLoadingIcon = speechLoadingDiv;\n        speakerContainer.onclick = function () {\n            window.clickHandled = true;\n            // tester()\n            if (speechManager.offlineSpeech) {\n                figure.saySpeech();\n            }\n            else {\n                if (speechDebounce === false) {\n                    speechLoadingDiv.style.display = 'inline-block';\n                    speechLoadingDiv.classList.remove('fade_in_fast_delay');\n                    // eslint-disable-next-line\n                    speechLoadingDiv.offsetWidth;\n                    speechLoadingDiv.classList.add('fade_in_fast_delay');\n                    speakerDiv.classList.remove('little-pulse');\n                    // eslint-disable-next-line\n                    speakerDiv.offsetWidth;\n                    speakerDiv.classList.add('little-pulse');\n                    // speakerDiv.style.display = 'none';\n                    speechManager.play(figure.chunkedSpeech[MANUAL_SPEECH_ID] ? MANUAL_SPEECH_ID : 'default');\n                    speechDebounce = true;\n                    setTimeout(function () {\n                        speechDebounce = false;\n                    }, 500);\n                }\n            }\n        };\n        speakerContainer.addEventListener('touchmove', function (event) {\n            event.preventDefault();\n        }, { passive: false });\n    }\n    // createSpeechIcon();\n    var speechKeyHandler = function (event) {\n        var _a, _b;\n        if (event.key === 'v' || event.key === 'V') {\n            // A training playing (lockInteraction) would restart from the top while\n            // its tap finger's queued steps carry on\n            if (((_a = figure.custom) === null || _a === void 0 ? void 0 : _a.releaseTraining) != null) {\n                return;\n            }\n            // As the speaker button (helper.tsx): blocked while interactions are\n            // disabled, e.g. a guide's |disable_interactions| demonstration, which\n            // would be cut off before its |enable_interactions| and leave the\n            // question locked\n            if ((_b = figure.custom) === null || _b === void 0 ? void 0 : _b.disabled) {\n                return;\n            }\n            if (speechDebounce === false) {\n                speechManager.play();\n                speechDebounce = true;\n                setTimeout(function () {\n                    speechDebounce = false;\n                }, 500);\n            }\n        }\n    };\n    document.body.addEventListener('keydown', speechKeyHandler);\n    if (!figure._docListeners)\n        figure._docListeners = [];\n    figure._docListeners.push({ target: document.body, event: 'keydown', handler: speechKeyHandler });\n    function createSeekBar() {\n        speechManager.updateSeekEnabled = function () { };\n        speechManager.updateSeekPosition = function () { };\n        var seekActions = getSeekActions();\n        if (seekActions.length === 0) {\n            return;\n        }\n        var numSeek = seekActions.length + 1;\n        var seekSpaceEM = numSeek > 4 ? 17 / (numSeek - 1) : 17 / (numSeek - 1);\n        var endSpaceEM = 0.5;\n        var widthEM = (numSeek - 1) * seekSpaceEM + endSpaceEM * 2;\n        var seekTouch = document.createElement('div');\n        var endSpacePercent = endSpaceEM / widthEM;\n        var seekPercent = (widthEM - endSpaceEM * 2) / widthEM;\n        var pointRadiusEM = 0.4;\n        var selectPointRadiusEM = 0.6;\n        var seekContainer = document.createElement('div');\n        seekContainer.classList.add('seek_container');\n        seekContainer.id = 'seek_container';\n        if (numSeek === 2) {\n            seekContainer.classList.add('hide');\n        }\n        var seekDiv = document.createElement('div');\n        seekDiv.classList.add('seek_div');\n        seekContainer.appendChild(seekDiv);\n        speechManager.seekContainer = seekContainer;\n        var seekBar = document.createElement('div');\n        seekBar.style.width = \"\".concat((numSeek - 1) * seekSpaceEM, \"em\");\n        seekBar.classList.add('seek_bar');\n        seekDiv.appendChild(seekBar);\n        speechManager.seekBar = seekBar;\n        var seekBarEnabled = document.createElement('div');\n        seekBarEnabled.style.width = '0em';\n        seekBarEnabled.classList.add('seek_bar');\n        seekBarEnabled.classList.add('seek_bar_enabled');\n        seekDiv.appendChild(seekBarEnabled);\n        var seekBarCurrent = document.createElement('div');\n        seekBarCurrent.style.width = '0em';\n        seekBarCurrent.classList.add('seek_bar');\n        seekBarCurrent.classList.add('seek_bar_current');\n        seekDiv.appendChild(seekBarCurrent);\n        var seekPoints = [];\n        for (var i = 0; i < numSeek; i += 1) {\n            var seekPoint = document.createElement('div');\n            seekPoint.id = \"seek_point_\".concat(i);\n            seekPoint.classList.add('seek_point');\n            seekPoint.style.left = \"\".concat(i * seekSpaceEM - pointRadiusEM, \"em\");\n            seekDiv.appendChild(seekPoint);\n            seekPoints.push(seekPoint);\n        }\n        seekTouch.style.width = \"\".concat(widthEM, \"em\");\n        seekTouch.style.left = \"-\".concat(endSpaceEM, \"em\");\n        seekTouch.classList.add('seek_touch');\n        seekTouch.addEventListener('click', function (event) {\n            var touch = event.offsetX;\n            var width = seekTouch.offsetWidth;\n            var p = touch / width;\n            var index = 0;\n            var normP = (p - endSpacePercent) / seekPercent;\n            if (normP <= 0) {\n                index = 0;\n            }\n            else if (normP >= 1) {\n                index = numSeek - 1;\n            }\n            else {\n                index = Fig.round(normP / (1 / (numSeek - 1)), 0);\n            }\n            index = Math.min(index, speechManager.maxSeek);\n            speechManager.seekPosition = index;\n            speechManager.updateSeekPosition(0);\n            speechManager.seek(index);\n        });\n        seekDiv.appendChild(seekTouch);\n        speechManager.updateSeekEnabled = function (index_in) {\n            var index = Math.min(index_in, numSeek - 1);\n            for (var i = 0; i < numSeek; i += 1) {\n                if (i <= index) {\n                    seekPoints[i].classList.add('seek_point_enabled');\n                }\n                else {\n                    seekPoints[i].classList.remove('seek_point_enabled');\n                }\n            }\n            seekBarEnabled.style.width = \"\".concat(index * seekSpaceEM, \"em\");\n        };\n        speechManager.updateSeekPosition = function (percentTime) {\n            var index = Math.min(speechManager.seekPosition, speechManager.maxSeek, numSeek - 1);\n            seekBarCurrent.style.width = \"\".concat(index * seekSpaceEM + percentTime * seekSpaceEM, \"em\");\n            for (var i = 0; i < numSeek; i += 1) {\n                if (i <= index) {\n                    seekPoints[i].classList.add('seek_point_current');\n                }\n                else {\n                    seekPoints[i].classList.remove('seek_point_current');\n                }\n            }\n            for (var i = 0; i < seekPoints.length; i += 1) {\n                if (i !== index) {\n                    seekPoints[i].classList.remove('seek_point_selected');\n                    seekPoints[i].style.left = \"\".concat(i * seekSpaceEM - pointRadiusEM, \"em\");\n                }\n                else {\n                    seekPoints[i].classList.add('seek_point_selected');\n                    seekPoints[i].style.left =\n                        \"\".concat(i * seekSpaceEM - selectPointRadiusEM, \"em\");\n                }\n            }\n        };\n        var f1_text_container = document.getElementsByClassName('figureone__html')[0];\n        f1_text_container.appendChild(seekContainer);\n    }\n    createSeekBar();\n    /*\n    .########..########..########.##........#######.....###....########.\n    .##.....##.##.....##.##.......##.......##.....##...##.##...##.....##\n    .##.....##.##.....##.##.......##.......##.....##..##...##..##.....##\n    .########..########..######...##.......##.....##.##.....##.##.....##\n    .##........##...##...##.......##.......##.....##.#########.##.....##\n    .##........##....##..##.......##.......##.....##.##.....##.##.....##\n    .##........##.....##.########.########..#######..##.....##.########.\n    */\n    var preloadQueue = [];\n    var preloadInProgress = false;\n    function preloadAudio(speechId, prioritize) {\n        if (prioritize === void 0) { prioritize = false; }\n        // decodeAudioData needs speechManager.ctx, but ctx is normally created\n        // lazily by ensureAudioContext on the first play().  If a preload runs\n        // before any play() / user gesture, ctx would be null when decode()\n        // runs and the captured-ctx closure in makeAudio would NPE.  Create it\n        // up front — decodeAudioData works on a suspended context, so no\n        // gesture is required.\n        if (speechManager.ctx == null) {\n            speechManager.ctx = new (window.AudioContext\n                || window.webkitAudioContext)();\n        }\n        if (prioritize) {\n            preloadQueue.unshift(speechId);\n        }\n        else {\n            preloadQueue.push(speechId);\n        }\n        processPreloadQueue();\n    }\n    function processPreloadQueue() {\n        if (preloadInProgress || preloadQueue.length === 0)\n            return;\n        preloadInProgress = true;\n        var speechId = preloadQueue.shift();\n        var chunks = figure.chunkedSpeech[speechId];\n        if (!chunks || chunks.length === 0) {\n            preloadInProgress = false;\n            processPreloadQueue();\n            return;\n        }\n        var chunkIndex = 0;\n        function loadNextChunk() {\n            // Skip already-loaded chunks\n            while (chunkIndex < chunks.length && chunks[chunkIndex].audio != null) {\n                chunkIndex++;\n            }\n            if (chunkIndex >= chunks.length) {\n                preloadInProgress = false;\n                processPreloadQueue();\n                return;\n            }\n            var chunk = chunks[chunkIndex];\n            var ssmlHash = hashSSML(chunk.ssml);\n            var marks_count = totalMarksCount(chunk);\n            chunk.marks = {\n                stamps: [],\n                captionStamps: [],\n                state: marks_count > 0 ? 'waiting' : 'ready',\n                url: null,\n            };\n            var currentChunkIndex = chunkIndex;\n            var receiveUrls = function (response) {\n                // Stale response from a previous question — discard.\n                if (isStaleGeneration())\n                    return;\n                var audioURL = response.urls[0][0];\n                var marksURL = response.urls[0][1];\n                delete chunk.cached_speech;\n                chunk.audio = makeAudio(audioURL);\n                // Flag the audio as a preload for limiter queue priority. (Whether a\n                // failure ends the speech is decided by ownership at the time -- see\n                // isActiveSpeechAudio in makeAudio -- not by this flag.)\n                chunk.audio._isPreload = true;\n                chunk.audio.onEnd = makeChunkOnEnd(speechId);\n                chunk.marks.url = marksURL;\n                chunk.audio.load();\n                if (marksURL != null) {\n                    // The retrying loader: its per-attempt caps bound a hung preload\n                    // marks fetch so it cannot hold a shared limiter slot indefinitely,\n                    // and chunk.audio._isPreload makes it a preload entry there.\n                    getMarks(marksURL, currentChunkIndex, speechId, null, undefined, chunk.audio);\n                }\n                chunkIndex++;\n                loadNextChunk();\n            };\n            var cachedUrls = cachedSpeechUrls(chunk);\n            if (cachedUrls) {\n                receiveUrls({ urls: [cachedUrls] });\n            }\n            else {\n                request('POST', 'speech_urls/', withSpeechToken({\n                    ssml_hash: ssmlHash,\n                    speech_chunks: [{ ssml: chunk.ssml, marks_count: marks_count }],\n                }), receiveUrls);\n            }\n        }\n        loadNextChunk();\n    }\n    /*\n    ..######...########.########..######..########..########.########..######..##.....##\n    .##....##..##..........##....##....##.##.....##.##.......##.......##....##.##.....##\n    .##........##..........##....##.......##.....##.##.......##.......##.......##.....##\n    .##...####.######......##.....######..########..######...######...##.......#########\n    .##....##..##..........##..........##.##........##.......##.......##.......##.....##\n    .##....##..##..........##....##....##.##........##.......##.......##....##.##.....##\n    ..######...########....##.....######..##........########.########..######..##.....##\n    */\n    function handleSpeechReady(speechId, play, interrupt, autoResume, preload, prioritize, resumeFrom, onInterruptStart, onInterruptEnd) {\n        if (play) {\n            if (interrupt && figure.speechId != null) {\n                speechManager.interruptPlay(speechId, autoResume, resumeFrom, onInterruptStart, onInterruptEnd);\n            }\n            else {\n                speechManager.play(speechId);\n            }\n        }\n        else if (preload) {\n            preloadAudio(speechId, prioritize);\n        }\n    }\n    speechManager.getSpeech = function (speech, options) {\n        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;\n        if (options === void 0) { options = {}; }\n        var play = (_a = options.play) !== null && _a !== void 0 ? _a : false;\n        var interrupt = (_b = options.interrupt) !== null && _b !== void 0 ? _b : false;\n        var autoResume = (_c = options.autoResume) !== null && _c !== void 0 ? _c : false;\n        var resumeFrom = (_d = options.resumeFrom) !== null && _d !== void 0 ? _d : 'here';\n        var id = (_e = options.id) !== null && _e !== void 0 ? _e : null;\n        var preload = (_f = options.preload) !== null && _f !== void 0 ? _f : false;\n        var prioritize = (_g = options.prioritize) !== null && _g !== void 0 ? _g : false;\n        var onInterruptStart = (_h = options.onInterruptStart) !== null && _h !== void 0 ? _h : null;\n        var onInterruptEnd = (_j = options.onInterruptEnd) !== null && _j !== void 0 ? _j : null;\n        var rand_indexes = (_k = options.rand_indexes) !== null && _k !== void 0 ? _k : null;\n        // A snapshot is a still image, and its page is rendered by an account with\n        // no learner selected: process_speech/ answers that with a redirect to\n        // /learners/, which request() follows by navigating the whole page away\n        // mid-screenshot (every snap render on 2026-10-05).\n        if (window.location.pathname.indexOf('/debug_learner_state_record_snapshot') === 0) {\n            return;\n        }\n        // Dedup: if this id already has chunked speech, use it directly\n        if (id != null && figure.chunkedSpeech[id] != null) {\n            handleSpeechReady(id, play, interrupt, autoResume, preload, prioritize, resumeFrom, onInterruptStart, onInterruptEnd);\n            return;\n        }\n        var payload = { speech: speech };\n        if (rand_indexes != null) {\n            payload.rand_indexes = rand_indexes;\n        }\n        request('POST', 'process_speech/', payload, function (response) {\n            // Stale response from a previous question — discard.\n            if (isStaleGeneration())\n                return;\n            figure.chunkedSpeech[response.hash] = response.chunked_speech;\n            var speechId = id !== null && id !== void 0 ? id : response.hash;\n            if (id != null) {\n                figure.chunkedSpeech[id] = response.chunked_speech;\n            }\n            handleSpeechReady(speechId, play, interrupt, autoResume, preload, prioritize, resumeFrom, onInterruptStart, onInterruptEnd);\n        });\n    };\n    speechManager.playSpeech = function (speech, options) {\n        if (options === void 0) { options = {}; }\n        speechManager.getSpeech(speech, {\n            play: true,\n            interrupt: options.interrupt,\n            autoResume: options.autoResume,\n            resumeFrom: options.resumeFrom,\n            id: options.id,\n            onInterruptStart: options.onInterruptStart,\n            onInterruptEnd: options.onInterruptEnd,\n            rand_indexes: options.rand_indexes,\n        });\n    };\n    // Accepts the same Python-style speech format as playSpeech\n    // (visual annotations like |v:...|, {vpulse: [...]}, delays, etc.).\n    // Processes the speech server-side and preloads the audio so a later\n    // speechManager.play(id) starts without a network round-trip.\n    speechManager.preloadSpeech = function (id, speech, options) {\n        if (options === void 0) { options = {}; }\n        speechManager.getSpeech(speech, {\n            preload: true,\n            id: id,\n            prioritize: options.prioritize,\n            rand_indexes: options.rand_indexes,\n        });\n    };\n}\nwindow.makeSpeechManager = makeSpeechManager;\n/*\n..#######..########.########.##.......####.##....##.########\n.##.....##.##.......##.......##........##..###...##.##......\n.##.....##.##.......##.......##........##..####..##.##......\n.##.....##.######...######...##........##..##.##.##.######..\n.##.....##.##.......##.......##........##..##..####.##......\n.##.....##.##.......##.......##........##..##...###.##......\n..#######..##.......##.......########.####.##....##.########\n*/\n// eslint-disable-next-line\nfunction hideHelperBubble() { }\nwindow.hideHelperBubble = hideHelperBubble;\nfunction getVoice() {\n    var voices = window.speechSynthesis.getVoices();\n    var voice;\n    // const bestVoices = ['Samantha', 'Alex', 'Fred', 'Victoria'];\n    var bestVoices = ['Samantha'];\n    for (var i = 0; i < voices.length; i += 1) {\n        if (voices[i].lang === 'en-US' && bestVoices.indexOf(voices[i].name) > -1) {\n            voice = voices[i];\n            break;\n        }\n    }\n    if (voice == null) {\n        for (var i = 0; i < voices.length; i += 1) {\n            if (voices[i].lang === 'en-US') {\n                voice = voices[i];\n                break;\n            }\n        }\n    }\n    figure.speech.voice = voice;\n}\nwindow.getVoice = getVoice;\n// eslint-disable-next-line\nfunction makeOfflineSpeech() {\n    if (figure.speechMessage == null) {\n        return;\n    }\n    var speechManager = figure.speechManager;\n    function setupSeekActions() {\n        var seekIndex = 0;\n        for (var i = 0; i < figure.speechMessage.length; i += 1) {\n            var phrase = figure.speechMessage[i];\n            if (phrase.seek != null) {\n                seekIndex += 1;\n                phrase.index = seekIndex;\n            }\n        }\n    }\n    setupSeekActions();\n    figure.speech = {\n        startCount: 0,\n        completeCount: 0,\n        timePlayed: 0,\n        playTime: [],\n        fastForward: false,\n        fastForwardDuration: 10,\n        useCaptions: false,\n        playDuration: 0,\n        getPlayDuration: function () { return 0; },\n    };\n    if (figure.speechMessage == null) {\n        return;\n    }\n    figure.speech.index = 0;\n    figure.speech.msg = null;\n    figure.speech.voice = null;\n    var speechTimeout = -1;\n    getVoice();\n    function cancelSpeech() {\n        if (speechTimeout !== -1) {\n            clearTimeout(speechTimeout);\n            speechTimeout = -1;\n        }\n        if (figure.speech.fastForwardTimerId != null) {\n            clearTimeout(figure.speech.fastForwardTimerId);\n            figure.speech.fastForwardTimerId = null;\n        }\n        figure.speech.msg = [];\n        window.speechSynthesis.cancel();\n        figure.speech.index = 0;\n    }\n    figure.speech.stop = function () { return cancelSpeech(); };\n    figure.say = function (something, cancel, queue) {\n        if (cancel === void 0) { cancel = true; }\n        if (queue === void 0) { queue = false; }\n        if (cancel) {\n            cancelSpeech();\n        }\n        var to_say = something.replace(/^,*/, '');\n        var msg = new SpeechSynthesisUtterance(to_say);\n        // Do not enable this - it breaks on some iOS devices with speech about\n        // the setup like voice name and prosody\n        // msg.voice = figure.speech.voice;\n        msg.rate = 0.9;\n        msg.lang = 'en-US';\n        figure.speech.msg.push(msg);\n        if (queue && !figure.speech.fastForward) {\n            msg.addEventListener('end', function () {\n                figure.speech.index += 1;\n                if (figure.speech.started == null) {\n                    figure.speech.started = performance.now();\n                }\n                figure.speech.speechTime = performance.now() - figure.speech.started;\n                var speechMsgIndex = figure.speech.msg.indexOf(msg);\n                if (speechMsgIndex > -1) {\n                    // eslint-disable-next-line\n                    sayNext();\n                }\n                figure.speech.msg.splice(speechMsgIndex, 1);\n            });\n        }\n        window.speechSynthesis.speak(msg);\n        if (figure.speech.fastForward) {\n            figure.speech.fastForwardTimerId = setTimeout(function () {\n                figure.speech.fastForwardTimerId = null;\n                figure.speech.index += 1;\n                window.speechSynthesis.cancel();\n                speechManager.stopFigure();\n                // eslint-disable-next-line\n                sayNext();\n            }, figure.speech.fastForwardDuration);\n        }\n        if (speechManager.useCaptions) {\n            speechManager.updateCaption(to_say);\n        }\n    };\n    function getElementsArray(elems_def) {\n        var elems;\n        if (!Array.isArray(elems_def)) {\n            elems = [elems_def];\n        }\n        else {\n            elems = elems_def;\n        }\n        return elems;\n    }\n    var specialTags = ['%end_if_shown%', '<split/>'];\n    figure.speech.getPlayDuration = function () {\n        var duration = figure.speech.playDuration;\n        if (figure.speech.timeStart != null) {\n            duration += performance.now() - figure.speech.timeStart;\n        }\n        return duration / 1000;\n    };\n    function sayNext() {\n        if (figure.speech.index > figure.speechMessage.length - 1) {\n            // speechManager.speechRect.hide();\n            // speechManager.speechArrow.hide();\n            // figure.notifications.publish('speechComplete');\n            speechManager.playFinished();\n            figure.speech.completeCount += 1;\n            if (figure.speech.timeStart != null) {\n                figure.speech.playDuration +=\n                    performance.now() - figure.speech.timeStart;\n            }\n            figure.speech.timeStart = null;\n            // if (speechManager.useCaptions) {\n            //   speechManager.hideCaptions();\n            // }\n            return;\n        }\n        var nextSpeech = figure.speechMessage[figure.speech.index];\n        if (typeof nextSpeech === 'string' &&\n            specialTags.indexOf(nextSpeech) === -1) {\n            var message = figure.speechMessage[figure.speech.index];\n            // console.log('1', message)\n            message = message.replace(/<\\/*prosody[^>]*>/gi, '');\n            message = message.replace(/<\\/*split[^>]*>/gi, '');\n            message = message.replace(/<\\/*break[^>]*>/gi, '');\n            message = message.replace(/<\\/*mark[^>]*>/gi, '');\n            message = message.replace(/<\\/*speak[^>]*>/gi, '');\n            message = message.replace(/<\\/*emphasis[^>]*>/gi, '');\n            message = message.replace(/<\\/*manual_split[^>]*>/gi, '');\n            // console.log('2', message)\n            if (message.length === 0) {\n                figure.speech.index += 1;\n                sayNext();\n            }\n            else {\n                figure.say(message, false, true);\n            }\n        }\n        else if (typeof nextSpeech === 'string' &&\n            specialTags.indexOf(nextSpeech) > -1) {\n            figure.speech.index += 1;\n            sayNext();\n        }\n        else if (typeof nextSpeech === 'object') {\n            if (nextSpeech.delay != null && Object.keys(nextSpeech).length === 1) {\n                speechTimeout = setTimeout(function () {\n                    figure.speech.index += 1;\n                    speechTimeout = -1;\n                    sayNext();\n                }, nextSpeech.delay * 1000);\n            }\n            else if (nextSpeech.if_shown != null) {\n                var elems = getElementsArray(nextSpeech.if_shown);\n                var isShown = true;\n                for (var i = 0; i < elems.length; i += 1) {\n                    var elem = figure.get(elems[i]);\n                    // A missing element counts as not shown: an answer input can\n                    // legitimately omit a button (e.g. guess's `see_another` once out\n                    // of repeats), and throwing here broke the speech.\n                    if (elem == null || !elem.isShown) {\n                        isShown = false;\n                        break;\n                    }\n                }\n                figure.speech.index += 1;\n                if (!isShown) {\n                    while (figure.speechMessage[figure.speech.index].end_if_shown == null &&\n                        figure.speech.index < figure.speechMessage.length) {\n                        figure.speech.index += 1;\n                    }\n                }\n                sayNext();\n            }\n            else {\n                speechManager.executeAction(nextSpeech);\n                figure.speech.index += 1;\n                sayNext();\n            }\n        }\n    }\n    function saySpeech(initialDelay) {\n        if (initialDelay === void 0) { initialDelay = 0; }\n        speechManager.updateSeekEnabled(speechManager.maxSeek);\n        speechManager.seekPosition = 0;\n        speechManager.updateSeekPosition(0);\n        figure.speech.inUse = true;\n        figure.speech.timeStart = performance.now();\n        figure.speech.startCount += 1;\n        if (speechManager.useCaptions) {\n            speechManager.showCaptions();\n        }\n        cancelSpeech();\n        if (initialDelay > 0) {\n            speechTimeout = setTimeout(function () {\n                figure.speech.index += 1;\n                speechTimeout = -1;\n                saySpeech();\n            }, initialDelay * 1000);\n            return;\n        }\n        sayNext();\n    }\n    figure.cancelSpeech = function () { return cancelSpeech(); };\n    figure.speech.sayNext = sayNext;\n    figure.speech.sayFastForward = function (fastForwardDuration) {\n        if (fastForwardDuration === void 0) { fastForwardDuration = 10; }\n        figure.speech.msg = [];\n        figure.speech.index = 0;\n        figure.speech.fastForward = true;\n        figure.speech.fastForwardDuration = fastForwardDuration;\n        sayNext();\n    };\n    figure.saySpeech = function (initialDelay) {\n        if (initialDelay === void 0) { initialDelay = 0; }\n        return saySpeech(initialDelay);\n    };\n    // speech.notifications.add('onClick', () => {\n    //   saySpeech();\n    // });\n    var offlineSpeechKeyHandler = function (event) {\n        if (event.key === '@') {\n            saySpeech();\n        }\n    };\n    document.body.addEventListener('keydown', offlineSpeechKeyHandler);\n    if (!figure._docListeners)\n        figure._docListeners = [];\n    figure._docListeners.push({ target: document.body, event: 'keydown', handler: offlineSpeechKeyHandler });\n}\nwindow.makeOfflineSpeech = makeOfflineSpeech;\n// // This works when timeout is small, but fails when big\n// function test() {\n//   console.log(\"hello\");\n//   const audio = new Audio(`http://${window.location.host}/static/speech/test.mp3`)\n//   audio.play();\n//   audio.addEventListener('ended', () => {\n//     setTimeout(() => {\n//       const audio2 = new Audio(`http://${window.location.host}/static/speech/test2.mp3`)\n//       audio2.play();\n//       audio2.addEventListener('ended', () => {\n//         const audio3 = new Audio(`http://${window.location.host}/static/speech/test3.mp3`)\n//         audio3.play();\n//       })\n//     }, 500);\n//   })\n// }\n// let ctx = null;\n// function test() {\n//   // ctx = new (window.AudioContext || window.webkitAudioContext)();\n//   // window.ctx1 = ctx;\n//   fetch(`http://${window.location.host}/static/speech/test10.mp3`)\n//     .then(resp => resp.arrayBuffer())\n//     .then(resp => {\n//       // speech.audioBuffer = response;\n//       console.log(resp)\n//       ctx.decodeAudioData(resp)\n//         .then((buffer) => {\n//           window.audioBuffer = buffer;\n//           console.log(buffer.duration);\n//         });\n//     });\n// }\n// function test2() {\n//   // ctx = new (window.AudioContext || window.webkitAudioContext)();\n//   fetch(`http://${window.location.host}/static/speech/test3.mp3`)\n//     .then(resp => resp.arrayBuffer())\n//     .then(resp => {\n//       // speech.audioBuffer = response;\n//       console.log(resp)\n//       ctx.decodeAudioData(resp)\n//         .then((buffer) => {\n//           window.audioBuffer1 = buffer;\n//         })\n//     })\n// }\n// let source1;\n// function tester() {\n//   console.log('hellow')\n//   const source = ctx.createBufferSource();\n//   source.buffer = window.audioBuffer;\n//   source.connect(ctx.destination);\n//   source.start(0);\n//   source1 = source\n// }\n// function tester2() {\n//   console.log('hellow')\n//   const source = ctx.createBufferSource();\n//   source.buffer = window.audioBuffer1;\n//   source.connect(ctx.destination);\n//   source.start(0);\n// }\n// function create() {\n//   const button = document.createElement('div');\n//   button.style.width = '100px';\n//   button.style.height = '100px';\n//   button.style.backgroundColor = 'red';\n//   button.onclick = () => {\n//     ctx = new (window.AudioContext || window.webkitAudioContext)();\n//     console.log(ctx)\n//   }\n//   const f1_text_container = document.getElementsByClassName('figureone__html')[0];\n//   f1_text_container.appendChild(button);\n// }\n// window.addEventListener('DOMContentLoaded', () => {\n//   create();\n// })\n","module.exports = Fig;","module.exports = React;","module.exports = ReactDOM;","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n// expose the modules object (__webpack_modules__)\n__webpack_require__.m = __webpack_modules__;\n\n","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = (module) => {\n\tvar getter = module && module.__esModule ?\n\t\t() => (module['default']) :\n\t\t() => (module);\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","__webpack_require__.j = 925;","// no baseURI\n\n// object to store loaded and loading chunks\n// undefined = chunk not loaded, null = chunk preloaded/prefetched\n// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded\nvar installedChunks = {\n\t925: 0\n};\n\n// no chunk on demand loading\n\n// no prefetching\n\n// no preloaded\n\n// no HMR\n\n// no HMR manifest\n\n__webpack_require__.O.j = (chunkId) => (installedChunks[chunkId] === 0);\n\n// install a JSONP callback for chunk loading\nvar webpackJsonpCallback = (parentChunkLoadingFunction, data) => {\n\tvar [chunkIds, moreModules, runtime] = data;\n\t// add \"moreModules\" to the modules object,\n\t// then flag all \"chunkIds\" as loaded and fire callback\n\tvar moduleId, chunkId, i = 0;\n\tif(chunkIds.some((id) => (installedChunks[id] !== 0))) {\n\t\tfor(moduleId in moreModules) {\n\t\t\tif(__webpack_require__.o(moreModules, moduleId)) {\n\t\t\t\t__webpack_require__.m[moduleId] = moreModules[moduleId];\n\t\t\t}\n\t\t}\n\t\tif(runtime) var result = runtime(__webpack_require__);\n\t}\n\tif(parentChunkLoadingFunction) parentChunkLoadingFunction(data);\n\tfor(;i < chunkIds.length; i++) {\n\t\tchunkId = chunkIds[i];\n\t\tif(__webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId]) {\n\t\t\tinstalledChunks[chunkId][0]();\n\t\t}\n\t\tinstalledChunks[chunkId] = 0;\n\t}\n\treturn __webpack_require__.O(result);\n}\n\nvar chunkLoadingGlobal = self[\"webpackChunk\"] = self[\"webpackChunk\"] || [];\nchunkLoadingGlobal.forEach(webpackJsonpCallback.bind(null, 0));\nchunkLoadingGlobal.push = webpackJsonpCallback.bind(null, chunkLoadingGlobal.push.bind(chunkLoadingGlobal));","// startup\n// Load entry module and return exports\n// This entry module depends on other loaded chunks and execution need to be delayed\nvar __webpack_exports__ = __webpack_require__.O(undefined, [121,223,806,76], () => (__webpack_require__(6241)))\n__webpack_exports__ = __webpack_require__.O(__webpack_exports__);\n"],"names":["deferred","extendStatics","__extends","d","b","Object","setPrototypeOf","__proto__","Array","p","prototype","hasOwnProperty","call","TypeError","String","__","this","constructor","create","_super","KeyboardButtonRepeatMonitor","_this","RECENT_PRESS_COUNT","MIN_SAME_BUTTON_COUNT","TRACKING_WINDOW","start","pressHistory","handlePress","event","label","target","HTMLElement","el","id","startsWith","classList","contains","replace","parentElement","getButtonLabel","now","Date","push","timestamp","filter","entry","length","recentPresses","slice","buttonCounts","Map","_i","recentPresses_1","set","get","forEach","count","buttonLabel","trip","repeated_button","occurrences","total_recent_presses","document","addEventListener","removeEventListener","getElem","elemName","element","figure","getElement","concat","processResponse","data","answer_input","_a","_b","zoomReset","custom","resetSceneZoom","then","processResponseAfterZoom","delay","response","speech_token","exception_msg","window","location","href","origin","answerSubmitted","reloadDelay","animateMathProgress","completion_score","total_correct_answers","star_earned","reload","speech","speechManager","chunked","console","log","chunkedSpeech","hash","JSON","parse","speechOptions","require_answer","interrupt","speechId","interruptPlay","helper","guideInit","stop","interruptedState","guideStart","performance","play","show_answer","answerShown","startPlaying","result","hideBubble","enableAnswerInput","elements","hasTouchableElements","keyboard","CORRECT","stopHelper","bubble","correctMsg","math_fact_speed_test","msg","achievements","indexOf","move_fastest_ever","ever","fastest","show","showAnswerInfo","answer_info","showCorrectness","animations","new","trigger","ai","cancel_show_answer","showAnswer","resumeCountdown","resumeCountdownOnIncorrect","NEEDS_HELP","hide","DONT_KNOW","honing","INVALID","INVALID_EMPTY","INVALID_FRACTION","INVALID_REPEATER_AT_END","INVALID_REPEATER_DECIMAL","INVALID_MULTI_REPEATER","INVALID_REPEATER_DIGIT","INVALID_REPEATER_EMPTY","INVALID_POWER","INVALID_BACKWARDS","INCORRECT","TECHNICALLY_CORRECT","answer_input_1","afterDelayAnimations","afterSubmit","opacity","duration","inParallel","helperPlaying","enableInteraction","fastReload","exec","onShow","_expression","method","params","redirect","reloadRedirect","reloadFalse","force_reload","forceReload","disableInteraction","timeout_1","reloadTriggered_1","doReload_1","playFinishedCallback1","setTimeout","playStartedBefore_1","playStartedTime","_speechFallbackTimer","neverStarted","ctx","ctxDead","state","isPlaying","show_back","back_button","showAll","answer_expected","hnt","inst","expr","overrides","_hint","updateElementText","sub_answer","toString","hintOptions","scenarios","form","setScenario","showForm","_box","surround","_line","setPosition","getPosition","add","resumeCountdownAfterHint","top","xPosition","yPosition","xAlign","yAlign","offset","bottom","left","right","pulse","processHint","hint","mag","type","frequency","expression","goToForm","animate","scenario","instruction","slide","nav_1","doNextSlide_1","nav","nextSlide","loadTime","setOpacity","clear","animateNextFrame","done_1","startedPlaying_1","advance_1","clearInterval","poll_1","_slideNextPoll","_slideNextFallback","clearTimeout","_slideNextCeiling","_slideNextDoTimer","setInterval","err","errorStr","error","stringify","getOwnPropertyNames","message","filename","lineno","colno","srcElement","timeStamp","stack","Error","name","CURSOR_ID","ROOT_CLASS","Set","_gTimeouts","gSetTimeout","key","fn","gClearTimeout","MANUAL_SPEECH_ID","AUTO_SPEECH_ID","__assign","assign","t","s","i","n","arguments","apply","sendTimingToBackend","report","timerName","timedOutCheckpoint","timer_id","timerId","total_duration","totalDuration","checkpoints","timed_out_checkpoint","question_id","grokkoli_question_id","startTimer","options","_timers","startTime","lastCheckpointTime","lastCheckpointId","_activeTimerId","totalTimeoutMs","totalTimeoutId","getTimerReport","checkpoint","checkpointId","warn","fromId","fromTime","timer","fromCheckpoint","nextCheckpointTimeoutId","undefined","found","find","cp","time","delta","Math","round","elapsed","checkpointData","from","nextTimeoutMs","addData","value","stopTimer","map","threshold","hasTimer","cancelTimer","startCriticalAnimation","criticalFunc","onElement","animationElement","criticalAnimations","isAnimating","cancel","criticalAnimation","clearCriticalAnimation","AnswerResult","MESSAGE","DECISION","SLIDES","TIMEOUT","NOT_ANSWERED_NOT_NEEDED","CORRECT_STEP","CORRECT_BUT_WRONG_LOCATION","setAtlasId","font","atlasId","src","family","split","toLowerCase","style","weight","glyphs","glyphKey","isArray","sort","join","mods","modifiers","keys","h","charCodeAt","abs","sizeBracket","size","atlasSize","getCount","counter","wrapBar","content","bar","side","symbol","__bar__","lineWidth","inSize","space","EqnPhrase","parent","description","phraseOptions","cursor","defaultPhrase","isEmpty","_dup","dupParent","dup","getAllElements","elems","j","render","symbolName","out","container","color","box","leftSpace","rightSpace","topSpace","bottomSpace","summarize","summary","c","defIn","def","frac","mfrac","root","repeater","brac","pow","EqnPow","superscript","EqnBrac","EqnRepeater","EqnRoot","EqnMixedFrac","whole","numerator","denominator","EqnFrac","EqnElement","text","noDelete","equationElementName","getEquationElement","equation","order","vorder","leftSymbol","scale","frac_scale","numeratorSpace","denominatorSpace","offsetY","overhang","lineWidth2","leftSymbolName","rightSymbolName","rightSymbol","insideSpace","outsideSpace","sup","eqnFuncs","Eqn","equationElement","endCursor","phrase","cursorIndex","history","maxHistoryLength","cursorBlinkTimeout","disabled","reset","pushHistory","shift","popHistory","pop","getClosestElement","position","boxes","element_1","isShown","Fig","Point","return_element","minDistance","minIndex","r","e","getBoundingRect","distance","width","height","rect","calcLength","len","getLength","getPhraseIndex","indexToFind","index","processElement","getFraction","result_1","getVinculum","getNumerator","result_2","getDenominator","getWhole","getIndexFromElement","beforeCursorIndex","afterCursorIndex","inTargetElement","phraseIndex","boxCounter","getCursorIndexFromPhrase","getElementAtIndex","getElementAtCursor","getlastIndex","delete","elementToAdd","list","splice","getCursorPosition","getCursorPositions","down","belowPhrase","getBelowPhrase","phraseUp","vOrder","vIndex","closestElement","_c","up","abovePhrase","getAbovePhrase","phraseDown","closestElement_1","side_1","_d","isAtStart","min","isAtEnd","max","blink","init","__timeoutKeys","getPath","hideCursor","disable","setColor","enable","addForms","layoutForms","NotificationHelper","ids","notification","callback","num","notifications","cleanup","notificationName","remaining","remove","Notification","subscribers","nextId","numberOfPublications","publish","functionArgument","asArray","subscribersToRemove","publishOk","subscirberId","NotificationManager","eventName","payload","subscriberId","subscription","getSceneZoomTelemetry","used","current","countSinceReload","__spreadArray","to","pack","ar","l","pageSnapshot","_e","_f","visibility","visibilityState","focused","hasFocus","online","navigator","onLine","audio_session_state","audioSession","user_agent","userAgent","user_activation_active","userActivation","isActive","user_activation_ever","hasBeenActive","speechFetchSnapshot","url","attempts","ssml_hash","match","load_timer","connection","effectiveType","rtt","downlink","saveData","getEntriesByName","entries","latest_resource_timing","start_ms","duration_ms","detail_available","responseStart","dns_ms","domainLookupEnd","domainLookupStart","connect_ms","connectEnd","connectStart","ttfb_ms","requestStart","response_ms","responseEnd","transfer_size","transferSize","diagnostic_snapshot_unavailable","notifyAudioFailed","audioFailed","RETRY_ATTEMPT_TIMEOUTS_MS","RETRY_BACKOFF_MS","retryDelay","attemptNum","base","random","attemptTimeoutMs","attemptTimeoutsUsed","isRetryable","status","getVoice","voice","voices","speechSynthesis","getVoices","bestVoices","lang","makeSpeechManager","speechMessage","speechRect","make","line","speechArrow","tail","tailWidth","defaultArrowOptions","arrow","move","toFront","regexMetaChars","_speechGeneration","speechGeneration","currentAudio","chunkIndex","chunkDelayDone","chunkDelayStart","chunkDelayRemaining","timeStart","playDuration","completeCount","startCount","useCaptions","actionIndex","initialActionIndex","actionTimeoutId","captionIndex","captionTimeoutId","delayTimeoutId","playbackRate","showArrow","pulseElement","executeAction","offlineSpeech","maxSeek","seekPosition","freeze","toPlayButton","toPauseButton","soundCtx","_soundBuffers","_soundPreloadQueue","_currentSoundSource","rate","showContinueOnEnd","FETCH_LANE_CAPACITY","mp3","marks","fetchesInFlight","fetchQueues","isMainSpeech","sw","_stallWatchdogId","_stallLastProgressAt","resetSpeechStats","removeFromState","names","removeFromObj","parts","obj","figureState","clearCachedSpeech","allSpeech","currentId","cached_speech","audio","_audioLoading","stamps","captionStamps","onLoad","speechTimerSeq","loadTimerParts","sharedAudio","sharedMarks","numSeeks","seekCount","initial_actions","seek","numActions","actions","getNumSeeks","getPlayDuration","cancelCaptions","startCaptions","playFinished","stopFigure","stopPlaying","playChunk","totalMarksCount","chunk","segments","caption_segments","captionMarks","cachedSpeechUrls","cached","Number","isFinite","_expiresAt","urls","isCaptionMark","mark","test","actionStamps","m","speechLoaded","speechLoadedCallback","SPEECH_BATCH_RAMP","SPEECH_BATCH_STEADY","pause","currentTime","getCurrentTime","getState","cancelActions","resume","ensureAudioContext","isStaleGeneration","setState","how","catch","autoResume","resumeFrom","onInterruptStart","onInterruptEnd","wasPlaying","playFinishedCallback2","playFinishedCallback3","preloadSound","AudioContext","webkitAudioContext","fetchAndDecodeSoundAudio","playSound","chunks","Promise","resolve","ensureSoundContext","buffer","source_1","createBufferSource","connect","destination","_playSoundWhenReady","visibilityHandler","hidden","suspendWhileHidden","soundState","_docListeners","handler","resetFailedChunk","resetFailedChunks","adoptSpeechLoads","stopStallWatchdog","lastChunkIndex","lastCurrentTime","hasMadeProgress","_g","_h","waitingChunk","waitingOnLoad","totalChunks","recovered","manager","ssmlHash","_j","_k","_l","_m","_o","_p","_q","_r","_s","_t","_u","_v","_w","_x","audioTime","_y","speech_id","chunk_index","total_chunks","current_audio_is_chunk","audio_origin","sound_ctx_state","delay_pending","start_count","ms_since_last_progress","ctx_state","ctx_time_ms","source_ctx_state","source","context","source_ctx_time_ms","source_present","source_started_at_ctx_ms","contextStartTime","audio_start_time","audio_pause_time","pauseTime","audio_state","chunk_audio_state","chunk_audio_loading","marks_state","audio_current_time","audio_buffer_duration","is_playing","interrupted_state","load_timer_scope","_z","speechStallSnapshot","ssml","hashSSML","loadToken","abortCurrentSpeechLoads","startStallWatchdog","playInner","hideHighlightElements","speechChunks","speechLoadingIcon","display","_pendingAutoSpeakNotification","isChunkFailed","loadAudio","resumePlayChunkTimeoutId","updateSeekEnabled","updateSeekPosition","getSeekActions","seekOverride","seekActions","_formReview","playFormReviewSpeech","formStepIndex","advanceToNextForm","resumeFormReviewSpeech","debugChunk","debugNextChunk","debugPrevChunk","sp","COMMENT_NAME_STYLE","COMMENT_STYLES","When","Story","Note","COMMENT_SECTION","COMMENT_LABEL","debugGuide","guide_id","submitted_answer","getSubmittedAnswer","enteredAnswer","slots","RNR","CLOCK","sub_ans","getAnswerInput","_answer_input","manips","manipulativeType","full","partial","sub_ans_obj","used_tiles","elementNames","elementName","request","guide_name","guides","comments","guide","comment","prev","title","commentToConsole","withoutNameHeading","toConsole","playingCommentToConsole","speechTextToConsole","chunked_speech","guide_hash","collectFormsFromAction","action","steps","formsFromChunks","a","logForms","f","fetchGuideChunks","arg","onChunks","debugForms","groups","results","seen","walk","has","eqn","forms","k","g","summarizeAction","o","parseSsmlItems","items","body","clean","trim","re","last","parseInt","lastIndex","SPEECH_STYLE","ACTION_STYLE","META_STYLE","FORM_STYLE","summarizeChunks","item","segment","caption","debugSpeech","default","chunkSpokenText","chunkCaptionText","leadingSpace","splitSentences","end","sentence","fmtTime","floor","sec","toFixed","debugCursor","isCurrentAudio","delayElapsed","inDelay","chunkDuration","before","beforeKnown","total","totalKnown","fraction","anchors","name_2","stamp","pos","t0","o0","t1","o1","chunkFractionAt","sentences","at","sentenceIndex","formElements","currentForm","playing","chunkTime","elapsedIsLowerBound","totalIsLowerBound","sentencesInChunk","chunkCaption","formNames_1","printTranscript","chunkStarts","formMarks","formLabel","chunkStart","initial_1","markOffsets","spokenLength","marked","back","fwd","fmt","reduce","acc","si","marker","lo","hi","Infinity","inSentence","args","piece","debugTranscript","sc","st","testGuide","playAll","phrases","i_3","debugHelperGuide","rand_indexes","speeches","info","cleaned","say","currentDebugIndex","checkGuides","errors","debugSpeechDefs","idx","getGuides","captions","createElement","createTextNode","appendChild","getElementById","updateCaption","newCaption","nodeValue","showCaptions","hideCaptionsTimeoutId","hideCaptions","makeCaptions","speechDebounce","speechKeyHandler","releaseTraining","numSeek","seekSpaceEM","widthEM","endSpaceEM","seekTouch","endSpacePercent","seekPercent","seekContainer","seekDiv","seekBar","seekBarEnabled","seekBarCurrent","seekPoints","seekPoint","normP","offsetX","offsetWidth","index_in","percentTime","getElementsByClassName","createSeekBar","preloadQueue","preloadInProgress","getSpeech","preload","prioritize","pathname","handleSpeechReady","playSpeech","preloadSpeech","direction","setRotation","PI","dissolveOut","drawOrder","highlightElement","ensureArrowElement","arrowElement","getElements","hideHighlight","hideOptions","defaultElement","defaultHideOptions","FigTools","joinObjects","hideElement","addClassToElements","className","stopAnimation","arr","some","elem","collection","pattern","prefix","substring","_instruction","regex","RegExp","matched","name_1","child","expandWildcardElements","expression_elements","function_elements","getFunctionElements","numeratorElements","denominatorElements","wholeElements","fractionElements","fractionElement","_workPad","getAllMapNames","mapNames","i_1","mapName","snappedElements","getMap","getSnappedTiles","getInputTiles","inputTiles","i_2","toPulse","p1","pointFromSpaceToSpace","y","translation","angle","execMethodOnElements","elemNames","helpers","dontKnow","defaults","fill","fillOptions","fillElement","corner","radius","sides","toBack","txt","drawingObject","parsePoint","spaceLeft","spaceRight","spaceBottom","spaceTop","fillPosition","x","fillWidth","fillHeight","fillColor","initialWidth","initialHeight","newP","w","updatePoints","dissolveIn","showFill","showContinue","v","spulse","vpulse","stop_1","vpulseCustom","stop_2","dotIndex","param","figureWP","targets","pulseTarget","hpulse","stop_3","step_vpulse","stop_4","cumDelay","step","stepDuration","stepDelay","arrowDefaults","arrowCustom","arrowOptions","savedDefaults","customElems","elementName_1","arrowPosition","arrowRotation","getRotation","arrowColor","rotation","showArrowNew","hideElem","showElemNames","showElem","showElemBounds","showElemPosition","toElem","toElemBounds","center","pLocal","hide_bubble","html","hide_unsnapped","hideParent_1","duration_1","hideIfUnsnapped_1","slot","snappedSlot","snappedFillSlot","isSnapped","answerContainers","isTouchable","disableForm","arrangeTile","force","show_unsnapped","showParent_1","duration_2","hide_keyboard","hideKeyboard","show_keyboard","showKeyboard","hide_answerinput","show_answerinput","disable_interactions","enable_interactions","anim","_loop_1","elementsToStop","stopElem","initialPosition","readyPosition","elementsToKeepTransparent","slotPosition","animId","_loop_2","_loop_3","act","continue","addClass","class","removeClass","clearTimeouts","__clearTimeouts","play_continue","playContainer","goto","getSpeechStats","startFetch","kind","audios","_isPreload","leaveSharedWaits","queue","promoted","unshift","_leaveSharedWait","_leaveSharedMarksWait","isActiveSpeechAudio","makeFetchSlot","yieldSlot","acquire","inFlight","findIndex","victim","acquireFetchSlot","release","next","releaseFetchSlot","sid","loadTimerOpen","finishLoadTimerPart","cancelLoadTimer","speechFileKey","sharedLeadFor","shared","owner","lead","done","leadSharedLoad","settle","reject","promise","res","rej","failSharedLoad","makeAudio","matchResult","onEnd","urlSimple","playBuffer","atTime","notPaused","helper_1","audioFailedShown","clearAudioFailed","disconnect","load","tokenValid","fileKey","setLoaded","fetchOwn","own","stillValid","attemptHistory","releaseSlot","yielded","attempt","controller","AbortController","didTimeout","timeoutId","abort","respStatus","readingBody","fetch","signal","resp","ok","statusText","arrayBuffer","buf","byteLength","_grokkoli_silent_log","decodeAudioData","bufMsg","numberOfChannels","sampleRate","decode","errorData","every","waiting_1","stopWaiting_1","was","flushPendingActions","currentChunkOnly","tryRun","_","_initialActionsFired","futureSpeech","nextAction","indexStr","__load_1","markTime","timeBuffer","nextCaption","due","playActions","saved","numChunks","targetChunk","targetTime","targetAction","rf","flushCaptions","isChunkReady","playNextChunk","playFrom","if_shown","elems_def","getMarks","marksURL","handleResponse","check","setMarks","httpStatus","parseFailed","marks_raw","parseMarks","handleExhaustion","nowPreload","waiting_2","stopWaiting_2","makeChunkOnEnd","forSpeechId","pending","useCached","batch","precedingChunks","speechBatchSize","marks_count","speechTimerId","receiveUrls","_loop_4","urlPair","audioURL","audioHash","chars","chunk_chars","openLoadTimer","speech_chunks","_soundFetching","copy","decodeSoundBuffer","suspend","inUse","cancelSpeech","seekTime","seekAction","currentSeekIndex","seekFound","processFormAction","review","getFormSteps","startIndex","nextFormStepIndex","clamped","runAll","initial","isMarked","indent","format","section","sectionMatch","guideName","lines","preloadAudio","processPreloadQueue","loadNextChunk","currentChunkIndex","cachedUrls","hideHelperBubble","makeOfflineSpeech","seekIndex","setupSeekActions","timePlayed","playTime","fastForward","fastForwardDuration","speechTimeout","something","to_say","SpeechSynthesisUtterance","started","speechTime","speechMsgIndex","sayNext","speak","fastForwardTimerId","specialTags","sayFastForward","saySpeech","initialDelay","offlineSpeechKeyHandler","nextSpeech","end_if_shown","module","exports","React","ReactDOM","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","__webpack_modules__","O","chunkIds","priority","notFulfilled","fulfilled","getter","__esModule","definition","defineProperty","enumerable","prop","installedChunks","chunkId","webpackJsonpCallback","parentChunkLoadingFunction","moreModules","runtime","chunkLoadingGlobal","self","bind","__webpack_exports__"],"sourceRoot":""}