@intellectif/lk-react 23.1.0 → 23.1.2

package/dist/LkAiProvider-DAPpA3PQ.d.cts

@@ -0,0 +1,84 @@
+import { AiCoachingRequest, AiCoachingResult, AiExplanationRequest, AiHintRequest, AiTextResult, AiWritingFeedbackRequest, AiWritingFeedbackResult } from "@intellectif/lk-core";
+import { ReactNode } from "react";
+//#region src/ai/LkAiProvider.d.ts
+/**
+ * The model a host runs for learners, as the components call it. The SDK never
+ * calls a model, holds a key or writes a prompt: each port is the host's
+ * function — usually a request to its own server, which holds the key and the
+ * prompt and chooses the model.
+ *
+ * A port is called only when the learner asks — a button, never on render —
+ * and gets an `AbortSignal` that fires when the answer it was asked about goes
+ * away. Whatever it resolves to is checked before a learner sees it: see
+ * `checkAiExplanation` and `checkAiHint` in lk-core. A port that rejects, or
+ * resolves to something refused, costs the learner the help, never the
+ * question.
+ *
+ * Leave a port out to switch that feature off. Nothing AI renders in `exam`,
+ * whatever is passed.
+ */
+interface LearnerAi {
+  /** Explains a graded answer. */
+  explain?: (request: AiExplanationRequest, options: {
+    signal: AbortSignal;
+  }) => Promise<AiTextResult>;
+  /** Writes the next hint for an answer not yet submitted. */
+  hint?: (request: AiHintRequest, options: {
+    signal: AbortSignal;
+  }) => Promise<AiTextResult>;
+  /** The most hints a learner can ask for on one question. Default 3, at most 10. */
+  maxHints?: number;
+  /**
+   * Gives feedback on a draft of a written response, before the learner
+   * submits it: the overall feedback as text, corrections that quote the
+   * draft, and a judgement per rubric criterion. See `checkAiWritingFeedback`
+   * in lk-core for what is refused.
+   */
+  writingFeedback?: (request: AiWritingFeedbackRequest, options: {
+    signal: AbortSignal;
+  }) => Promise<AiWritingFeedbackResult>;
+  /** How many times a learner can ask for feedback on one written response. Default 3, at most 10. */
+  maxWritingFeedback?: number;
+  /**
+   * Coaches a learner on a graded reading aloud: what the speech engine's
+   * marks mean and how to practise, word by word. The marks are the engine's
+   * and are never re-scored; coaching on a word the engine did not mark, or a
+   * sound it did not report, is refused whole. See `checkAiCoaching` in
+   * lk-core. One coaching per reading.
+   */
+  pronunciationCoaching?: (request: AiCoachingRequest, options: {
+    signal: AbortSignal;
+  }) => Promise<AiCoachingResult>;
+  /**
+   * The language to write explanations, hints, feedback and coaching in, as a tag (`es`,
+   * `pt-BR`). Defaults to the component's `locale`: the interface language,
+   * which the buttons around the help are in, and usually the right one. In a
+   * language course it need not be the item's — English items, explained in
+   * Spanish — and the item's own language reaches your port as `facts.locale`.
+   */
+  learnerLocale?: string;
+}
+interface LkAiProviderProps {
+  ai: LearnerAi;
+  children: ReactNode;
+}
+/**
+ * Supplies the host's AI ports to every activity beneath, as `LkIntlProvider`
+ * supplies strings. A component's own `ai` prop wins over it, whole.
+ *
+ * ```tsx
+ * <LkAiProvider ai={{
+ *   explain: (request, { signal }) => api.explain(request, signal),
+ *   hint: (request, { signal }) => api.hint(request, signal),
+ *   learnerLocale: learner.language,
+ * }}>
+ *   <ActivitySequence … />
+ * </LkAiProvider>
+ * ```
+ */
+declare function LkAiProvider({ ai, children }: LkAiProviderProps): React.JSX.Element;
+/** The ports in force: a component's own, else the provider's, else none. */
+declare function useLearnerAi(override?: LearnerAi): LearnerAi | undefined;
+//#endregion
+export { useLearnerAi as i, LkAiProvider as n, LkAiProviderProps as r, LearnerAi as t };
+//# sourceMappingURL=LkAiProvider-DAPpA3PQ.d.cts.map

package/dist/LkAiProvider-DAPpA3PQ.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LkAiProvider-DAPpA3PQ.d.cts","names":[],"sources":["../src/ai/LkAiProvider.tsx"],"mappings":";;;;;;;;;;;;;;;;;;;UA6BiB;;EAEf,WACE,SAAS,sBACT;IAAW,QAAQ;QAChB,QAAQ;;EAEb,QAAQ,SAAS,eAAe;IAAW,QAAQ;QAAkB,QAAQ;;EAE7E;;;;;;;EAOA,mBACE,SAAS,0BACT;IAAW,QAAQ;QAChB,QAAQ;;EAEb;;;;;;;;EAQA,yBACE,SAAS,mBACT;IAAW,QAAQ;QAChB,QAAQ;;;;;;;;EAQb;;UAKe;EACf,IAAI;EACJ,UAAU;;;;;;;;;;;;;;;;iBAiBI,eAAe,IAAI,YAAY,oBAAoB,MAAM,IAAI;;iBAK7D,aAAa,WAAW,YAAY"}

package/dist/LkAiProvider-QdEcIhoo.d.ts

@@ -0,0 +1,84 @@
+import { ReactNode } from "react";
+import { AiCoachingRequest, AiCoachingResult, AiExplanationRequest, AiHintRequest, AiTextResult, AiWritingFeedbackRequest, AiWritingFeedbackResult } from "@intellectif/lk-core";
+//#region src/ai/LkAiProvider.d.ts
+/**
+ * The model a host runs for learners, as the components call it. The SDK never
+ * calls a model, holds a key or writes a prompt: each port is the host's
+ * function — usually a request to its own server, which holds the key and the
+ * prompt and chooses the model.
+ *
+ * A port is called only when the learner asks — a button, never on render —
+ * and gets an `AbortSignal` that fires when the answer it was asked about goes
+ * away. Whatever it resolves to is checked before a learner sees it: see
+ * `checkAiExplanation` and `checkAiHint` in lk-core. A port that rejects, or
+ * resolves to something refused, costs the learner the help, never the
+ * question.
+ *
+ * Leave a port out to switch that feature off. Nothing AI renders in `exam`,
+ * whatever is passed.
+ */
+interface LearnerAi {
+  /** Explains a graded answer. */
+  explain?: (request: AiExplanationRequest, options: {
+    signal: AbortSignal;
+  }) => Promise<AiTextResult>;
+  /** Writes the next hint for an answer not yet submitted. */
+  hint?: (request: AiHintRequest, options: {
+    signal: AbortSignal;
+  }) => Promise<AiTextResult>;
+  /** The most hints a learner can ask for on one question. Default 3, at most 10. */
+  maxHints?: number;
+  /**
+   * Gives feedback on a draft of a written response, before the learner
+   * submits it: the overall feedback as text, corrections that quote the
+   * draft, and a judgement per rubric criterion. See `checkAiWritingFeedback`
+   * in lk-core for what is refused.
+   */
+  writingFeedback?: (request: AiWritingFeedbackRequest, options: {
+    signal: AbortSignal;
+  }) => Promise<AiWritingFeedbackResult>;
+  /** How many times a learner can ask for feedback on one written response. Default 3, at most 10. */
+  maxWritingFeedback?: number;
+  /**
+   * Coaches a learner on a graded reading aloud: what the speech engine's
+   * marks mean and how to practise, word by word. The marks are the engine's
+   * and are never re-scored; coaching on a word the engine did not mark, or a
+   * sound it did not report, is refused whole. See `checkAiCoaching` in
+   * lk-core. One coaching per reading.
+   */
+  pronunciationCoaching?: (request: AiCoachingRequest, options: {
+    signal: AbortSignal;
+  }) => Promise<AiCoachingResult>;
+  /**
+   * The language to write explanations, hints, feedback and coaching in, as a tag (`es`,
+   * `pt-BR`). Defaults to the component's `locale`: the interface language,
+   * which the buttons around the help are in, and usually the right one. In a
+   * language course it need not be the item's — English items, explained in
+   * Spanish — and the item's own language reaches your port as `facts.locale`.
+   */
+  learnerLocale?: string;
+}
+interface LkAiProviderProps {
+  ai: LearnerAi;
+  children: ReactNode;
+}
+/**
+ * Supplies the host's AI ports to every activity beneath, as `LkIntlProvider`
+ * supplies strings. A component's own `ai` prop wins over it, whole.
+ *
+ * ```tsx
+ * <LkAiProvider ai={{
+ *   explain: (request, { signal }) => api.explain(request, signal),
+ *   hint: (request, { signal }) => api.hint(request, signal),
+ *   learnerLocale: learner.language,
+ * }}>
+ *   <ActivitySequence … />
+ * </LkAiProvider>
+ * ```
+ */
+declare function LkAiProvider({ ai, children }: LkAiProviderProps): React.JSX.Element;
+/** The ports in force: a component's own, else the provider's, else none. */
+declare function useLearnerAi(override?: LearnerAi): LearnerAi | undefined;
+//#endregion
+export { useLearnerAi as i, LkAiProvider as n, LkAiProviderProps as r, LearnerAi as t };
+//# sourceMappingURL=LkAiProvider-QdEcIhoo.d.ts.map

package/dist/LkAiProvider-QdEcIhoo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LkAiProvider-QdEcIhoo.d.ts","names":[],"sources":["../src/ai/LkAiProvider.tsx"],"mappings":";;;;;;;;;;;;;;;;;;;UA6BiB;;EAEf,WACE,SAAS,sBACT;IAAW,QAAQ;QAChB,QAAQ;;EAEb,QAAQ,SAAS,eAAe;IAAW,QAAQ;QAAkB,QAAQ;;EAE7E;;;;;;;EAOA,mBACE,SAAS,0BACT;IAAW,QAAQ;QAChB,QAAQ;;EAEb;;;;;;;;EAQA,yBACE,SAAS,mBACT;IAAW,QAAQ;QAChB,QAAQ;;;;;;;;EAQb;;UAKe;EACf,IAAI;EACJ,UAAU;;;;;;;;;;;;;;;;iBAiBI,eAAe,IAAI,YAAY,oBAAoB,MAAM,IAAI;;iBAK7D,aAAa,WAAW,YAAY"}

package/dist/LkIntlProvider-D_FdYXjQ.js

@@ -0,0 +1,375 @@
+'use client';
+import { createContext, useContext, useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/i18n/strings.ts
+/**
+* English defaults, byte-identical to what every component rendered before the
+* strings surface existed. Supplying no override changes nothing on screen.
+*/
+const DEFAULT_STRINGS = {
+	submit: "Submit",
+	checkAnswers: "Check answers",
+	submitAnswers: "Submit answers",
+	scoreAnnouncement: (percent, passed) => `Score ${percent}%. ${passed ? "Passed." : "Not passed."}`,
+	answerSubmitted: "Answer submitted.",
+	notGradedYet: "Not graded yet.",
+	noGradeAvailable: "No grade available.",
+	tryAgain: "Try again",
+	showAnswer: "Show answer",
+	keepAnswer: "Keep this answer",
+	triesLeft: (tries, costPercent) => `${tries} ${tries === 1 ? "try" : "tries"} left.${costPercent > 0 ? ` Each costs ${costPercent}% of the marks.` : ""}`,
+	countedTry: (counts, percent) => `Your ${counts === "first" ? "first" : "best"} try counts. This one scored ${percent}%.`,
+	scoreBeforeCosts: (percent) => `Before hints and tries, this answer scored ${percent}%.`,
+	hintCost: (percent) => `Each hint costs ${percent}% of this question's marks.`,
+	showFeedback: "Show feedback",
+	hideFeedback: "Hide feedback",
+	blankLabel: (ordinal) => `Fill in blank ${ordinal}`,
+	gapLabel: (ordinal) => `Choose the answer for gap ${ordinal}`,
+	gapPlaceholder: "Choose…",
+	showHint: "Show hint",
+	hideHint: "Hide hint",
+	responseSubmitted: "Response submitted. It will be graded and your result will appear here later.",
+	wordCount: (count) => `${count} ${count === 1 ? "word" : "words"}`,
+	wordBounds: (min, max) => min > 0 ? `${min}–${max} words` : `up to ${max} words`,
+	notApplicable: "Not applicable",
+	awaitingHumanReview: "This grade is awaiting review by a teacher.",
+	awaitingGrade: "Not graded yet. This response is waiting for its grade.",
+	couldNotBeGraded: "This response could not be graded.",
+	previous: "Previous",
+	next: "Next",
+	questionProgress: (index, total) => `Question ${index} of ${total}`,
+	unsupportedActivity: "This activity type has no renderer. Supply one through the renderers prop.",
+	dictationInputLabel: "Type what you hear",
+	dictationRecording: "Recording",
+	dictationSlowRecording: "Slow recording",
+	dictationRevealNextWord: (revealed, total) => `Reveal the next word (${revealed} of ${total} shown)`,
+	dictationResetHints: "Reset hints",
+	showSolution: "Show solution",
+	hideSolution: "Hide solution",
+	dictationSolutionLabel: "Solution",
+	dictationMarksLabel: "Your answer, word by word",
+	dictationDiffNote: "Compared after ignoring case, punctuation and extra spaces.",
+	dictationWordCorrect: (word) => `“${word}” is correct`,
+	dictationWordWrong: (word, expected) => `“${word}” should be “${expected}”`,
+	dictationWordMissing: (expected) => `“${expected}” is missing`,
+	dictationWordWrongUnnamed: (word) => `“${word}” is wrong`,
+	dictationWordMissingUnnamed: "A word is missing",
+	dictationWordExtra: (word) => `“${word}” is extra`,
+	dictationLegendCorrect: "Correct",
+	dictationLegendWrong: "Wrong",
+	dictationLegendMissing: "Missing",
+	dictationLegendExtra: "Extra",
+	dictationNothingTyped: "Nothing to compare: no words were entered.",
+	dictationWordsSummary: (correct, total) => `${correct} of ${total} ${total === 1 ? "word" : "words"} correct.`,
+	readAloudModelRecording: "Model recording",
+	readAloudSlowRecording: "Slow model recording",
+	readAloudRecord: "Record",
+	readAloudStop: "Stop recording",
+	readAloudRerecord: "Record again",
+	readAloudYourRecording: "Your recording",
+	readAloudPlaybackUnavailable: "Your recording cannot be played back on this page.",
+	readAloudRecordingProgress: (seconds, maxSeconds) => `Recording: ${seconds} of ${maxSeconds} seconds`,
+	readAloudRecordingStarted: "Recording started.",
+	readAloudRecordingStopped: (seconds, maxSeconds) => `Recording stopped. ${seconds} of ${maxSeconds} seconds recorded.`,
+	readAloudTakesRemaining: (remaining, max) => `${remaining} of ${max} recording${max === 1 ? "" : "s"} left`,
+	readAloudSubmitWithoutRecording: "Submit without recording",
+	readAloudUploading: "Sending your recording…",
+	readAloudUploadFailed: "Your recording could not be sent.",
+	readAloudTryAgain: "Try again",
+	readAloudAssessing: "Checking your pronunciation…",
+	readAloudAssessmentUnavailable: "Pronunciation feedback is not available for this activity.",
+	readAloudNotHeard: "We could not hear you. Record again somewhere quieter.",
+	readAloudNotAssessed: "This recording could not be assessed. Try recording it again.",
+	readAloudAssessmentFailed: "Your pronunciation could not be checked.",
+	readAloudRecorderError: (reason) => {
+		switch (reason) {
+			case "permission-denied": return "This page is not allowed to use the microphone.";
+			case "no-device": return "No microphone was found.";
+			case "unsupported": return "This browser cannot record audio.";
+			case "too-short": return "That recording was too short.";
+			default: return "The recording could not be made.";
+		}
+	},
+	pronunciationFeedbackLabel: "Pronunciation feedback",
+	pronunciationDimension: (dimension) => {
+		switch (dimension) {
+			case "accuracy": return "Accuracy";
+			case "fluency": return "Fluency";
+			case "completeness": return "Completeness";
+			default: return "Intonation";
+		}
+	},
+	pronunciationNotAssessed: "Not assessed",
+	pronunciationWordsLabel: "Your reading, word by word",
+	pronunciationLegend: (state) => {
+		switch (state) {
+			case "correct": return "Read correctly";
+			case "mispronounced": return "Mispronounced";
+			case "omitted": return "Not read";
+			default: return "Added";
+		}
+	},
+	pronunciationWordCorrect: (word) => `“${word}” was read correctly`,
+	pronunciationWordMispronounced: (word) => `“${word}” was mispronounced`,
+	pronunciationWordOmitted: (word) => `“${word}” was not read`,
+	pronunciationWordInserted: (word) => `“${word}” was added`,
+	pronunciationWordDetails: (word) => `Details for “${word}”`,
+	pronunciationSyllables: "Syllables",
+	pronunciationPhonemes: "Sounds",
+	pronunciationSyllableSpelling: (syllable, grapheme) => `${syllable} (spelled “${grapheme}”)`,
+	pronunciationPhonemePosition: (ordinal) => `Sound ${ordinal}`,
+	pronunciationHeardAs: "Heard as",
+	pronunciationPlayWord: (word) => `Play “${word}”`,
+	pronunciationBreakUnexpected: "There was an unexpected pause here.",
+	pronunciationBreakMissing: "A pause was expected here.",
+	pronunciationMonotone: "Your reading stayed on one note. Try varying your pitch.",
+	pronunciationIpaNote: "Sounds are written in the International Phonetic Alphabet.",
+	videoBack: (seconds) => `Back ${seconds} seconds`,
+	videoForward: (seconds) => `Forward ${seconds} seconds`,
+	videoReplay: "Replay",
+	videoShowRemaining: "Show time remaining",
+	videoShowElapsed: "Show time elapsed",
+	videoCaptionsShow: "Show captions",
+	videoCaptionsHide: "Hide captions",
+	videoCaptionsFailed: "Captions could not be loaded.",
+	videoSecondaryCaptionsFailed: "The second language could not be loaded.",
+	videoSpeedValue: (rate) => rate === 1 ? "Normal" : `${rate}×`,
+	videoSettings: "Settings",
+	videoCaptionLanguage: "Captions",
+	videoSecondCaptionLanguage: "Second language",
+	videoCaptionPair: (primary, secondary) => `${primary} + ${secondary}`,
+	videoNoSecondLanguage: "No second language for this video.",
+	videoCaptionSize: "Caption size",
+	videoCaptionSizeValue: (size) => size === "small" ? "Small" : size === "large" ? "Large" : "Medium",
+	videoCaptionBackground: "Caption background",
+	videoKeyboardShortcuts: "Keyboard shortcuts",
+	videoShortcutList: "Shortcut list",
+	videoClose: "Close",
+	videoOn: "On",
+	videoOff: "Off",
+	videoShortcut: (action) => {
+		switch (action) {
+			case "play-pause": return "Play or pause";
+			case "jump-10": return "Back or forward 10 seconds";
+			case "jump-5": return "Back or forward 5 seconds";
+			case "jump-1": return "Back or forward 1 second";
+			case "frame": return "Previous or next frame, while paused";
+			case "speed": return "Slower or faster";
+			case "percent": return "Jump to 0% – 90%";
+			case "start-end": return "Start or end";
+			case "chapter": return "Previous or next chapter or quiz";
+			case "mute": return "Mute";
+			case "captions": return "Captions";
+			case "secondary-captions": return "Second caption language on/off";
+			case "transcript": return "Transcript";
+			case "picture-in-picture": return "Picture in picture";
+			case "fullscreen": return "Fullscreen";
+			default: return "This list";
+		}
+	},
+	videoPanel: "Contents and transcript",
+	videoContents: "Contents",
+	videoTranscript: "Transcript",
+	videoTranscriptSearch: "Search the transcript",
+	videoTranscriptNoMatch: "No lines match.",
+	videoPictureInPicture: "Picture in picture",
+	videoFullscreen: "Fullscreen",
+	videoExitFullscreen: "Exit fullscreen",
+	videoError: (code) => code === 2 ? "The connection dropped while the video was loading." : code === 3 ? "This video file could not be played." : code === 4 ? "The video could not be loaded." : "The video stopped before it could play.",
+	videoTryAgain: "Try again",
+	videoQuiz: "Quiz",
+	videoQuestionProgress: (index, total) => `Question ${index} of ${total}`,
+	videoQuestionStep: (index, answered) => `Question ${index}${answered ? ", answered" : ""}`,
+	videoNextQuestion: "Next question",
+	videoContinue: "Continue video",
+	videoSkipQuiz: "Skip quiz",
+	videoRewatch: "Rewatch",
+	videoAnswerSaved: "Answer saved",
+	videoAnswerPending: "Saving your answer…",
+	videoRequired: "Required",
+	videoQuizProgress: (answered, total) => answered === total ? "Answered" : answered === 0 ? "Not started" : `${answered} of ${total} answered`,
+	videoQuizOpened: (time, questions) => `Video paused. Quiz at ${time}, ${questions} question${questions === 1 ? "" : "s"}.`,
+	videoHeldAtQuiz: (time) => `Finish the quiz at ${time} to continue.`,
+	videoHeldAhead: "You can rewind, but not skip ahead.",
+	videoEnded: "You reached the end",
+	videoEndScore: (answered, total, percent) => `You answered ${answered} of ${total} · ${percent}%`,
+	videoEndAnswered: (answered, total) => `You answered ${answered} of ${total} questions`,
+	videoWatchAgain: "Watch again",
+	videoFinish: "Finish",
+	previewIncomplete: "This activity is not finished yet, so it cannot be previewed.",
+	previewInvalid: "This activity has a problem to fix before it can be previewed.",
+	embeddedMedia: "Embedded media",
+	stimulusKind: {
+		text: "Passage",
+		audio: "Recording",
+		video: "Video",
+		image: "Image",
+		mixed: "Material"
+	},
+	stimulusRange: (first, last) => first === last ? `Question ${first}` : `Questions ${first}–${last}`,
+	activityFailed: "Activity failed to render",
+	activityFailedNamed: (title) => `"${title}" could not be displayed.`,
+	activityFailedUnnamed: "This activity could not be displayed.",
+	aiExplain: "Explain my answer",
+	aiExplaining: "Explaining…",
+	aiExplanation: "Explanation",
+	aiExplanationUnavailable: "No explanation is available right now.",
+	aiHint: "Get a hint",
+	aiHintLoading: "Finding a hint…",
+	aiHintNumber: (hintNumber) => `Hint ${hintNumber}`,
+	aiHints: "Hints",
+	aiHintUnavailable: "No hint is available right now.",
+	aiNoMoreHints: "No more hints for this question.",
+	aiNotice: "Written by AI. It can make mistakes.",
+	aiWritingFeedback: "Get feedback on my draft",
+	aiWritingFeedbackLoading: "Reading your draft…",
+	aiWritingFeedbackHeading: "Feedback on your draft",
+	aiWritingFeedbackUnavailable: "No feedback is available right now.",
+	aiNoMoreWritingFeedback: "No more feedback for this answer.",
+	aiWritingFeedbackOutdated: "You have changed your text since this feedback.",
+	aiCorrections: "Suggested corrections",
+	aiIndicativeScore: (percent) => `Indicative score: ${percent}%. Not a grade.`,
+	aiCoaching: "Coach me on this reading",
+	aiCoachingLoading: "Writing your coaching…",
+	aiCoachingHeading: "Coaching on your reading",
+	aiCoachingUnavailable: "No coaching is available right now.",
+	aiCoachingWords: "Words to practise",
+	aiCoachingSound: (expected, heard) => heard === void 0 ? `Sound: ${expected}` : `Sound: ${expected}, heard as ${heard}`,
+	media: {
+		play: "Play",
+		pause: "Pause",
+		preparing: "Preparing…",
+		mute: "Mute",
+		unmute: "Unmute",
+		volume: "Volume",
+		speed: "Playback speed",
+		seek: "Seek",
+		timeValue: (elapsed, duration) => `${elapsed} of ${duration}`,
+		playsRemaining: (remaining, max) => `${remaining} of ${max} play${max === 1 ? "" : "s"} remaining`,
+		noPlaysRemaining: "No plays remaining",
+		lastPlayConfirm: "This is your last play. Start it now?",
+		lastPlayStart: "Start last play",
+		lastPlayCancel: "Not yet",
+		seekBlocked: "Rewinding is not available for this recording.",
+		rateBlocked: "Playback speed is fixed for this recording.",
+		playFailed: "The recording could not be started. Try again."
+	}
+};
+/**
+* Layers an override onto a base dictionary.
+*
+* Two levels deep and no further, because the shape is two levels deep. A
+* generic deep merge would silently accept a nested object where a function
+* belongs and fail at render instead of at the call site.
+*/
+function mergeStrings(base, override) {
+	if (override === void 0) return base;
+	const { media, stimulusKind, ...flat } = override;
+	return {
+		...base,
+		...flat,
+		stimulusKind: {
+			...base.stimulusKind,
+			...stimulusKind
+		},
+		media: {
+			...base.media,
+			...media
+		}
+	};
+}
+//#endregion
+//#region src/i18n/LkIntlProvider.tsx
+const LkIntlContext = createContext(null);
+/**
+* Locales written right-to-left, by language subtag.
+*
+* A short list rather than a dependency: these are the RTL scripts in living
+* use, and the set has not changed in decades. `Intl.Locale.textInfo` would be
+* better but is not available everywhere this package runs, and an explicit
+* `direction` prop overrides this in either direction anyway.
+*/
+const RTL_LANGUAGES = /* @__PURE__ */ new Set([
+	"ar",
+	"arc",
+	"dv",
+	"fa",
+	"he",
+	"ku",
+	"ps",
+	"sd",
+	"ug",
+	"ur",
+	"yi"
+]);
+/** Resolves a BCP 47 tag to a writing direction. */
+function directionForLocale(locale) {
+	if (locale === void 0) return "ltr";
+	const language = locale.split("-")[0]?.toLowerCase() ?? "";
+	return RTL_LANGUAGES.has(language) ? "rtl" : "ltr";
+}
+/**
+* Supplies the SDK's chrome text and writing direction to everything beneath.
+*
+* Mirrors `ThemeProvider`: a provider for the whole tree, and a per-component
+* prop for the exceptions. The component prop wins, so a single activity can
+* be relabelled without a second provider.
+*
+* ```tsx
+* <LkIntlProvider locale="es" strings={{
+*   submit: 'Enviar',
+*   checkAnswers: 'Comprobar respuestas',
+*   questionProgress: (i, total) => `Pregunta ${i} de ${total}`,
+*   wordCount: (n) => `${n} ${n === 1 ? 'palabra' : 'palabras'}`,
+*   media: { noPlaysRemaining: 'No quedan reproducciones' },
+* }}>
+*   <ActivitySequence … />
+* </LkIntlProvider>
+* ```
+*
+* The SDK ships **English only**. Bundling Spanish, Portuguese or Arabic would
+* mean shipping translations nobody in this repo can review, and a wrong
+* "No plays remaining" on a listening exam is worse than an English one that a
+* teacher can see is untranslated. The mechanism is the deliverable; the words
+* belong to whoever speaks the language.
+*/
+function LkIntlProvider({ strings, locale, direction = "auto", children }) {
+	const value = useMemo(() => ({
+		strings: mergeStrings(DEFAULT_STRINGS, strings),
+		locale,
+		direction: direction === "auto" ? directionForLocale(locale) : direction
+	}), [
+		strings,
+		locale,
+		direction
+	]);
+	const declared = direction === "auto" && locale === void 0 ? void 0 : value.direction;
+	return /* @__PURE__ */ jsx(LkIntlContext.Provider, {
+		value,
+		children: /* @__PURE__ */ jsx("div", {
+			className: "lk-intl",
+			lang: locale,
+			dir: declared,
+			children
+		})
+	});
+}
+/**
+* The strings in force, with an optional per-component override layered on top.
+*
+* Usable without a provider: every component calls this, and one rendered
+* standalone still needs its labels. Falling back to the English defaults is
+* what keeps `<MultipleChoice>` working with no setup at all.
+*/
+function useLkStrings(override) {
+	const base = useContext(LkIntlContext)?.strings ?? DEFAULT_STRINGS;
+	return useMemo(() => mergeStrings(base, override), [base, override]);
+}
+/** The direction in force. `ltr` with no provider. */
+function useLkDirection() {
+	return useContext(LkIntlContext)?.direction ?? "ltr";
+}
+//#endregion
+export { DEFAULT_STRINGS as a, useLkStrings as i, directionForLocale as n, mergeStrings as o, useLkDirection as r, LkIntlProvider as t };
+
+//# sourceMappingURL=LkIntlProvider-D_FdYXjQ.js.map