@intellectif/lk-react 23.1.0 → 23.1.2

package/dist/Dictation-jECzL88E.cjs

@@ -0,0 +1,931 @@
+'use client';
+const require_ai_LkAiProvider = require("./ai/LkAiProvider.cjs");
+const require_useAiHelp = require("./useAiHelp-h9yOLFqt.cjs");
+const require_LkIntlProvider = require("./LkIntlProvider-oi57lYB0.cjs");
+const require_ActivityErrorBoundary = require("./ActivityErrorBoundary-B379hvtL.cjs");
+const require_hooks_useActivityState = require("./hooks/useActivityState.cjs");
+const require_direction = require("./direction-K1pj0HCA.cjs");
+const require_ActivityMedia = require("./ActivityMedia-CQQTRNl7.cjs");
+const require_tries = require("./tries-CbbtZkdG.cjs");
+const require_FeedbackRegion = require("./FeedbackRegion-BNNMtTY-.cjs");
+let react = require("react");
+let react_jsx_runtime = require("react/jsx-runtime");
+let _intellectif_lk_core = require("@intellectif/lk-core");
+//#region src/components/Dictation/Dictation.tsx
+/** How long the learner has to stop typing before one `text-changed` is emitted. */
+const TEXT_CHANGED_DEBOUNCE_MS = 500;
+/**
+* Present for assistive technology, invisible on screen. Inline rather than
+* left to the optional skin: the per-word sentences are the marks' only
+* channel for a screen reader, and without this a page that does not load the
+* skin would show every one of them beside its word.
+*/
+const VISUALLY_HIDDEN = {
+	position: "absolute",
+	width: 1,
+	height: 1,
+	margin: -1,
+	padding: 0,
+	overflow: "hidden",
+	clip: "rect(0 0 0 0)",
+	clipPath: "inset(50%)",
+	whiteSpace: "nowrap",
+	border: 0
+};
+/**
+* Names playback groups. Per mount and never derived from `useId`: two
+* separately hydrated roots derive the same id for the same tree position, and
+* their recordings would pause each other. The name never reaches the DOM.
+*/
+let recordingsGroupCount = 0;
+/**
+* A token with nothing spelled in it, as the scorer reads it once composed:
+* only punctuation, control, format and default-ignorable characters, the acute
+* accent, grave accent (and its fullwidth form) and modifier apostrophe the
+* scorer folds into an apostrophe, and the Arabic tatweel and N'Ko lajanyalan
+* it removes.
+*/
+const UNSPELLED_RE = new RegExp(`^[\\p{P}\\p{Cc}\\p{Cf}\\p{Default_Ignorable_Code_Point}${String.fromCodePoint(180, 96, 65344, 700, 1600, 2042)}]*$`, "u");
+/**
+* Spacing as the scorer reads it: whitespace and NEXT LINE — but not the
+* byte-order mark, which JavaScript counts as whitespace and the scorer
+* removes as a format character, joining the letters on either side.
+*/
+const HINT_SPACE_RE = new RegExp(`(?:(?!${String.fromCodePoint(65279)})\\s|${String.fromCodePoint(133)})+`, "u");
+/** A title with something in it a screen reader can say. */
+const VISIBLE_TEXT_RE = /[^\p{White_Space}\p{Cc}\p{Cf}\p{Default_Ignorable_Code_Point}]/u;
+const BULLET = "•";
+const LEFT_TO_RIGHT_MARK = String.fromCodePoint(8206);
+const RIGHT_TO_LEFT_MARK = String.fromCodePoint(8207);
+/**
+* Code points a font draws onto the character before them rather than beside
+* it — combining marks (variation selectors among them), the joiners, emoji
+* skin tones, tag characters, the vowel and final jamo of an old Hangul
+* syllable, and the Thai and Lao SARA AM, whose ring the font sets on the
+* consonant before — so their own span can have no width to decorate.
+*/
+const EXTENDING_RE = new RegExp(`^[\\p{M}${String.fromCodePoint(8204, 8205, 3635, 3763)}${String.fromCodePoint(127995)}-${String.fromCodePoint(127999)}${String.fromCodePoint(917536)}-${String.fromCodePoint(917631)}${String.fromCodePoint(4448)}-${String.fromCodePoint(4607)}${String.fromCodePoint(55216)}-${String.fromCodePoint(55295)}]$`, "u");
+/**
+* Viramas that stack the letter after them into one glyph without asking —
+* Devanagari, Bengali, Gujarati, Oriya, Telugu, Kannada and Malayalam, the
+* Burmese stacker, the Khmer coeng, and the Tai Tham, Balinese, Javanese,
+* Chakma and Brahmi signs. Not the Tamil, Gurmukhi or Sinhala virama, which is
+* drawn visibly and leaves most letters after it on their own.
+*/
+const STACKING_VIRAMAS = new Set([
+	2381,
+	2509,
+	2765,
+	2893,
+	3149,
+	3277,
+	3405,
+	4153,
+	6098,
+	6752,
+	6980,
+	43456,
+	69702,
+	69939
+].map((point) => String.fromCodePoint(point)));
+/**
+* The letters a visible virama still draws into the letter before it: the
+* Gurmukhi RA, YA and VA, which fonts set under the consonant, and the Tamil
+* conjuncts KSSA (க்ஷ) and SHRII (ஸ்ரீ), which fonts draw as one glyph —
+* each keyed by its letter, virama and the letter before the virama.
+*/
+const SUBJOINED_AFTER = new Map([
+	...[
+		2608,
+		2607,
+		2613
+	].map((point) => [String.fromCodePoint(point), (before) => before.at(-1) === String.fromCodePoint(2637)]),
+	[String.fromCodePoint(2999), (before) => before.at(-1) === String.fromCodePoint(3021) && before.at(-2) === String.fromCodePoint(2965)],
+	[String.fromCodePoint(2992), (before) => before.at(-1) === String.fromCodePoint(3021) && before.at(-2) === String.fromCodePoint(3e3)]
+]);
+/** Viramas after which a zero-width joiner asks for a conjunct: every stacking one, and the Sinhala. */
+const JOINABLE_VIRAMAS = /* @__PURE__ */ new Set([...STACKING_VIRAMAS, String.fromCodePoint(3530)]);
+const ZERO_WIDTH_JOINER = String.fromCodePoint(8205);
+/**
+* Characters the font draws into the letter after them: MALAYALAM LETTER DOT
+* REPH, set on the consonant after it, and the MONGOLIAN VOWEL SEPARATOR, which
+* has no width of its own and changes the shape of the vowel after it.
+*/
+const PREPENDED = /* @__PURE__ */ new Set([String.fromCodePoint(3406), String.fromCodePoint(6158)]);
+const ARABIC_LAM = String.fromCodePoint(1604);
+/** The alefs a lam before them fuses with into one glyph, in every Arabic font. */
+const LIGATING_ALEFS = new Set([
+	1570,
+	1571,
+	1573,
+	1575,
+	1649,
+	1650,
+	1651,
+	1653
+].map((point) => String.fromCodePoint(point)));
+const REGIONAL_INDICATOR_RE = /^[\u{1f1e6}-\u{1f1ff}]$/u;
+const LETTER_RE = /^\p{L}$/u;
+/** A letter of any script but Latin, Greek or Cyrillic, whose common ligatures are only decorative. */
+const LETTER_WITH_REQUIRED_LIGATURES_RE = /(?![\p{Script=Latin}\p{Script=Greek}\p{Script=Cyrillic}])\p{L}/u;
+const DIGIT_RE = /^\p{Nd}$/u;
+/**
+* Signs laid out with the European number beside them (bidirectional class
+* ET): the currency signs, the degree, plus-minus and per-mille signs.
+*/
+const NUMBER_SIGN_RE = new RegExp(`^[\\p{Sc}${String.fromCodePoint(176, 177, 8240, 8241, 8494, 8723)}]$`, "u");
+/** Letters of the Arabic, Syriac and Thaana blocks and their presentation forms: before them, a European number is not one. */
+const ARABIC_LETTER_BLOCKS = [
+	[1536, 1983],
+	[2144, 2303],
+	[64336, 65023],
+	[65136, 65279]
+];
+/**
+* The text out of a `LearnerResponse`. A response of another activity type
+* reads as nothing typed rather than throwing — a controlled host that has not
+* yet swapped its state on an activity change would otherwise crash the attempt.
+*/
+function textOf(response) {
+	return response !== void 0 && response.type === "dictation" ? response.text : "";
+}
+/** The hint count out of a `LearnerResponse`; absent or another type reads as none. */
+function hintsOf(response) {
+	if (response === void 0 || response.type !== "dictation") return 0;
+	const revealed = response.hintsRevealed;
+	return typeof revealed === "number" && Number.isInteger(revealed) && revealed > 0 ? revealed : 0;
+}
+/** The response this component emits; `hintsRevealed` is written only when there is one. */
+function responseOf(text, hintsRevealed) {
+	return {
+		type: "dictation",
+		text,
+		...hintsRevealed > 0 ? { hintsRevealed } : {}
+	};
+}
+/**
+* The slower recording as an `ActivityMedia`: it follows the recording's
+* playback policy minus `maxPlays` (`controls`, `seek`, `rate`, the native
+* hints), so a locked scrubber or a fixed speed binds both files — and it never
+* carries a budget of its own, so `<ActivityMedia>` never demands a binding
+* for it. `undefined` when there is no slow recording.
+*/
+function slowMediaFor(data, label) {
+	const slow = data.slowMedia;
+	if (slow === void 0) return;
+	const { maxPlays: _budget, ...inherited } = data.media?.playback ?? {};
+	const hasPolicy = Object.values(inherited).some((value) => value !== void 0);
+	return {
+		type: "audio",
+		url: slow.url,
+		alt: slow.alt ?? label,
+		...hasPolicy ? { playback: inherited } : {}
+	};
+}
+/**
+* The transcript's words as a learner would read them: raw, in order, split at
+* whitespace. A token with nothing in it that is spelled — a dash, an ellipsis
+* — is joined to the word before it (or to the first word, when it leads), so
+* every reveal shows a word. A script written without spaces is one token, so
+* one reveal shows the whole sentence.
+*/
+function hintWordsOf(transcript) {
+	const words = [];
+	let leading = "";
+	for (const token of transcript.split(HINT_SPACE_RE)) {
+		if (token === "") continue;
+		const last = words.length - 1;
+		if (!UNSPELLED_RE.test(token.normalize("NFC"))) {
+			words.push(leading === "" ? token : `${leading} ${token}`);
+			leading = "";
+		} else if (last >= 0) words[last] = `${words[last]} ${token}`;
+		else leading = leading === "" ? token : `${leading} ${token}`;
+	}
+	return words;
+}
+/**
+* Word marks rebuilt from stored scoring details — a server-recorded mark
+* shown after an exam, with no transcript on the client. Extras are not in the
+* details (the scorer writes one per transcript word), so none appear.
+*/
+function wordsFromDetails(details) {
+	if (details.length === 0 || !details.every((detail) => /^w\d+$/.test(detail.itemId))) return null;
+	return details.map((detail) => {
+		const attempt = Array.isArray(detail.learnerResponse) ? detail.learnerResponse.join(" ") : detail.learnerResponse;
+		const reference = Array.isArray(detail.correctResponse) ? detail.correctResponse.join(" ") : detail.correctResponse;
+		const correct = require_useAiHelp.detailIsRight(detail);
+		const missing = detail.outcome === "incorrect-omission" || !correct && attempt === "";
+		return {
+			itemId: detail.itemId,
+			reference,
+			attempt,
+			similarity: detail.score ?? (correct ? 1 : 0),
+			status: correct ? "correct" : missing ? "missing" : "incorrect"
+		};
+	});
+}
+/**
+* Whether `shown`, the character an operation displays, is drawn into the
+* cluster whose characters so far are `before`: a mark, a joiner or a skin tone
+* onto its base, a letter stacked under a virama, an alef fused with the lam
+* before it, the second half of a flag.
+*/
+function extendsCluster(before, shown) {
+	const previous = before.at(-1);
+	if (EXTENDING_RE.test(shown)) return true;
+	if (LETTER_RE.test(shown)) {
+		if (STACKING_VIRAMAS.has(previous) || PREPENDED.has(previous) || SUBJOINED_AFTER.get(shown)?.(before) === true) return true;
+		if (previous === ZERO_WIDTH_JOINER && JOINABLE_VIRAMAS.has(before.at(-2))) return true;
+	}
+	if (previous === ARABIC_LAM && LIGATING_ALEFS.has(shown)) return true;
+	return REGIONAL_INDICATOR_RE.test(shown) && before.length % 2 === 1 && before.every((character) => REGIONAL_INDICATOR_RE.test(character));
+}
+/** The character an operation stands for: what should have been typed, or what was typed in excess. */
+function characterOf(op) {
+	return op.reference === "" ? op.attempt : op.reference;
+}
+function isArabicLetter(character) {
+	const point = character?.codePointAt(0);
+	return point !== void 0 && LETTER_RE.test(character) && ARABIC_LETTER_BLOCKS.some(([first, last]) => point >= first && point <= last);
+}
+/**
+* The directions missing characters' bullets are laid out in, by operation
+* index, worked out in two passes over the operations rather than a search
+* per bullet: a word of 2,000 emoji missing its letters took seconds to draw.
+*
+* A bullet takes the character's own direction when it has one — a digit runs
+* left to right, unless it is a digit of a right-to-left script. A currency,
+* degree or per-mille sign beside a digit is laid out with that number, left to
+* right, unless an Arabic letter comes before it, after which the number is not
+* a European one. Otherwise, for a space or a punctuation mark, it takes the
+* direction of the characters on both sides when they agree, and the content's
+* when they do not. A bare bullet is a neutral, which the bidirectional
+* algorithm would otherwise attach to the wrong side of a number or a word of
+* the other direction.
+*/
+function bulletDirections(ops, contentDir) {
+	const own = ops.map((op) => require_direction.characterDirectionOf(characterOf(op)));
+	const before = [];
+	const arabicBefore = [];
+	let lastDirection;
+	let lastLetterArabic = false;
+	ops.forEach((op, index) => {
+		before[index] = lastDirection;
+		arabicBefore[index] = lastLetterArabic;
+		lastDirection = own[index] ?? lastDirection;
+		if (LETTER_RE.test(characterOf(op))) lastLetterArabic = isArabicLetter(characterOf(op));
+	});
+	const after = [];
+	let nextDirection;
+	for (let index = ops.length - 1; index >= 0; index -= 1) {
+		after[index] = nextDirection;
+		nextDirection = own[index] ?? nextDirection;
+	}
+	const directions = /* @__PURE__ */ new Map();
+	ops.forEach((op, index) => {
+		if (op.op !== "missing") return;
+		const neighbourIsDigit = [ops[index - 1], ops[index + 1]].some((neighbour) => neighbour !== void 0 && DIGIT_RE.test(characterOf(neighbour)));
+		directions.set(index, own[index] ?? (NUMBER_SIGN_RE.test(characterOf(op)) && neighbourIsDigit && !arabicBefore[index] ? "ltr" : before[index] !== void 0 && before[index] === after[index] ? before[index] : contentDir ?? before[index] ?? after[index]));
+	});
+	return directions;
+}
+/**
+* How a cluster is marked. One led by a missing character's bullet is missing,
+* whatever marks sit on the bullet: the character they belong to is not there.
+* Otherwise a cluster is marked as its wrong operations are when they agree —
+* a correct letter with an extra mark is `extra` — and as a substitution when
+* they do not.
+*/
+function clusterOpOf(ops) {
+	if (ops[0].op === "missing") return "missing";
+	const wrong = new Set(ops.map((op) => op.op).filter((kind) => kind !== "equal"));
+	if (wrong.size === 0) return "equal";
+	return wrong.size === 1 ? [...wrong][0] : "substitute";
+}
+/**
+* Character operations grouped into what is drawn as one cluster, so a wrong
+* combining mark, joiner or stacked letter marks the glyph it is drawn into —
+* alone, its span has no width, and its underline or strike would not be
+* painted at all. A missing character's bullet carries only the marks drawn
+* onto it, never a letter that is drawn apart. A missing character's bullet is
+* wrapped in the direction mark of the character it stands for. Consecutive
+* correct clusters are one run: an engine that shapes each element on its own
+* would otherwise draw a correctly typed conjunct or a joined Mongolian word
+* broken apart.
+*/
+function clustersOf(ops, contentDir) {
+	const bullets = bulletDirections(ops, contentDir);
+	const groups = [];
+	ops.forEach((op, index) => {
+		const shown = op.op === "missing" ? BULLET : op.attempt;
+		const current = groups.at(-1);
+		if (current !== void 0 && op.op !== "missing" && (current.ops[0].op === "missing" ? EXTENDING_RE.test(shown) : extendsCluster(current.shown, shown))) {
+			current.ops.push(op);
+			current.shown.push(shown);
+			return;
+		}
+		const direction = bullets.get(index);
+		groups.push({
+			ops: [op],
+			shown: [shown],
+			...direction !== void 0 ? { bullet: direction } : {}
+		});
+	});
+	const clusters = [];
+	for (const group of groups) {
+		const mark = group.bullet === void 0 ? "" : group.bullet === "rtl" ? RIGHT_TO_LEFT_MARK : LEFT_TO_RIGHT_MARK;
+		const cluster = {
+			op: clusterOpOf(group.ops),
+			text: `${mark}${group.shown.join("")}${mark}`
+		};
+		const previous = clusters.at(-1);
+		if (previous !== void 0 && previous.op === "equal" && cluster.op === "equal") previous.text += cluster.text;
+		else clusters.push(cluster);
+	}
+	return clusters;
+}
+/**
+* Character-level edit operations as decoration. Hidden from assistive
+* technology as a whole: a screen reader must never verbalise surrogate or
+* combining fragments one by one, and the word list already carries the
+* meaning. Sighted colour-blind and forced-colors users still get one
+* decoration per state, which the skin draws and the legend explains.
+*/
+function CharOps({ ops, contentDir }) {
+	return clustersOf(ops, contentDir).map((cluster, index) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+		className: "lk-dc-op",
+		"data-op": cluster.op,
+		...LETTER_WITH_REQUIRED_LIGATURES_RE.test(cluster.text) ? {} : { "data-ligatures": "decorative" },
+		"aria-hidden": "true",
+		children: cluster.text
+	}, index));
+}
+/**
+* The announcement, with authored feedback in its own isolated span: its
+* direction is its own, so an English "Well heard." in an Arabic interface
+* keeps its full stop at its end. Its language is not guessed — feedback may be
+* written in the interface's language or the dictation's.
+*/
+function AnnouncementText({ announcement }) {
+	if (announcement === null) return null;
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [announcement.text, announcement.feedback ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [" ", /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+		dir: "auto",
+		children: announcement.feedback
+	})] }) : null] });
+}
+function Dictation$1({ data, onComplete, onSubmit, onChange, onInteraction, value, defaultValue, defaultSubmitted, renderMode = "practice", outcome, mediaBudget, mediaStrings, strings, theme, locale, disabled, ai: aiProp, delivery, scoring }) {
+	const isExam = renderMode === "exam";
+	const isReview = renderMode === "review";
+	const s = require_LkIntlProvider.useLkStrings(strings);
+	const ai = require_ai_LkAiProvider.useLearnerAi(aiProp);
+	const policy = require_FeedbackRegion.useDeliveryPolicy(delivery);
+	const scoringPolicy = require_tries.useItemScoringPolicy(scoring);
+	const hasKey = typeof data.transcript === "string";
+	const devError = (0, react.useMemo)(() => {
+		if (!require_useAiHelp.isDevelopment()) return null;
+		if (data.redacted === true) {
+			if (hasKey) {
+				const shape = data;
+				return shape.type === "dictation" && typeof shape.id === "string" && typeof shape.title === "string" ? null : /* @__PURE__ */ new Error("Dictation received a revealed projection (redacted: true with a transcript) that is not a dictation: `type`, `id` and `title` are required.");
+			}
+			try {
+				(0, _intellectif_lk_core.assertRedacted)(data);
+				return null;
+			} catch (error) {
+				return error instanceof Error ? error : new Error(String(error));
+			}
+		}
+		const result = (0, _intellectif_lk_core.validateActivity)("dictation", data);
+		return result.success ? null : new _intellectif_lk_core.ActivitySchemaError("dictation", result.errors);
+	}, [data, hasKey]);
+	const { state, start, complete, getTimeSpent, reset } = require_hooks_useActivityState.useActivityState(defaultSubmitted === true ? "completed" : "idle");
+	const tries = require_tries.useTries({
+		policy: scoringPolicy,
+		graded: renderMode === "practice" && policy.feedback,
+		submitted: state === "completed",
+		disabled: disabled === true
+	});
+	const resetTries = tries.reset;
+	const isControlled = value !== void 0;
+	const [internalText, setInternalText] = (0, react.useState)(() => textOf(defaultValue));
+	const [internalRevealed, setInternalRevealed] = (0, react.useState)(() => hintsOf(defaultValue));
+	const [result, setResult] = (0, react.useState)(null);
+	const [summary, setSummary] = (0, react.useState)(null);
+	const [solutionShown, setSolutionShown] = (0, react.useState)(false);
+	const formRef = (0, react.useRef)(null);
+	const feedbackRef = (0, react.useRef)(null);
+	const focusAfterRef = (0, react.useRef)(null);
+	const text = isControlled ? textOf(value) : internalText;
+	const revealed = isControlled ? hintsOf(value) : internalRevealed;
+	const defaultValueRef = (0, react.useRef)(defaultValue);
+	(0, react.useEffect)(() => {
+		defaultValueRef.current = defaultValue;
+	}, [defaultValue]);
+	const defaultSubmittedRef = (0, react.useRef)(defaultSubmitted);
+	(0, react.useEffect)(() => {
+		defaultSubmittedRef.current = defaultSubmitted;
+	}, [defaultSubmitted]);
+	const lastDataRef = (0, react.useRef)(data);
+	(0, react.useEffect)(() => {
+		if (lastDataRef.current === data) return;
+		lastDataRef.current = data;
+		setInternalText(textOf(defaultValueRef.current));
+		setInternalRevealed(hintsOf(defaultValueRef.current));
+		setResult(null);
+		setSummary(null);
+		setSolutionShown(false);
+		resetTries();
+		reset(defaultSubmittedRef.current === true ? "completed" : "idle");
+	}, [
+		data,
+		reset,
+		resetTries
+	]);
+	const textChangedRef = (0, react.useRef)(null);
+	(0, react.useEffect)(() => () => {
+		if (textChangedRef.current !== null) clearTimeout(textChangedRef.current.timer);
+	}, []);
+	const revealButtonRef = (0, react.useRef)(null);
+	const ids = (0, react.useId)();
+	const hintId = `${ids}-hint`;
+	const titleId = `${ids}-title`;
+	const solutionId = `${ids}-solution`;
+	const [recordingsGroup] = (0, react.useState)(() => {
+		recordingsGroupCount += 1;
+		return `lk-dc-recordings-${recordingsGroupCount}`;
+	});
+	const slowMedia = (0, react.useMemo)(() => slowMediaFor(data, s.dictationSlowRecording), [data, s.dictationSlowRecording]);
+	(0, react.useEffect)(() => {
+		const target = focusAfterRef.current;
+		if (target === null) return;
+		focusAfterRef.current = null;
+		if (target === "answer") formRef.current?.querySelector("textarea")?.focus();
+		else feedbackRef.current?.focus();
+	});
+	if (devError) throw devError;
+	if (data.redacted === true && renderMode === "practice") throw new Error(`Dictation "${data.id}" received redacted activity data in renderMode "practice", which grades locally and has no answer key to grade against. Render redacted data with renderMode="exam" (server grades) or "review" (pass \`outcome\`).`);
+	const submitted = state === "completed";
+	const inactive = disabled === true || submitted || isReview;
+	const marking = (isReview ? outcome?.status === "scored" : !isExam && submitted) && policy.feedback;
+	const solutionsShown = policy.solutions && !tries.open;
+	const transcript = isExam || !hasKey ? void 0 : data.transcript;
+	const hintWords = (0, react.useMemo)(() => transcript === void 0 ? [] : hintWordsOf(transcript), [transcript]);
+	const hintsOffered = policy.hints && data.hints?.mode === "progressive-words" && !isExam && !isReview && transcript !== void 0;
+	const hintsEnabled = hintsOffered && !submitted;
+	const hintTotal = hintWords.length;
+	const hintsShown = Math.min(revealed, hintTotal);
+	const reportedHints = hintsOffered ? hintsShown : 0;
+	const fireInteraction = (type, payload) => {
+		onInteraction?.({
+			type,
+			activityId: data.id,
+			timestamp: Date.now(),
+			payload
+		});
+	};
+	const flushTextChanged = () => {
+		const pending = textChangedRef.current;
+		if (pending === null) return;
+		clearTimeout(pending.timer);
+		textChangedRef.current = null;
+		fireInteraction("text-changed", { length: pending.length });
+	};
+	const handleTextChange = (next) => {
+		if (inactive) return;
+		if (state === "idle") start();
+		if (!isControlled) setInternalText(next);
+		onChange?.(responseOf(next, reportedHints));
+		if (onInteraction === void 0) return;
+		if (textChangedRef.current !== null) clearTimeout(textChangedRef.current.timer);
+		textChangedRef.current = {
+			length: next.length,
+			timer: setTimeout(() => {
+				const pending = textChangedRef.current;
+				textChangedRef.current = null;
+				if (pending !== null) fireInteraction("text-changed", { length: pending.length });
+			}, TEXT_CHANGED_DEBOUNCE_MS)
+		};
+	};
+	const setRevealed = (next) => {
+		if (!isControlled) setInternalRevealed(next);
+		onChange?.(responseOf(text, next));
+	};
+	const revealNextHint = () => {
+		if (inactive || hintsShown >= hintTotal) return;
+		if (state === "idle") start();
+		const next = hintsShown + 1;
+		setRevealed(next);
+		fireInteraction("hint-requested", {
+			revealed: next,
+			total: hintTotal
+		});
+	};
+	const resetHints = () => {
+		if (inactive || hintsShown === 0 || scoringPolicy.hintPenalty > 0) return;
+		revealButtonRef.current?.focus();
+		setRevealed(0);
+	};
+	const handleSubmit = (event) => {
+		event.preventDefault();
+		if (inactive) return;
+		const response = responseOf(text, reportedHints);
+		onSubmit?.(response);
+		flushTextChanged();
+		if (isExam) {
+			complete();
+			setSummary({
+				text: s.answerSubmitted,
+				feedback: null
+			});
+			fireInteraction("submitted", {
+				length: text.length,
+				hintsRevealed: reportedHints
+			});
+			return;
+		}
+		const answer = (0, _intellectif_lk_core.score)("dictation", data, response);
+		complete();
+		const timeSpent = getTimeSpent();
+		const counted = tries.record({
+			score: answer.score,
+			maxScore: answer.maxScore,
+			hintsRevealed: reportedHints
+		});
+		const mine = counted.tries[counted.tries.length - 1];
+		const costed = mine === void 0 ? answer.score : mine.scored;
+		const scoringResult = costed === answer.score ? answer : {
+			...answer,
+			score: costed,
+			passed: (0, _intellectif_lk_core.computePassThreshold)(data, costed)
+		};
+		const passed = counted.score === scoringResult.score ? scoringResult.passed : (0, _intellectif_lk_core.computePassThreshold)(data, counted.score);
+		const xapiStatement = _intellectif_lk_core.xAPIBuilder.buildAnsweredStatement({
+			actor: require_useAiHelp.ANONYMOUS_ACTOR,
+			object: {
+				id: require_useAiHelp.objectIdFor(data.id),
+				name: { [data.locale ?? "en-US"]: data.title },
+				...(0, _intellectif_lk_core.xapiDefinitionFor)(data)
+			},
+			scoringResult,
+			timeSpentMs: timeSpent,
+			response: response.text
+		});
+		setResult(answer);
+		onComplete?.(require_useAiHelp.stampTake({
+			score: counted.score,
+			maxScore: counted.maxScore,
+			passed,
+			timeSpent,
+			xapiStatement
+		}, require_useAiHelp.mintTake()));
+		const correctWords = answer.details.filter(require_useAiHelp.detailIsRight).length;
+		setSolutionShown(false);
+		setSummary({
+			text: `${s.answerSubmitted} ${s.scoreAnnouncement(Math.round(counted.score * 100), passed)} ${s.dictationWordsSummary(correctWords, answer.details.length)}`,
+			feedback: answer.feedback
+		});
+		fireInteraction("submitted", {
+			length: text.length,
+			hintsRevealed: reportedHints,
+			score: scoringResult.score
+		});
+	};
+	/** "Try again": the text stays, to be corrected; the marks go. Hints shown stay shown. */
+	const retry = () => {
+		reset("idle");
+		setSummary(null);
+		focusAfterRef.current = "answer";
+	};
+	/** "Show answer": no more tries; the question shows what a finished one shows. */
+	const closeTries = () => {
+		tries.close();
+		focusAfterRef.current = "feedback";
+	};
+	const given = isControlled ? value : defaultValue;
+	const hasResponse = given !== void 0 && given.type === "dictation";
+	const contentLang = typeof data.locale === "string" ? data.locale.replaceAll("_", "-") : void 0;
+	const localeDir = require_direction.localeDirectionOf(data.locale);
+	const alignment = (0, react.useMemo)(() => marking && transcript !== void 0 && (!isReview || hasResponse) ? (0, _intellectif_lk_core.alignDictation)(data, text) : null, [
+		marking,
+		transcript,
+		isReview,
+		hasResponse,
+		data,
+		text
+	]);
+	const sentenceDiff = (0, react.useMemo)(() => alignment !== null && alignment.attempt !== "" && solutionsShown ? (0, _intellectif_lk_core.diffDictationChars)(alignment.reference, alignment.attempt) : null, [alignment, solutionsShown]);
+	const detailWords = (0, react.useMemo)(() => isReview && alignment === null && outcome?.status === "scored" ? wordsFromDetails(outcome.details) : null, [
+		isReview,
+		alignment,
+		outcome
+	]);
+	const words = alignment?.words ?? detailWords;
+	const marksShown = marking && words !== null;
+	const contentDir = localeDir ?? require_direction.textDirectionOf(transcript ?? words?.map((word) => word.reference).join(" ") ?? "");
+	const nothingTyped = alignment !== null ? alignment.attempt === "" : words?.every((word) => word.attempt === "") ?? false;
+	const passed = isReview ? outcome?.status === "scored" || outcome?.status === "graded" ? outcome.passed : void 0 : result?.passed;
+	const reviewSummary = (0, react.useMemo)(() => {
+		if (!isReview || outcome === void 0) return null;
+		if (outcome.status === "scored") return {
+			text: s.scoreAnnouncement(Math.round(outcome.score * 100), outcome.passed),
+			feedback: outcome.feedback
+		};
+		if (outcome.status === "deferred") return {
+			text: s.notGradedYet,
+			feedback: null
+		};
+		if (outcome.status === "graded") {
+			const percent = outcome.maxScore > 0 ? Math.round(outcome.score / outcome.maxScore * 100) : Math.round(outcome.score * 100);
+			return {
+				text: s.scoreAnnouncement(percent, outcome.passed),
+				feedback: outcome.feedback ?? null
+			};
+		}
+		return {
+			text: s.noGradeAvailable,
+			feedback: null
+		};
+	}, [
+		isReview,
+		outcome,
+		s
+	]);
+	const sentenceFor = (word) => {
+		switch (word.status) {
+			case "correct": return s.dictationWordCorrect(word.attempt);
+			case "incorrect": return solutionsShown ? s.dictationWordWrong(word.attempt, word.reference) : s.dictationWordWrongUnnamed(word.attempt);
+			case "missing": return solutionsShown ? s.dictationWordMissing(word.reference) : s.dictationWordMissingUnnamed;
+			default: return s.dictationWordExtra(word.attempt);
+		}
+	};
+	const acceptedTranscripts = transcript === void 0 || !Array.isArray(data.acceptedTranscripts) ? void 0 : data.acceptedTranscripts.filter((entry) => typeof entry === "string");
+	const extra = !isReview && policy.feedback && submitted && tries.counted !== null ? require_tries.triesSummary(s, scoringPolicy, tries.counted, tries.open) : "";
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("form", {
+		ref: formRef,
+		className: "lk-dc",
+		"aria-labelledby": VISIBLE_TEXT_RE.test(data.title) ? titleId : void 0,
+		lang: locale,
+		"data-render-mode": renderMode,
+		style: theme,
+		onSubmit: handleSubmit,
+		children: [
+			/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+				id: titleId,
+				className: "lk-dc-title",
+				dir: localeDir ?? "auto",
+				lang: contentLang,
+				children: data.title
+			}),
+			data.media !== void 0 || slowMedia !== void 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				className: "lk-dc-recordings",
+				children: [data.media !== void 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("fieldset", {
+					className: "lk-dc-recording",
+					children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("legend", {
+						className: "lk-dc-recording-label",
+						children: s.dictationRecording
+					}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_ActivityMedia.ActivityMedia, {
+						media: data.media,
+						renderMode,
+						playbackGroup: recordingsGroup,
+						...mediaBudget !== void 0 ? { mediaBudget } : {},
+						...mediaStrings !== void 0 ? { mediaStrings } : {},
+						...strings !== void 0 ? { strings } : {},
+						...onInteraction !== void 0 ? { onInteraction } : {},
+						...locale !== void 0 ? { locale } : {},
+						...disabled !== void 0 ? { disabled } : {}
+					})]
+				}) : null, slowMedia !== void 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("fieldset", {
+					className: "lk-dc-recording",
+					"data-slow": "true",
+					children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("legend", {
+						className: "lk-dc-recording-label",
+						children: s.dictationSlowRecording
+					}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_ActivityMedia.ActivityMedia, {
+						media: slowMedia,
+						renderMode,
+						playbackGroup: recordingsGroup,
+						...mediaStrings !== void 0 ? { mediaStrings } : {},
+						...strings !== void 0 ? { strings } : {},
+						...locale !== void 0 ? { locale } : {},
+						...disabled !== void 0 ? { disabled } : {}
+					})]
+				}) : null]
+			}) : null,
+			hintsEnabled ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				className: "lk-dc-hints",
+				children: [
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+						ref: revealButtonRef,
+						type: "button",
+						className: "lk-dc-hint-btn",
+						disabled: inactive,
+						"aria-disabled": hintsShown >= hintTotal || void 0,
+						onClick: revealNextHint,
+						children: s.dictationRevealNextWord(hintsShown, hintTotal)
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_tries.HintCost, {
+						policy: scoringPolicy,
+						strings: s
+					}),
+					hintsShown > 0 && scoringPolicy.hintPenalty <= 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+						type: "button",
+						className: "lk-dc-hint-reset",
+						disabled: inactive,
+						onClick: resetHints,
+						children: s.dictationResetHints
+					}) : null,
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						id: hintId,
+						className: "lk-dc-hint",
+						role: "status",
+						dir: contentDir,
+						lang: contentLang,
+						children: hintsShown > 0 ? `${hintWords.slice(0, hintsShown).join(" ")}${hintsShown < hintTotal ? " …" : ""}` : ""
+					})
+				]
+			}) : null,
+			/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("fieldset", {
+				disabled: inactive,
+				children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("textarea", {
+					className: "lk-dc-input",
+					"aria-label": s.dictationInputLabel,
+					"aria-describedby": hintsEnabled && hintsShown > 0 ? hintId : void 0,
+					dir: "auto",
+					rows: 3,
+					maxLength: _intellectif_lk_core.DICTATION_MAX_TEXT_LENGTH,
+					autoComplete: "off",
+					autoCapitalize: "none",
+					autoCorrect: "off",
+					spellCheck: false,
+					value: text,
+					disabled: inactive,
+					"aria-disabled": inactive || void 0,
+					"data-correct": marking && passed !== void 0 && (!isReview || hasResponse) ? String(passed) : void 0,
+					onChange: (event) => handleTextChange(event.target.value)
+				}), isReview ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+					type: "submit",
+					disabled: inactive,
+					children: isExam ? s.submitAnswers : s.checkAnswers
+				})]
+			}),
+			marksShown ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				className: "lk-dc-result",
+				children: [nothingTyped ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+					className: "lk-dc-nothing",
+					role: "note",
+					children: s.dictationNothingTyped
+				}) : /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("ol", {
+						className: "lk-dc-words",
+						"aria-label": s.dictationMarksLabel,
+						dir: contentDir,
+						children: words?.map((word, index) => {
+							const sentence = sentenceFor(word);
+							return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("li", {
+								className: "lk-dc-word",
+								"data-state": word.status,
+								title: sentence,
+								children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+									className: "lk-visually-hidden",
+									style: VISUALLY_HIDDEN,
+									children: sentence
+								}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+									className: "lk-dc-word-text",
+									"aria-hidden": "true",
+									dir: contentDir ?? "auto",
+									lang: contentLang,
+									...word.status === "incorrect" && alignment !== null && solutionsShown ? { "data-marks": "characters" } : {},
+									children: word.status === "incorrect" && alignment !== null && solutionsShown ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(CharOps, {
+										ops: (0, _intellectif_lk_core.diffDictationChars)(word.reference, word.attempt),
+										contentDir
+									}) : word.status === "missing" ? solutionsShown ? word.reference : "…" : word.attempt
+								})]
+							}, index);
+						})
+					}),
+					sentenceDiff !== null ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						className: "lk-dc-diff",
+						"aria-hidden": "true",
+						dir: contentDir,
+						lang: contentLang,
+						children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(CharOps, {
+							ops: sentenceDiff,
+							contentDir
+						})
+					}) : null,
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("ul", {
+						className: "lk-dc-legend",
+						children: [
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("li", {
+								"data-state": "correct",
+								children: s.dictationLegendCorrect
+							}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("li", {
+								"data-state": "incorrect",
+								children: s.dictationLegendWrong
+							}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("li", {
+								"data-state": "missing",
+								children: s.dictationLegendMissing
+							}),
+							alignment !== null ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("li", {
+								"data-state": "extra",
+								children: s.dictationLegendExtra
+							}) : null
+						]
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						className: "lk-dc-diff-note",
+						children: s.dictationDiffNote
+					})
+				] }), transcript !== void 0 && solutionsShown ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+					type: "button",
+					className: "lk-dc-solution-toggle",
+					"aria-expanded": solutionShown,
+					"aria-controls": solutionId,
+					onClick: () => setSolutionShown((shown) => !shown),
+					children: solutionShown ? s.hideSolution : s.showSolution
+				}), solutionShown ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("blockquote", {
+					id: solutionId,
+					className: "lk-dc-solution",
+					"aria-label": s.dictationSolutionLabel,
+					dir: contentDir,
+					children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						lang: contentLang,
+						children: transcript
+					}), acceptedTranscripts !== void 0 && acceptedTranscripts.length > 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("ul", {
+						className: "lk-dc-solution-alternatives",
+						lang: contentLang,
+						children: acceptedTranscripts.map((alternative) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("li", { children: alternative }, alternative))
+					}) : null]
+				}) : null] }) : null]
+			}) : null,
+			/* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_FeedbackRegion.FeedbackRegion, {
+				id: `${data.id}-feedback`,
+				...scoringPolicy.retries > 0 ? { ref: feedbackRef } : {},
+				children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(AnnouncementText, { announcement: require_FeedbackRegion.feedbackAnnouncement({
+					review: isReview,
+					feedback: policy.feedback,
+					outcome,
+					readBack: reviewSummary,
+					submitted: summary !== null,
+					result: summary === null || extra === "" ? summary : {
+						...summary,
+						text: `${summary.text} ${extra}`
+					},
+					received: {
+						text: s.answerSubmitted,
+						feedback: null
+					}
+				}) })
+			}),
+			/* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_tries.TryActions, {
+				tries,
+				solutions: policy.solutions && transcript !== void 0,
+				strings: s,
+				onRetry: retry,
+				onClose: closeTries
+			}),
+			/* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_tries.AiExplanation, {
+				ai,
+				data,
+				renderMode,
+				submitted,
+				response: responseOf(text, reportedHints),
+				outcome,
+				locale,
+				onInteraction,
+				strings: s,
+				delivery: tries.open ? {
+					...policy,
+					solutions: false
+				} : policy
+			})
+		]
+	});
+}
+//#endregion
+//#region src/components/Dictation/index.tsx
+/**
+* Public Dictation activity: the core wrapped in `ActivityErrorBoundary` so a
+* render failure (including the dev schema-validation throw and the
+* redacted-in-`practice` guard) degrades to an accessible fallback instead of
+* crashing the host.
+*/
+function Dictation(props) {
+	const strings = require_LkIntlProvider.useLkStrings(props.strings);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_ActivityErrorBoundary.ActivityErrorBoundary, {
+		activityTitle: props.data?.title,
+		strings,
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Dictation$1, { ...props })
+	});
+}
+//#endregion
+Object.defineProperty(exports, "Dictation", {
+	enumerable: true,
+	get: function() {
+		return Dictation;
+	}
+});
+
+//# sourceMappingURL=Dictation-jECzL88E.cjs.map