@thanh01.pmt/interactive-quiz-kit 1.0.22 → 1.0.24

package/dist/index.js

@@ -0,0 +1,3500 @@
+import { z } from 'zod';
+import { genkit } from 'genkit';
+import { gemini20Flash, googleAI } from '@genkit-ai/googleai';
+import JSZip from 'jszip';
+import { clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+
+// src/services/SCORMService.ts
+var SCORM_TRUE = "true";
+var SCORM_NO_ERROR = "0";
+var CMI_CORE_LESSON_STATUS_PASSED = "passed";
+var CMI_CORE_LESSON_STATUS_FAILED = "failed";
+var CMI_CORE_LESSON_STATUS_COMPLETED = "completed";
+var CMI_CORE_LESSON_STATUS_INCOMPLETE = "incomplete";
+var CMI_CORE_LESSON_STATUS_NOT_ATTEMPTED = "not attempted";
+var CMI_COMPLETION_STATUS_COMPLETED = "completed";
+var CMI_COMPLETION_STATUS_INCOMPLETE = "incomplete";
+var CMI_SUCCESS_STATUS_PASSED = "passed";
+var CMI_SUCCESS_STATUS_FAILED = "failed";
+var SCORMService = class {
+  constructor(settings) {
+    this.scormAPI = null;
+    this.scormVersionFound = null;
+    this.isInitialized = false;
+    this.isTerminated = false;
+    this.studentName = null;
+    this.settings = __spreadValues({
+      setCompletionOnFinish: true,
+      setSuccessOnPass: true,
+      autoCommit: true
+    }, settings);
+    if (typeof window !== "undefined") {
+      this._findAPI();
+    }
+  }
+  _findAPIRecursive(win) {
+    if (win === null) return null;
+    if (win.API_1484_11) {
+      this.scormVersionFound = "2004";
+      return win.API_1484_11;
+    }
+    if (win.API) {
+      this.scormVersionFound = "1.2";
+      return win.API;
+    }
+    if (win.parent && win.parent !== win) {
+      return this._findAPIRecursive(win.parent);
+    }
+    if (win.opener && typeof win.opener !== "undefined" && win.opener !== win && win.opener !== win.parent) {
+      try {
+        if (win.opener.document) {
+          return this._findAPIRecursive(win.opener);
+        }
+      } catch (e) {
+        console.warn("SCORMService: Could not access win.opener for API search due to cross-origin restrictions.");
+      }
+    }
+    return null;
+  }
+  _findAPI() {
+    try {
+      this.scormAPI = this._findAPIRecursive(window);
+      if (this.scormAPI) {
+        if (!this.scormVersionFound) this.scormVersionFound = this.settings.version;
+        console.log(`SCORMService: API Found. Version determined: ${this.scormVersionFound}`);
+      } else {
+        console.warn("SCORMService: SCORM API not found in window hierarchy.");
+      }
+    } catch (e) {
+      console.error("SCORMService: Error finding SCORM API", e);
+      this.scormAPI = null;
+    }
+  }
+  hasAPI() {
+    return this.scormAPI !== null;
+  }
+  getSCORMVersion() {
+    return this.scormVersionFound;
+  }
+  initialize() {
+    if (!this.hasAPI()) return { success: false, error: "SCORM API not found." };
+    if (this.isInitialized) return { success: true, studentName: this.studentName || void 0 };
+    const result = this.scormVersionFound === "2004" ? this.scormAPI.Initialize("") : this.scormAPI.LMSInitialize("");
+    if (result.toString() === SCORM_TRUE || result === true) {
+      this.isInitialized = true;
+      this.isTerminated = false;
+      const studentNameVar = this.settings.studentNameVar || (this.scormVersionFound === "2004" ? "cmi.learner_name" : "cmi.core.student_name");
+      this.studentName = this.getValue(studentNameVar);
+      if (this.scormVersionFound === "2004") {
+        const completionStatusVar = this.settings.completionStatusVar_2004 || this.settings.lessonStatusVar || "cmi.completion_status";
+        if (this.getValue(completionStatusVar) === "not attempted") {
+          this.setValue(completionStatusVar, CMI_COMPLETION_STATUS_INCOMPLETE);
+        }
+      } else {
+        const lessonStatusVar = this.settings.lessonStatusVar_1_2 || this.settings.lessonStatusVar || "cmi.core.lesson_status";
+        if (this.getValue(lessonStatusVar) === CMI_CORE_LESSON_STATUS_NOT_ATTEMPTED) {
+          this.setValue(lessonStatusVar, CMI_CORE_LESSON_STATUS_INCOMPLETE);
+        }
+      }
+      if (this.settings.autoCommit) this.commit();
+      return { success: true, studentName: this.studentName || void 0 };
+    } else {
+      const error = this.getLastError();
+      return { success: false, error: `Initialization failed: ${error.message}` };
+    }
+  }
+  terminate() {
+    if (!this.hasAPI() || !this.isInitialized || this.isTerminated) {
+      const reason = !this.hasAPI() ? "API not found" : !this.isInitialized ? "Not initialized" : "Already terminated";
+      return { success: !this.hasAPI() || this.isTerminated, error: this.isTerminated ? void 0 : reason };
+    }
+    const result = this.scormVersionFound === "2004" ? this.scormAPI.Terminate("") : this.scormAPI.LMSFinish("");
+    if (result.toString() === SCORM_TRUE || result === true) {
+      this.isTerminated = true;
+      this.isInitialized = false;
+      return { success: true };
+    } else {
+      const error = this.getLastError();
+      return { success: false, error: `Termination failed: ${error.message}` };
+    }
+  }
+  setValue(element, value) {
+    if (!this.hasAPI() || !this.isInitialized) {
+      return { success: false, error: !this.hasAPI() ? "SCORM API not found." : "SCORM not initialized." };
+    }
+    const valStr = value.toString();
+    const result = this.scormVersionFound === "2004" ? this.scormAPI.SetValue(element, valStr) : this.scormAPI.LMSSetValue(element, valStr);
+    if (result.toString() === SCORM_TRUE || result === true) {
+      if (this.settings.autoCommit) this.commit();
+      return { success: true };
+    } else {
+      const error = this.getLastError();
+      return { success: false, error: `SetValue failed for ${element}: ${error.message}` };
+    }
+  }
+  getValue(element) {
+    var _a;
+    if (!this.hasAPI() || !this.isInitialized) return null;
+    const value = this.scormVersionFound === "2004" ? this.scormAPI.GetValue(element) : this.scormAPI.LMSGetValue(element);
+    const error = this.getLastError();
+    if (error.code !== SCORM_NO_ERROR && error.code !== "403" && error.code !== "0") {
+      console.warn(`SCORMService: GetValue for ${element} produced an error ${error.code}: ${error.message}. Returning raw value:`, value);
+    }
+    return (_a = value == null ? void 0 : value.toString()) != null ? _a : null;
+  }
+  commit() {
+    if (!this.hasAPI() || !this.isInitialized) {
+      return { success: false, error: !this.hasAPI() ? "SCORM API not found." : "SCORM not initialized." };
+    }
+    const result = this.scormVersionFound === "2004" ? this.scormAPI.Commit("") : this.scormAPI.LMSCommit("");
+    if (result.toString() === SCORM_TRUE || result === true) {
+      return { success: true };
+    } else {
+      const error = this.getLastError();
+      return { success: false, error: `Commit failed: ${error.message}` };
+    }
+  }
+  setScore(rawScore, maxScore, minScore = 0) {
+    if (!this.hasAPI() || !this.isInitialized) return;
+    if (this.scormVersionFound === "2004") {
+      const scoreRawVar = this.settings.scoreRawVar_2004 || this.settings.scoreRawVar || "cmi.score.raw";
+      const scoreMaxVar = this.settings.scoreMaxVar_2004 || this.settings.scoreMaxVar || "cmi.score.max";
+      const scoreMinVar = this.settings.scoreMinVar_2004 || this.settings.scoreMinVar || "cmi.score.min";
+      const scoreScaledVar = this.settings.scoreScaledVar_2004 || "cmi.score.scaled";
+      this.setValue(scoreMinVar, minScore);
+      this.setValue(scoreMaxVar, maxScore);
+      this.setValue(scoreRawVar, rawScore);
+      if (maxScore > minScore) {
+        const scaledScore = (rawScore - minScore) / (maxScore - minScore);
+        this.setValue(scoreScaledVar, parseFloat(scaledScore.toFixed(4)));
+      } else if (maxScore === minScore && maxScore !== 0) {
+        this.setValue(scoreScaledVar, rawScore >= maxScore ? 1 : 0);
+      } else {
+        this.setValue(scoreScaledVar, 0);
+      }
+    } else {
+      const scoreRawVar = this.settings.scoreRawVar_1_2 || this.settings.scoreRawVar || "cmi.core.score.raw";
+      const scoreMaxVar = this.settings.scoreMaxVar_1_2 || this.settings.scoreMaxVar || "cmi.core.score.max";
+      const scoreMinVar = this.settings.scoreMinVar_1_2 || this.settings.scoreMinVar || "cmi.core.score.min";
+      this.setValue(scoreMinVar, minScore);
+      this.setValue(scoreMaxVar, maxScore);
+      this.setValue(scoreRawVar, rawScore);
+    }
+  }
+  setLessonStatus(status, passed) {
+    if (!this.hasAPI() || !this.isInitialized) return;
+    if (this.scormVersionFound === "2004") {
+      const completionStatusVar = this.settings.completionStatusVar_2004 || this.settings.lessonStatusVar || "cmi.completion_status";
+      const successStatusVar = this.settings.successStatusVar_2004 || "cmi.success_status";
+      if (this.settings.setCompletionOnFinish && (status === "completed" || status === "passed" || status === "failed")) {
+        this.setValue(completionStatusVar, CMI_COMPLETION_STATUS_COMPLETED);
+      } else if (status === "incomplete" || status === "browsed") {
+        this.setValue(completionStatusVar, CMI_COMPLETION_STATUS_INCOMPLETE);
+      }
+      if (this.settings.setSuccessOnPass && passed !== void 0) {
+        this.setValue(successStatusVar, passed ? CMI_SUCCESS_STATUS_PASSED : CMI_SUCCESS_STATUS_FAILED);
+      }
+    } else {
+      const lessonStatusVar = this.settings.lessonStatusVar_1_2 || this.settings.lessonStatusVar || "cmi.core.lesson_status";
+      let finalStatus = status;
+      if (this.settings.setCompletionOnFinish) {
+        if (this.settings.setSuccessOnPass && passed !== void 0) {
+          finalStatus = passed ? CMI_CORE_LESSON_STATUS_PASSED : CMI_CORE_LESSON_STATUS_FAILED;
+        } else {
+          finalStatus = CMI_CORE_LESSON_STATUS_COMPLETED;
+        }
+      } else {
+        if (status === CMI_CORE_LESSON_STATUS_PASSED || status === CMI_CORE_LESSON_STATUS_FAILED) ; else {
+          finalStatus = CMI_CORE_LESSON_STATUS_INCOMPLETE;
+        }
+      }
+      this.setValue(lessonStatusVar, finalStatus);
+    }
+  }
+  getLastError() {
+    var _a, _b;
+    if (!this.hasAPI()) return { code: "-1", message: "SCORM API not found." };
+    const errorCode = this.scormVersionFound === "2004" ? this.scormAPI.GetLastError() : this.scormAPI.LMSGetLastError();
+    if (errorCode === SCORM_NO_ERROR || errorCode === 0 || errorCode === "0") {
+      return { code: SCORM_NO_ERROR, message: "No error." };
+    }
+    const errorMessage = this.scormVersionFound === "2004" ? this.scormAPI.GetErrorString(errorCode.toString()) : this.scormAPI.LMSGetErrorString(errorCode.toString());
+    const diagnostic = this.scormVersionFound === "2004" ? this.scormAPI.GetDiagnostic(errorCode.toString()) : this.scormAPI.LMSGetDiagnostic(errorCode.toString());
+    return {
+      code: errorCode.toString(),
+      message: (_a = errorMessage == null ? void 0 : errorMessage.toString()) != null ? _a : "Unknown error.",
+      diagnostic: (_b = diagnostic == null ? void 0 : diagnostic.toString()) != null ? _b : void 0
+    };
+  }
+  formatCMITime(totalSeconds) {
+    const pad = (num, size = 2) => num.toString().padStart(size, "0");
+    if (this.scormVersionFound === "2004") {
+      const hours = Math.floor(totalSeconds / 3600);
+      const minutes = Math.floor(totalSeconds % 3600 / 60);
+      const seconds = parseFloat((totalSeconds % 60).toFixed(2));
+      let timeString = "PT";
+      if (hours > 0) timeString += `${hours}H`;
+      if (minutes > 0 || hours > 0 && seconds > 0) {
+        timeString += `${minutes}M`;
+      }
+      if (seconds > 0 || timeString === "PT") {
+        timeString += `${seconds}S`;
+      }
+      return timeString === "PT" ? "PT0S" : timeString;
+    } else {
+      const hours = Math.floor(totalSeconds / 3600);
+      const minutes = Math.floor(totalSeconds % 3600 / 60);
+      const secondsOnly = Math.floor(totalSeconds % 60);
+      const centiseconds = Math.floor((totalSeconds - Math.floor(totalSeconds)) * 100);
+      return `${pad(hours, 4)}:${pad(minutes)}:${pad(secondsOnly)}.${pad(centiseconds)}`;
+    }
+  }
+};
+
+// src/services/evaluators/multiple-choice-evaluator.ts
+var MultipleChoiceEvaluator = class {
+  async evaluate(question, answer) {
+    var _a;
+    const points = (_a = question.points) != null ? _a : 0;
+    const correctAnswerId = question.correctAnswerId;
+    const isCorrect = answer === correctAnswerId;
+    const correctOption = question.options.find((opt) => opt.id === correctAnswerId);
+    const correctAnswerDetail = {
+      id: correctAnswerId,
+      value: (correctOption == null ? void 0 : correctOption.text) || ""
+    };
+    return Promise.resolve({
+      isCorrect,
+      correctAnswer: correctAnswerDetail,
+      pointsEarned: isCorrect ? points : 0
+    });
+  }
+};
+
+// src/services/evaluators/multiple-response-evaluator.ts
+var MultipleResponseEvaluator = class {
+  async evaluate(question, answer) {
+    var _a;
+    const points = (_a = question.points) != null ? _a : 0;
+    const correctAnswerIds = question.correctAnswerIds;
+    let isCorrect = false;
+    if (Array.isArray(answer)) {
+      const userAnswerSet = new Set(answer);
+      const correctAnswerSet = new Set(correctAnswerIds);
+      isCorrect = userAnswerSet.size === correctAnswerSet.size && [...userAnswerSet].every((id) => correctAnswerSet.has(id));
+    }
+    const correctValues = correctAnswerIds.map(
+      (id) => {
+        var _a2;
+        return ((_a2 = question.options.find((opt) => opt.id === id)) == null ? void 0 : _a2.text) || "";
+      }
+    );
+    const correctAnswerDetail = {
+      id: correctAnswerIds,
+      value: correctValues
+    };
+    return Promise.resolve({
+      isCorrect,
+      correctAnswer: correctAnswerDetail,
+      pointsEarned: isCorrect ? points : 0
+    });
+  }
+};
+
+// src/services/evaluators/true-false-evaluator.ts
+var TrueFalseEvaluator = class {
+  async evaluate(question, answer) {
+    var _a;
+    const points = (_a = question.points) != null ? _a : 0;
+    const correctAnswer = question.correctAnswer;
+    let userAnswer = answer;
+    if (typeof answer === "string") {
+      userAnswer = answer.toLowerCase() === "true";
+    }
+    const isCorrect = typeof userAnswer === "boolean" && userAnswer === correctAnswer;
+    const correctAnswerDetail = {
+      id: null,
+      value: correctAnswer
+    };
+    return Promise.resolve({
+      isCorrect,
+      correctAnswer: correctAnswerDetail,
+      pointsEarned: isCorrect ? points : 0
+    });
+  }
+};
+
+// src/services/evaluators/short-answer-evaluator.ts
+var ShortAnswerEvaluator = class {
+  async evaluate(question, answer) {
+    var _a, _b;
+    const points = (_a = question.points) != null ? _a : 0;
+    let isCorrect = false;
+    if (typeof answer === "string") {
+      const userAnswerTrimmed = answer.trim();
+      const caseSensitive = (_b = question.isCaseSensitive) != null ? _b : false;
+      isCorrect = question.acceptedAnswers.some(
+        (accAns) => caseSensitive ? accAns.trim() === userAnswerTrimmed : accAns.trim().toLowerCase() === userAnswerTrimmed.toLowerCase()
+      );
+    }
+    const correctAnswerDetail = {
+      id: null,
+      value: question.acceptedAnswers
+    };
+    return Promise.resolve({
+      isCorrect,
+      correctAnswer: correctAnswerDetail,
+      pointsEarned: isCorrect ? points : 0
+    });
+  }
+};
+
+// src/services/evaluators/numeric-evaluator.ts
+var NumericEvaluator = class {
+  async evaluate(question, answer) {
+    var _a;
+    const points = (_a = question.points) != null ? _a : 0;
+    let isCorrect = false;
+    if (typeof answer === "string" || typeof answer === "number") {
+      const userAnswerNum = parseFloat(String(answer));
+      if (!isNaN(userAnswerNum)) {
+        isCorrect = question.tolerance != null ? Math.abs(userAnswerNum - question.answer) <= question.tolerance : userAnswerNum === question.answer;
+      }
+    }
+    const correctAnswerDetail = {
+      id: null,
+      value: question.answer
+    };
+    return Promise.resolve({
+      isCorrect,
+      correctAnswer: correctAnswerDetail,
+      pointsEarned: isCorrect ? points : 0
+    });
+  }
+};
+
+// src/services/evaluators/sequence-evaluator.ts
+var SequenceEvaluator = class {
+  async evaluate(question, answer) {
+    var _a;
+    const points = (_a = question.points) != null ? _a : 0;
+    let isCorrect = false;
+    if (Array.isArray(answer) && answer.length === question.correctOrder.length) {
+      isCorrect = answer.every((itemId, index) => itemId === question.correctOrder[index]);
+    }
+    const correctValues = question.correctOrder.map(
+      (id) => {
+        var _a2;
+        return ((_a2 = question.items.find((item) => item.id === id)) == null ? void 0 : _a2.content) || "";
+      }
+    );
+    const correctAnswerDetail = {
+      id: question.correctOrder,
+      value: correctValues
+    };
+    return Promise.resolve({
+      isCorrect,
+      correctAnswer: correctAnswerDetail,
+      pointsEarned: isCorrect ? points : 0
+    });
+  }
+};
+
+// src/services/evaluators/matching-evaluator.ts
+var MatchingEvaluator = class {
+  async evaluate(question, answer) {
+    var _a;
+    const points = (_a = question.points) != null ? _a : 0;
+    let isCorrect = false;
+    if (typeof answer === "object" && answer !== null && !Array.isArray(answer)) {
+      const userAnswerMap = answer;
+      isCorrect = question.correctAnswerMap.length === Object.keys(userAnswerMap).length && question.correctAnswerMap.every((map) => userAnswerMap[map.promptId] === map.optionId);
+    }
+    const correctMap = question.correctAnswerMap.reduce((acc, curr) => {
+      var _a2, _b;
+      const promptText = ((_a2 = question.prompts.find((p) => p.id === curr.promptId)) == null ? void 0 : _a2.content) || "";
+      const optionText = ((_b = question.options.find((o) => o.id === curr.optionId)) == null ? void 0 : _b.content) || "";
+      acc[promptText] = optionText;
+      return acc;
+    }, {});
+    const correctAnswerDetail = {
+      id: null,
+      value: correctMap
+    };
+    return Promise.resolve({
+      isCorrect,
+      correctAnswer: correctAnswerDetail,
+      pointsEarned: isCorrect ? points : 0
+    });
+  }
+};
+
+// src/services/evaluators/fill-in-the-blanks-evaluator.ts
+var FillInTheBlanksEvaluator = class {
+  async evaluate(question, answer) {
+    var _a;
+    const points = (_a = question.points) != null ? _a : 0;
+    let isCorrect = false;
+    if (typeof answer === "object" && answer !== null && !Array.isArray(answer)) {
+      const userAnswerMap = answer;
+      isCorrect = question.answers.length > 0 && question.answers.every((correctAnsDef) => {
+        var _a2, _b;
+        const userValForBlank = (_a2 = userAnswerMap[correctAnsDef.blankId]) == null ? void 0 : _a2.trim();
+        if (userValForBlank === void 0) return false;
+        const caseSensitive = (_b = question.isCaseSensitive) != null ? _b : false;
+        return correctAnsDef.acceptedValues.some(
+          (accVal) => caseSensitive ? accVal.trim() === userValForBlank : accVal.trim().toLowerCase() === userValForBlank.toLowerCase()
+        );
+      });
+    }
+    const correctMap = question.answers.reduce((acc, curr) => {
+      acc[curr.blankId] = curr.acceptedValues.join(" | ");
+      return acc;
+    }, {});
+    const correctAnswerDetail = {
+      id: null,
+      value: correctMap
+    };
+    return Promise.resolve({
+      isCorrect,
+      correctAnswer: correctAnswerDetail,
+      pointsEarned: isCorrect ? points : 0
+    });
+  }
+};
+
+// src/services/evaluators/drag-and-drop-evaluator.ts
+var DragAndDropEvaluator = class {
+  async evaluate(question, answer) {
+    var _a;
+    const points = (_a = question.points) != null ? _a : 0;
+    let isCorrect = false;
+    if (typeof answer === "object" && answer !== null && !Array.isArray(answer)) {
+      const userAnswerMap = answer;
+      isCorrect = question.answerMap.length === Object.keys(userAnswerMap).length && question.answerMap.every((map) => userAnswerMap[map.draggableId] === map.dropZoneId);
+    }
+    const correctMap = question.answerMap.reduce((acc, curr) => {
+      var _a2, _b;
+      const draggableText = ((_a2 = question.draggableItems.find((d) => d.id === curr.draggableId)) == null ? void 0 : _a2.content) || "";
+      const dropZoneText = ((_b = question.dropZones.find((z4) => z4.id === curr.dropZoneId)) == null ? void 0 : _b.label) || "";
+      acc[draggableText] = dropZoneText;
+      return acc;
+    }, {});
+    const correctAnswerDetail = {
+      id: null,
+      value: correctMap
+    };
+    return Promise.resolve({
+      isCorrect,
+      correctAnswer: correctAnswerDetail,
+      pointsEarned: isCorrect ? points : 0
+    });
+  }
+};
+
+// src/services/evaluators/hotspot-evaluator.ts
+var HotspotEvaluator = class {
+  async evaluate(question, answer) {
+    var _a;
+    const points = (_a = question.points) != null ? _a : 0;
+    let isCorrect = false;
+    if (Array.isArray(answer)) {
+      const userAnswerSet = new Set(answer);
+      const correctAnswerSet = new Set(question.correctHotspotIds);
+      isCorrect = userAnswerSet.size === correctAnswerSet.size && [...userAnswerSet].every((id) => correctAnswerSet.has(id));
+    }
+    const correctValues = question.correctHotspotIds.map(
+      (id) => {
+        var _a2;
+        return ((_a2 = question.hotspots.find((h) => h.id === id)) == null ? void 0 : _a2.description) || id;
+      }
+    );
+    const correctAnswerDetail = {
+      id: question.correctHotspotIds,
+      value: correctValues
+    };
+    return Promise.resolve({
+      isCorrect,
+      correctAnswer: correctAnswerDetail,
+      pointsEarned: isCorrect ? points : 0
+    });
+  }
+};
+
+// src/services/evaluators/programming-evaluator.ts
+var ProgrammingEvaluator = class {
+  async evaluate(question, answer) {
+    var _a, _b;
+    const points = (_a = question.points) != null ? _a : 0;
+    let isCorrect = false;
+    if (typeof answer === "string" && typeof question.solutionGeneratedCode === "string") {
+      if (typeof window !== "undefined" && ((_b = window.Blockly) == null ? void 0 : _b.JavaScript)) {
+        const LocalBlockly = window.Blockly;
+        let generatedUserCode = "";
+        try {
+          const tempWorkspace = new LocalBlockly.Workspace();
+          const dom = LocalBlockly.Xml.textToDom(answer);
+          LocalBlockly.Xml.domToWorkspace(dom, tempWorkspace);
+          generatedUserCode = LocalBlockly.JavaScript.workspaceToCode(tempWorkspace) || "";
+          const normalize = (code) => code.replace(/\s+/g, " ").trim();
+          isCorrect = normalize(generatedUserCode) === normalize(question.solutionGeneratedCode);
+          tempWorkspace.dispose();
+        } catch (e) {
+          console.error(`Error generating code from user's ${question.questionType} XML for evaluation:`, e);
+          isCorrect = false;
+        }
+      } else {
+        console.warn(`Blockly library not available for ${question.questionType} evaluation. Skipping code comparison.`);
+        isCorrect = false;
+      }
+    }
+    const correctAnswerDetail = {
+      id: null,
+      value: question.solutionGeneratedCode || ""
+    };
+    return Promise.resolve({
+      isCorrect,
+      correctAnswer: correctAnswerDetail,
+      pointsEarned: isCorrect ? points : 0
+    });
+  }
+};
+
+// src/utils/jsonUtils.ts
+var JsonRepairEngine = class {
+  /**
+   * Attempts to repair unterminated strings in JSON.
+   * NOTE: This is a heuristic approach and may not be perfect for all cases.
+   */
+  static repairUnterminatedStrings(jsonStr) {
+    let repaired = jsonStr;
+    let inString = false;
+    let escaped = false;
+    let lastQuoteIndex = -1;
+    for (let i = 0; i < repaired.length; i++) {
+      const char = repaired[i];
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (char === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (char === '"') {
+        inString = !inString;
+        if (inString) {
+          lastQuoteIndex = i;
+        }
+      }
+    }
+    if (inString && lastQuoteIndex !== -1) {
+      const beforeUnterminated = repaired.substring(0, lastQuoteIndex + 1);
+      const afterUnterminated = repaired.substring(lastQuoteIndex + 1);
+      const breakPoints = [",", "}", "]", "\n"];
+      let breakIndex = -1;
+      for (let i = 0; i < afterUnterminated.length; i++) {
+        if (breakPoints.includes(afterUnterminated[i])) {
+          breakIndex = i;
+          break;
+        }
+      }
+      if (breakIndex !== -1) {
+        const stringContent = afterUnterminated.substring(0, breakIndex);
+        const remainder = afterUnterminated.substring(breakIndex);
+        const escapedContent = stringContent.replace(new RegExp('(?<!\\\\)"', "g"), '\\"');
+        repaired = beforeUnterminated + escapedContent + '"' + remainder;
+      } else {
+        const escapedContent = afterUnterminated.replace(new RegExp('(?<!\\\\)"', "g"), '\\"');
+        repaired = beforeUnterminated + escapedContent + '"';
+      }
+    }
+    return repaired;
+  }
+  // FIX: Replaced unsafe single quote replacement with a stateful parser.
+  /**
+   * Safely replaces single quotes with double quotes only for keys and string values,
+   * ignoring apostrophes inside already double-quoted strings.
+   */
+  static safelyFixQuotes(jsonStr) {
+    let result = "";
+    let inDoubleQuoteString = false;
+    let escaped = false;
+    for (let i = 0; i < jsonStr.length; i++) {
+      const char = jsonStr[i];
+      if (escaped) {
+        result += char;
+        escaped = false;
+        continue;
+      }
+      if (char === "\\") {
+        escaped = true;
+        result += char;
+        continue;
+      }
+      if (char === '"') {
+        inDoubleQuoteString = !inDoubleQuoteString;
+      }
+      if (char === "'" && !inDoubleQuoteString) {
+        result += '"';
+      } else {
+        result += char;
+      }
+    }
+    return result;
+  }
+  /**
+   * Fixes common JSON formatting issues using more robust methods.
+   */
+  static applyCommonFixes(jsonStr) {
+    let fixed = jsonStr;
+    fixed = this.safelyFixQuotes(fixed);
+    fixed = fixed.replace(/,\s*([}\]])/g, "$1");
+    fixed = fixed.replace(/("|}|\d|]|true|false|null)\s*\n\s*(")/g, "$1,\n$2");
+    fixed = fixed.replace(/"[\s\S]*?"/g, (match) => {
+      const content = match.substring(1, match.length - 1);
+      const fixedContent = content.replace(/\n/g, "\\n").replace(/\r/g, "\\r");
+      return `"${fixedContent}"`;
+    });
+    fixed = fixed.replace(/"(true|false|null)"/g, "$1");
+    return fixed;
+  }
+  /**
+   * Validates JSON by attempting to parse and providing detailed error info.
+   */
+  static validateAndGetError(jsonStr) {
+    try {
+      JSON.parse(jsonStr);
+      return { isValid: true };
+    } catch (error) {
+      const errorMessage = error.message || "";
+      const positionMatch = errorMessage.match(/position (\d+)/);
+      const position = positionMatch ? parseInt(positionMatch[1], 10) : void 0;
+      return {
+        isValid: false,
+        error: errorMessage,
+        position
+      };
+    }
+  }
+  /**
+   * Main repair function that attempts multiple strategies.
+   */
+  static repairJson(jsonStr) {
+    var _a;
+    let current = jsonStr.trim();
+    const maxAttempts = 5;
+    let lastError = "";
+    let lastPosition = -1;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const validation = this.validateAndGetError(current);
+      if (validation.isValid) {
+        return current;
+      }
+      console.warn(`JSON repair attempt ${attempt + 1}: ${validation.error}`);
+      if (validation.error === lastError && validation.position === lastPosition) {
+        console.error("Repair attempt stuck on the same error, aborting this strategy.");
+        if (validation.position) {
+          const truncated = current.substring(0, validation.position);
+          const openBraces = (truncated.match(/{/g) || []).length;
+          const closeBraces = (truncated.match(/}/g) || []).length;
+          const openBrackets = (truncated.match(/\[/g) || []).length;
+          const closeBrackets = (truncated.match(/\]/g) || []).length;
+          let repaired = truncated.replace(/,\s*$/, "");
+          for (let i = 0; i < openBrackets - closeBrackets; i++) repaired += "]";
+          for (let i = 0; i < openBraces - closeBraces; i++) repaired += "}";
+          current = repaired;
+          const finalValidation = this.validateAndGetError(current);
+          if (finalValidation.isValid) return current;
+        }
+        break;
+      }
+      lastError = validation.error || "";
+      lastPosition = validation.position;
+      if ((_a = validation.error) == null ? void 0 : _a.includes("Unterminated string")) {
+        current = this.repairUnterminatedStrings(current);
+      } else {
+        current = this.applyCommonFixes(current);
+      }
+    }
+    try {
+      let finalAttempt = this.applyCommonFixes(jsonStr.trim());
+      finalAttempt = this.repairUnterminatedStrings(finalAttempt);
+      JSON.parse(finalAttempt);
+      return finalAttempt;
+    } catch (e) {
+      throw new Error(`Unable to repair JSON after ${maxAttempts} attempts. Last known error: ${lastError}`);
+    }
+  }
+};
+function extractJsonFromMarkdown(text) {
+  if (!text) {
+    throw new Error("Input text is empty or null.");
+  }
+  const trimmedText = text.trim();
+  try {
+    JSON.parse(trimmedText);
+    return trimmedText;
+  } catch (e) {
+  }
+  const markdownPatterns = [
+    /```(?:json|JSON)\s*([\s\S]*?)\s*```/,
+    // ```json ... ```
+    /```\s*({[\s\S]*?}|\[[\s\S]*?\])\s*```/
+    // ``` { ... } ``` or ``` [ ... ] ```
+  ];
+  for (const pattern of markdownPatterns) {
+    const match = trimmedText.match(pattern);
+    if (match && match[1]) {
+      const content = match[1].trim();
+      try {
+        JSON.parse(content);
+        return content;
+      } catch (e) {
+        console.warn("JSON inside markdown block is invalid, attempting repair...");
+        try {
+          return JsonRepairEngine.repairJson(content);
+        } catch (repairError) {
+          console.warn(`Markdown block repair failed: ${repairError.message}. Trying other strategies...`);
+        }
+      }
+    }
+  }
+  const firstBrace = trimmedText.indexOf("{");
+  const firstBracket = trimmedText.indexOf("[");
+  let startIndex = -1;
+  if (firstBrace === -1 && firstBracket === -1) ; else if (firstBrace === -1) {
+    startIndex = firstBracket;
+  } else if (firstBracket === -1) {
+    startIndex = firstBrace;
+  } else {
+    startIndex = Math.min(firstBrace, firstBracket);
+  }
+  if (startIndex !== -1) {
+    const textToProcess = trimmedText.substring(startIndex);
+    let balance = 0;
+    let inString = false;
+    let escaped = false;
+    const startChar = textToProcess[0];
+    const endChar = startChar === "{" ? "}" : "]";
+    for (let i = 0; i < textToProcess.length; i++) {
+      const char = textToProcess[i];
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (char === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (char === '"') {
+        inString = !inString;
+      }
+      if (!inString) {
+        if (char === startChar) balance++;
+        if (char === endChar) balance--;
+      }
+      if (balance === 0 && i > 0) {
+        const potentialJson = textToProcess.substring(0, i + 1);
+        try {
+          JSON.parse(potentialJson);
+          return potentialJson;
+        } catch (e) {
+          console.warn(`Balanced JSON segment is invalid, attempting repair...`);
+          try {
+            return JsonRepairEngine.repairJson(potentialJson);
+          } catch (repairError) {
+            console.warn(`Repair failed for balanced segment: ${repairError.message}`);
+          }
+        }
+        break;
+      }
+    }
+  }
+  console.warn("All extraction strategies failed, attempting to repair the entire input text as a last resort.");
+  try {
+    return JsonRepairEngine.repairJson(trimmedText);
+  } catch (finalError) {
+    throw new Error(`Unable to extract or repair valid JSON from AI response. Preview: "${trimmedText.substring(0, 100)}...". Final error: ${finalError.message}`);
+  }
+}
+z.object({
+  language: z.custom(),
+  problemPrompt: z.string(),
+  userCode: z.string(),
+  testCase: z.custom()
+});
+var AIEvaluationOutputSchema = z.object({
+  passed: z.boolean().describe("Did the user's code produce the expected output for the given input?"),
+  actualOutput: z.any().describe("The actual output produced by the user's code."),
+  reasoning: z.string().describe("A brief explanation of why the code passed or failed, or if there was a syntax error.")
+});
+var EvaluateUserCodeOutputSchema = AIEvaluationOutputSchema;
+
+// src/ai/flows/evaluate-user-code.ts
+async function evaluateUserCode(clientInput, apiKey) {
+  try {
+    const ai = genkit({
+      plugins: [googleAI({ apiKey })],
+      model: gemini20Flash
+    });
+    const { language, problemPrompt, userCode, testCase } = clientInput;
+    const promptText = `
+You are an expert Code Judge and Teaching Assistant for a ${language} programming course.
+Your task is to evaluate a student's code submission for a specific problem against a single test case.
+
+## Problem Description
+${problemPrompt}
+
+## Student's Code Submission
+\`\`\`${language}
+${userCode}
+\`\`\`
+
+## Test Case to Evaluate
+- Input(s): ${JSON.stringify(testCase.input)}
+- Expected Output: ${JSON.stringify(testCase.expectedOutput)}
+
+## Your Task
+1.  **Analyze Execution:** Mentally execute the student's code with the provided input(s).
+2.  **Determine Output:** Figure out what the actual output of the code would be.
+3.  **Compare:** Compare the actual output with the expected output.
+4.  **Handle Errors:** If the code has a syntax error or would crash, treat it as a failure.
+5.  **Provide Reasoning:** Briefly explain your conclusion. If it failed, explain why (e.g., "incorrect result", "infinite loop", "syntax error on line 5").
+
+**CRITICAL JSON OUTPUT FORMAT:**
+Return ONLY the JSON object with this EXACT structure.
+
+\`\`\`json
+{
+  "passed": false,
+  "actualOutput": 5,
+  "reasoning": "The function correctly summed the numbers but did not filter for only even numbers."
+}
+\`\`\`
+
+Return only the JSON response.`;
+    const response = await ai.generate(promptText);
+    const rawText = response.text;
+    const jsonText = extractJsonFromMarkdown(rawText);
+    const aiGeneratedContent = JSON.parse(jsonText);
+    return EvaluateUserCodeOutputSchema.parse(aiGeneratedContent);
+  } catch (error) {
+    console.error("Error evaluating user code:", error);
+    if (error instanceof z.ZodError) {
+      throw new Error(`AI evaluation output validation failed: ${error.message}`);
+    }
+    return {
+      passed: false,
+      actualOutput: "Evaluation Error",
+      reasoning: `The AI judge failed to process the code. Error: ${error.message}`
+    };
+  }
+}
+
+// src/services/APIKeyService.ts
+var GEMINI_API_KEY_SERVICE_NAME = "gemini";
+var LOCAL_STORAGE_PREFIX = "iqk_api_keys_";
+function _encode(data) {
+  if (typeof window !== "undefined" && typeof window.btoa === "function") {
+    try {
+      return window.btoa(data);
+    } catch (e) {
+      console.error("Base64 encoding (btoa) failed:", e);
+      return data;
+    }
+  }
+  return data;
+}
+function _decode(data) {
+  if (typeof window !== "undefined" && typeof window.atob === "function") {
+    try {
+      return window.atob(data);
+    } catch (e) {
+      console.error("Base64 decoding (atob) failed:", e);
+      return data;
+    }
+  }
+  return data;
+}
+var APIKeyService = class {
+  static getStorageKey(serviceName) {
+    return `${LOCAL_STORAGE_PREFIX}${serviceName}`;
+  }
+  /**
+   * Saves an API key to localStorage. The key is mildly obfuscated using Base64.
+   * @param serviceName - The name of the service (e.g., 'gemini').
+   * @param apiKey - The API key to save.
+   */
+  static saveAPIKey(serviceName, apiKey) {
+    if (typeof window !== "undefined" && window.localStorage) {
+      try {
+        const encodedKey = _encode(apiKey);
+        localStorage.setItem(this.getStorageKey(serviceName), encodedKey);
+      } catch (e) {
+        console.error(`Error saving API key for ${serviceName} to localStorage:`, e);
+      }
+    } else {
+      console.warn("localStorage is not available. APIKeyService cannot save keys.");
+    }
+  }
+  /**
+   * Retrieves an API key from localStorage.
+   * @param serviceName - The name of the service.
+   * @returns The decoded API key, or null if not found or if localStorage is unavailable.
+   */
+  static getAPIKey(serviceName) {
+    if (typeof window !== "undefined" && window.localStorage) {
+      try {
+        const storedKey = localStorage.getItem(this.getStorageKey(serviceName));
+        if (storedKey) {
+          return _decode(storedKey);
+        }
+      } catch (e) {
+        console.error(`Error retrieving API key for ${serviceName} from localStorage:`, e);
+      }
+    }
+    return null;
+  }
+  /**
+   * Removes an API key from localStorage.
+   * @param serviceName - The name of the service.
+   */
+  static removeAPIKey(serviceName) {
+    if (typeof window !== "undefined" && window.localStorage) {
+      try {
+        localStorage.removeItem(this.getStorageKey(serviceName));
+      } catch (e) {
+        console.error(`Error removing API key for ${serviceName} from localStorage:`, e);
+      }
+    }
+  }
+  /**
+   * Checks if an API key exists in localStorage for the given service.
+   * @param serviceName - The name of the service.
+   * @returns True if a key exists, false otherwise.
+   */
+  static hasAPIKey(serviceName) {
+    return this.getAPIKey(serviceName) !== null;
+  }
+};
+
+// src/services/CodeEvaluationService.ts
+var CodeEvaluationService = class {
+  constructor() {
+    this.apiKey = APIKeyService.getAPIKey(GEMINI_API_KEY_SERVICE_NAME);
+  }
+  /**
+   * Evaluates a user's code against a single test case using an AI judge.
+   * @param question The full CodingQuestion object.
+   * @param userCode The user's submitted code string.
+   * @param testCase The specific TestCase to evaluate against.
+   * @returns A promise that resolves to an EvaluationResult object.
+   */
+  async evaluateSingleTestCase(question, userCode, testCase) {
+    if (!this.apiKey) {
+      return {
+        testCaseId: testCase.id,
+        passed: false,
+        actualOutput: "Configuration Error",
+        reasoning: "API Key is not configured."
+      };
+    }
+    const aiResult = await evaluateUserCode({
+      language: question.language,
+      problemPrompt: question.prompt,
+      userCode,
+      testCase
+    }, this.apiKey);
+    return __spreadValues({
+      testCaseId: testCase.id
+    }, aiResult);
+  }
+  /**
+   * Evaluates user's code against all test cases for a given question.
+   * @param question The full CodingQuestion object.
+   * @param userCode The user's submitted code string.
+   * @returns A promise that resolves to an array of EvaluationResult objects.
+   */
+  async evaluateAllTestCases(question, userCode) {
+    const results = [];
+    for (const testCase of question.testCases) {
+      const result = await this.evaluateSingleTestCase(question, userCode, testCase);
+      results.push(result);
+    }
+    return results;
+  }
+  /**
+   * Evaluates user's code against only the public test cases for a given question.
+   * Useful for a "Run Tests" button before final submission.
+   * @param question The full CodingQuestion object.
+   * @param userCode The user's submitted code string.
+   * @returns A promise that resolves to an array of EvaluationResult objects.
+   */
+  async evaluatePublicTestCases(question, userCode) {
+    const publicTestCases = question.testCases.filter((tc) => tc.isPublic);
+    const results = [];
+    for (const testCase of publicTestCases) {
+      const result = await this.evaluateSingleTestCase(question, userCode, testCase);
+      results.push(result);
+    }
+    return results;
+  }
+};
+
+// src/services/evaluators/coding-evaluator.ts
+var CodingEvaluator = class {
+  async evaluate(question, answer) {
+    var _a;
+    const points = (_a = question.points) != null ? _a : 0;
+    if (typeof answer !== "string" || !answer.trim()) {
+      return {
+        isCorrect: false,
+        correctAnswer: { id: null, value: question.solutionCode },
+        pointsEarned: 0,
+        evaluationDetails: question.testCases.map((tc) => ({
+          testCaseId: tc.id,
+          passed: false,
+          actualOutput: "No submission",
+          reasoning: "User did not submit any code."
+        }))
+      };
+    }
+    try {
+      const evaluationService = new CodeEvaluationService();
+      const testCaseResults = await evaluationService.evaluateAllTestCases(question, answer);
+      const isCorrect = testCaseResults.every((result) => result.passed);
+      const correctAnswerDetail = {
+        id: null,
+        value: question.solutionCode
+      };
+      return {
+        isCorrect,
+        correctAnswer: correctAnswerDetail,
+        pointsEarned: isCorrect ? points : 0,
+        evaluationDetails: testCaseResults
+        // Pass through the detailed results
+      };
+    } catch (error) {
+      console.error("A critical error occurred during code evaluation:", error);
+      return {
+        isCorrect: false,
+        correctAnswer: { id: null, value: question.solutionCode },
+        pointsEarned: 0,
+        evaluationDetails: question.testCases.map((tc) => ({
+          testCaseId: tc.id,
+          passed: false,
+          actualOutput: "Evaluation Error",
+          reasoning: error instanceof Error ? error.message : "An unknown error occurred."
+        }))
+      };
+    }
+  }
+};
+
+// src/services/QuizEngine.ts
+var QuizEngine = class {
+  constructor(options) {
+    this.userAnswers = /* @__PURE__ */ new Map();
+    this.currentQuestionIndex = 0;
+    this.timerId = null;
+    this.timeLeftInSeconds = null;
+    this.scormService = null;
+    this.quizResultState = { scormStatus: "idle" };
+    this.questionStartTime = null;
+    this.questionTimings = /* @__PURE__ */ new Map();
+    var _a, _b, _c, _d, _e;
+    this.config = options.config;
+    this.callbacks = options.callbacks || {};
+    this.questions = ((_a = this.config.settings) == null ? void 0 : _a.shuffleQuestions) ? [...this.config.questions].sort(() => Math.random() - 0.5) : this.config.questions;
+    this.overallStartTime = Date.now();
+    this.evaluators = /* @__PURE__ */ new Map();
+    this.registerEvaluators();
+    if (((_b = this.config.settings) == null ? void 0 : _b.timeLimitMinutes) && this.config.settings.timeLimitMinutes > 0) {
+      this.timeLeftInSeconds = this.config.settings.timeLimitMinutes * 60;
+    }
+    if ((_c = this.config.settings) == null ? void 0 : _c.scorm) {
+      this.quizResultState.scormStatus = "initializing";
+      this.scormService = new SCORMService(this.config.settings.scorm);
+      if (this.scormService.hasAPI()) {
+        const initResult = this.scormService.initialize();
+        if (initResult.success) {
+          this.quizResultState.scormStatus = "initialized";
+          this.quizResultState.studentName = initResult.studentName;
+        } else {
+          this.quizResultState.scormStatus = "error";
+          this.quizResultState.scormError = initResult.error || "SCORM initialization failed.";
+        }
+      } else {
+        this.quizResultState.scormStatus = "no_api";
+      }
+    }
+    const initialQ = this.getCurrentQuestion();
+    if (initialQ) {
+      this.questionStartTime = Date.now();
+    }
+    if (this.callbacks.onQuizStart) {
+      this.callbacks.onQuizStart({
+        initialQuestion: initialQ,
+        currentQuestionNumber: this.getCurrentQuestionNumber(),
+        totalQuestions: this.getTotalQuestions(),
+        timeLimitInSeconds: this.timeLeftInSeconds,
+        scormStatus: this.quizResultState.scormStatus,
+        studentName: this.quizResultState.studentName
+      });
+    }
+    if (this.timeLeftInSeconds !== null) {
+      this.startTimer();
+    }
+    (_e = (_d = this.callbacks).onQuestionChange) == null ? void 0 : _e.call(_d, initialQ, this.getCurrentQuestionNumber(), this.getTotalQuestions());
+  }
+  registerEvaluators() {
+    this.evaluators.set("multiple_choice", new MultipleChoiceEvaluator());
+    this.evaluators.set("multiple_response", new MultipleResponseEvaluator());
+    this.evaluators.set("true_false", new TrueFalseEvaluator());
+    this.evaluators.set("short_answer", new ShortAnswerEvaluator());
+    this.evaluators.set("numeric", new NumericEvaluator());
+    this.evaluators.set("sequence", new SequenceEvaluator());
+    this.evaluators.set("matching", new MatchingEvaluator());
+    this.evaluators.set("fill_in_the_blanks", new FillInTheBlanksEvaluator());
+    this.evaluators.set("drag_and_drop", new DragAndDropEvaluator());
+    this.evaluators.set("hotspot", new HotspotEvaluator());
+    const programmingEvaluator = new ProgrammingEvaluator();
+    this.evaluators.set("blockly_programming", programmingEvaluator);
+    this.evaluators.set("scratch_programming", programmingEvaluator);
+    this.evaluators.set("coding", new CodingEvaluator());
+  }
+  _recordCurrentQuestionTime() {
+    if (this.questionStartTime && this.currentQuestionIndex >= 0 && this.currentQuestionIndex < this.questions.length) {
+      const currentQId = this.questions[this.currentQuestionIndex].id;
+      const elapsedMs = Date.now() - this.questionStartTime;
+      const currentTotalTime = this.questionTimings.get(currentQId) || 0;
+      this.questionTimings.set(currentQId, currentTotalTime + elapsedMs / 1e3);
+    }
+    this.questionStartTime = null;
+  }
+  startTimer() {
+    if (this.timerId !== null) clearInterval(this.timerId);
+    this.timerId = setInterval(() => this.handleTick(), 1e3);
+  }
+  stopTimer() {
+    if (this.timerId !== null) {
+      clearInterval(this.timerId);
+      this.timerId = null;
+    }
+  }
+  handleTick() {
+    var _a, _b, _c, _d;
+    if (this.timeLeftInSeconds === null) return;
+    if (this.timeLeftInSeconds > 0) {
+      this.timeLeftInSeconds--;
+      (_b = (_a = this.callbacks).onTimeTick) == null ? void 0 : _b.call(_a, this.timeLeftInSeconds);
+    }
+    if (this.timeLeftInSeconds <= 0) {
+      this.stopTimer();
+      (_d = (_c = this.callbacks).onQuizTimeUp) == null ? void 0 : _d.call(_c);
+      this.calculateResults();
+    }
+  }
+  getTimeLeftInSeconds() {
+    return this.timeLeftInSeconds;
+  }
+  getCurrentQuestion() {
+    return this.questions[this.currentQuestionIndex] || null;
+  }
+  getCurrentQuestionNumber() {
+    return this.currentQuestionIndex + 1;
+  }
+  getTotalQuestions() {
+    return this.questions.length;
+  }
+  getUserAnswer(questionId) {
+    return this.userAnswers.get(questionId);
+  }
+  isQuizFinished() {
+    return this.quizResultState.score !== void 0;
+  }
+  submitAnswer(questionId, answer) {
+    var _a, _b;
+    this.userAnswers.set(questionId, answer);
+    const question = this.questions.find((q) => q.id === questionId);
+    if (question) (_b = (_a = this.callbacks).onAnswerSubmit) == null ? void 0 : _b.call(_a, question, answer);
+  }
+  nextQuestion() {
+    var _a, _b;
+    this._recordCurrentQuestionTime();
+    if (this.currentQuestionIndex < this.questions.length - 1) {
+      this.currentQuestionIndex++;
+      const currentQ = this.getCurrentQuestion();
+      this.questionStartTime = Date.now();
+      (_b = (_a = this.callbacks).onQuestionChange) == null ? void 0 : _b.call(_a, currentQ, this.getCurrentQuestionNumber(), this.getTotalQuestions());
+      return currentQ;
+    }
+    return null;
+  }
+  previousQuestion() {
+    var _a, _b;
+    this._recordCurrentQuestionTime();
+    if (this.currentQuestionIndex > 0) {
+      this.currentQuestionIndex--;
+      const currentQ = this.getCurrentQuestion();
+      this.questionStartTime = Date.now();
+      (_b = (_a = this.callbacks).onQuestionChange) == null ? void 0 : _b.call(_a, currentQ, this.getCurrentQuestionNumber(), this.getTotalQuestions());
+      return currentQ;
+    }
+    return null;
+  }
+  goToQuestion(index) {
+    var _a, _b;
+    if (index >= 0 && index < this.questions.length && index !== this.currentQuestionIndex) {
+      this._recordCurrentQuestionTime();
+      this.currentQuestionIndex = index;
+      const currentQ = this.getCurrentQuestion();
+      this.questionStartTime = Date.now();
+      (_b = (_a = this.callbacks).onQuestionChange) == null ? void 0 : _b.call(_a, currentQ, this.getCurrentQuestionNumber(), this.getTotalQuestions());
+      return currentQ;
+    }
+    return this.getCurrentQuestion();
+  }
+  getElapsedTime() {
+    return Date.now() - this.overallStartTime;
+  }
+  destroy() {
+    this.stopTimer();
+    this._recordCurrentQuestionTime();
+    if (this.scormService && this.scormService.hasAPI()) {
+      if (["initialized", "committed", "sending_data"].includes(this.quizResultState.scormStatus || "")) {
+        const termResult = this.scormService.terminate();
+        if (termResult.success) {
+          this.quizResultState.scormStatus = "terminated";
+        } else {
+          this.quizResultState.scormStatus = "error";
+          this.quizResultState.scormError = termResult.error || "SCORM termination failed on destroy.";
+        }
+      }
+    }
+    this.scormService = null;
+  }
+  // (Tiếp theo từ Phần 1)
+  async calculateResults() {
+    var _a, _b, _c, _d, _e;
+    this.stopTimer();
+    this._recordCurrentQuestionTime();
+    let totalScore = 0;
+    let maxScore = 0;
+    const questionResultsArray = [];
+    let accumulatedTotalTimeSpent = 0;
+    for (const question of this.questions) {
+      const userAnswerRaw = this.userAnswers.get(question.id) || null;
+      maxScore += (_a = question.points) != null ? _a : 0;
+      const evaluator = this.evaluators.get(question.questionType);
+      if (!evaluator) {
+        console.warn(`No evaluator found for question type: ${question.questionType}`);
+        questionResultsArray.push({
+          questionId: question.id,
+          questionType: question.questionType,
+          prompt: question.prompt,
+          isCorrect: false,
+          pointsEarned: 0,
+          userAnswer: { id: null, value: userAnswerRaw },
+          correctAnswer: { id: null, value: "Evaluation not implemented." },
+          timeSpentSeconds: parseFloat((this.questionTimings.get(question.id) || 0).toFixed(2))
+        });
+        continue;
+      }
+      const {
+        isCorrect,
+        correctAnswer: correctAnswerDetail,
+        pointsEarned,
+        evaluationDetails
+      } = await evaluator.evaluate(question, userAnswerRaw);
+      totalScore += pointsEarned;
+      const timeSpentOnThisQuestion = parseFloat((this.questionTimings.get(question.id) || 0).toFixed(2));
+      accumulatedTotalTimeSpent += timeSpentOnThisQuestion;
+      const userAnswerDetail = this.formatUserAnswerDetail(question, userAnswerRaw);
+      questionResultsArray.push({
+        questionId: question.id,
+        questionType: question.questionType,
+        prompt: question.prompt,
+        isCorrect,
+        pointsEarned,
+        userAnswer: userAnswerDetail,
+        correctAnswer: correctAnswerDetail,
+        timeSpentSeconds: timeSpentOnThisQuestion,
+        evaluationDetails
+      });
+    }
+    const percentage = maxScore > 0 ? parseFloat((totalScore / maxScore * 100).toFixed(2)) : 0;
+    let passed = void 0;
+    if (((_b = this.config.settings) == null ? void 0 : _b.passingScorePercent) != null) {
+      passed = percentage >= this.config.settings.passingScorePercent;
+    }
+    const totalQuizTimeSpentSeconds = parseFloat(accumulatedTotalTimeSpent.toFixed(2));
+    const averageTimePerQuestionSeconds = this.questions.length > 0 ? parseFloat((totalQuizTimeSpentSeconds / this.questions.length).toFixed(2)) : 0;
+    const metadataPerformance = await this._calculateMetadataPerformance();
+    const finalResults = __spreadValues({
+      score: totalScore,
+      maxScore,
+      percentage,
+      answers: this.userAnswers,
+      questionResults: questionResultsArray,
+      passed,
+      webhookStatus: "idle",
+      scormStatus: this.quizResultState.scormStatus || "idle",
+      scormError: this.quizResultState.scormError,
+      studentName: this.quizResultState.studentName,
+      totalTimeSpentSeconds: totalQuizTimeSpentSeconds,
+      averageTimePerQuestionSeconds
+    }, metadataPerformance);
+    this.quizResultState = __spreadValues(__spreadValues({}, this.quizResultState), finalResults);
+    if ((_c = this.config.settings) == null ? void 0 : _c.scorm) this._sendResultsToSCORM(finalResults);
+    await this._sendResultsToWebhook(finalResults);
+    (_e = (_d = this.callbacks).onQuizFinish) == null ? void 0 : _e.call(_d, finalResults);
+    return finalResults;
+  }
+  formatUserAnswerDetail(question, userAnswerRaw) {
+    var _a, _b, _c, _d, _e;
+    if (userAnswerRaw === null) return null;
+    switch (question.questionType) {
+      case "multiple_choice": {
+        const q = question;
+        const id = userAnswerRaw;
+        return { id, value: ((_a = q.options.find((opt) => opt.id === id)) == null ? void 0 : _a.text) || "" };
+      }
+      case "multiple_response": {
+        const q = question;
+        const ids = userAnswerRaw;
+        const values = ids.map((id) => {
+          var _a2;
+          return ((_a2 = q.options.find((opt) => opt.id === id)) == null ? void 0 : _a2.text) || "";
+        });
+        return { id: ids, value: values };
+      }
+      case "sequence": {
+        const q = question;
+        const ids = userAnswerRaw;
+        const values = ids.map((id) => {
+          var _a2;
+          return ((_a2 = q.items.find((item) => item.id === id)) == null ? void 0 : _a2.content) || "";
+        });
+        return { id: ids, value: values };
+      }
+      case "matching": {
+        const q = question;
+        const userAnswerMap = userAnswerRaw;
+        const valueMap = {};
+        for (const promptId in userAnswerMap) {
+          const optionId = userAnswerMap[promptId];
+          const promptText = ((_b = q.prompts.find((p) => p.id === promptId)) == null ? void 0 : _b.content) || "";
+          const optionText = ((_c = q.options.find((o) => o.id === optionId)) == null ? void 0 : _c.content) || "";
+          valueMap[promptText] = optionText;
+        }
+        return { id: null, value: valueMap };
+      }
+      case "drag_and_drop": {
+        const q = question;
+        if (typeof userAnswerRaw === "object" && userAnswerRaw !== null && !Array.isArray(userAnswerRaw)) {
+          const userAnswerMapByIds = userAnswerRaw;
+          const enrichedUserAnswerMap = {};
+          for (const draggableId in userAnswerMapByIds) {
+            const dropZoneId = userAnswerMapByIds[draggableId];
+            const draggableText = ((_d = q.draggableItems.find((d) => d.id === draggableId)) == null ? void 0 : _d.content) || `(ID: ${draggableId})`;
+            const dropZoneText = ((_e = q.dropZones.find((z4) => z4.id === dropZoneId)) == null ? void 0 : _e.label) || `(ID: ${dropZoneId})`;
+            enrichedUserAnswerMap[draggableText] = dropZoneText;
+          }
+          return { id: null, value: enrichedUserAnswerMap };
+        }
+        return { id: null, value: userAnswerRaw };
+      }
+      default:
+        return { id: null, value: userAnswerRaw };
+    }
+  }
+  async _calculateMetadataPerformance() {
+    var _a;
+    const loPerformanceMap = /* @__PURE__ */ new Map();
+    const categoryPerformanceMap = /* @__PURE__ */ new Map();
+    const topicPerformanceMap = /* @__PURE__ */ new Map();
+    const difficultyPerformanceMap = /* @__PURE__ */ new Map();
+    const bloomLevelPerformanceMap = /* @__PURE__ */ new Map();
+    const updateMap = (map, key, points, isCorrect) => {
+      if (!key) return;
+      const current = map.get(key) || { totalQuestions: 0, correctQuestions: 0, pointsEarned: 0, maxPoints: 0 };
+      current.totalQuestions++;
+      current.maxPoints += points;
+      if (isCorrect) {
+        current.correctQuestions++;
+        current.pointsEarned += points;
+      }
+      map.set(key, current);
+    };
+    for (const q of this.questions) {
+      const userAnswer = this.userAnswers.get(q.id) || null;
+      const evaluator = this.evaluators.get(q.questionType);
+      if (evaluator) {
+        const { isCorrect } = await evaluator.evaluate(q, userAnswer);
+        const pointsForThisQuestion = (_a = q.points) != null ? _a : 0;
+        updateMap(loPerformanceMap, q.learningObjective, pointsForThisQuestion, isCorrect);
+        updateMap(categoryPerformanceMap, q.category, pointsForThisQuestion, isCorrect);
+        updateMap(topicPerformanceMap, q.topic, pointsForThisQuestion, isCorrect);
+        updateMap(difficultyPerformanceMap, q.difficulty, pointsForThisQuestion, isCorrect);
+        updateMap(bloomLevelPerformanceMap, q.bloomLevel, pointsForThisQuestion, isCorrect);
+      }
+    }
+    const formatPerformanceArray = (map, keyName) => {
+      return Array.from(map.entries()).map(([key, data]) => ({
+        [keyName]: key,
+        totalQuestions: data.totalQuestions,
+        correctQuestions: data.correctQuestions,
+        pointsEarned: data.pointsEarned,
+        maxPoints: data.maxPoints,
+        percentage: data.maxPoints > 0 ? parseFloat((data.pointsEarned / data.maxPoints * 100).toFixed(2)) : 0
+      }));
+    };
+    return {
+      performanceByLearningObjective: formatPerformanceArray(loPerformanceMap, "learningObjective"),
+      performanceByCategory: formatPerformanceArray(categoryPerformanceMap, "category"),
+      performanceByTopic: formatPerformanceArray(topicPerformanceMap, "topic"),
+      performanceByDifficulty: formatPerformanceArray(difficultyPerformanceMap, "difficulty"),
+      performanceByBloomLevel: formatPerformanceArray(bloomLevelPerformanceMap, "bloomLevel")
+    };
+  }
+  async _sendResultsToWebhook(results) {
+    var _a;
+    if (!((_a = this.config.settings) == null ? void 0 : _a.webhookUrl)) {
+      results.webhookStatus = "idle";
+      return;
+    }
+    results.webhookStatus = "sending";
+    try {
+      const response = await fetch(this.config.settings.webhookUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(results)
+      });
+      if (response.ok) {
+        results.webhookStatus = "success";
+      } else {
+        results.webhookStatus = "error";
+        results.webhookError = `Webhook returned status: ${response.status} ${response.statusText}`;
+        try {
+          const errorBody = await response.text();
+          results.webhookError += ` - Body: ${errorBody.substring(0, 200)}`;
+        } catch (e) {
+        }
+      }
+    } catch (error) {
+      results.webhookStatus = "error";
+      results.webhookError = error instanceof Error ? `Fetch error: ${error.message}` : "Unknown webhook error.";
+    }
+  }
+  _sendResultsToSCORM(results) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    if (!this.scormService || !this.scormService.hasAPI() || this.quizResultState.scormStatus === "no_api") {
+      results.scormStatus = this.quizResultState.scormStatus || "idle";
+      return;
+    }
+    if (this.quizResultState.scormStatus === "error" && ((_a = this.quizResultState.scormError) == null ? void 0 : _a.includes("initialization failed"))) {
+      results.scormStatus = "error";
+      results.scormError = this.quizResultState.scormError;
+      return;
+    }
+    results.scormStatus = "sending_data";
+    try {
+      this.scormService.setScore(results.score, results.maxScore, 0);
+      let lessonStatusSetting = "completed";
+      if (((_b = this.config.settings) == null ? void 0 : _b.passingScorePercent) !== void 0 && ((_c = this.config.settings) == null ? void 0 : _c.passingScorePercent) !== null) {
+        lessonStatusSetting = results.passed ? "passed" : "failed";
+      } else if ((_e = (_d = this.config.settings) == null ? void 0 : _d.scorm) == null ? void 0 : _e.setCompletionOnFinish) {
+        lessonStatusSetting = "completed";
+      }
+      this.scormService.setLessonStatus(lessonStatusSetting, results.passed);
+      if (results.totalTimeSpentSeconds !== void 0 && this.scormService.formatCMITime) {
+        const cmiTime = this.scormService.formatCMITime(results.totalTimeSpentSeconds);
+        const sessionTimeVar = ((_g = (_f = this.config.settings) == null ? void 0 : _f.scorm) == null ? void 0 : _g.sessionTimeVar) || (this.scormService.getSCORMVersion() === "2004" ? "cmi.session_time" : "cmi.core.session_time");
+        if (sessionTimeVar) this.scormService.setValue(sessionTimeVar, cmiTime);
+      }
+      const commitResult = this.scormService.commit();
+      if (commitResult.success) {
+        results.scormStatus = "committed";
+      } else {
+        results.scormStatus = "error";
+        results.scormError = commitResult.error || "SCORM commit failed.";
+      }
+    } catch (e) {
+      results.scormStatus = "error";
+      results.scormError = e instanceof Error ? e.message : "Unknown SCORM data sending error.";
+    }
+  }
+};
+
+// src/utils/idGenerators.ts
+function generateUniqueId(prefix = "id_") {
+  return prefix + Date.now().toString(36) + Math.random().toString(36).substring(2, 7);
+}
+
+// src/services/QuizEditorService.ts
+var QuizEditorService = class {
+  constructor(initialQuiz) {
+    this.quiz = JSON.parse(JSON.stringify(initialQuiz));
+  }
+  getQuiz() {
+    return this.quiz;
+  }
+  static createNewQuestionTemplate(type) {
+    const baseNewQuestion = {
+      id: generateUniqueId(`new_${type}_`),
+      questionType: type,
+      prompt: "",
+      points: 10,
+      difficulty: "medium"
+    };
+    switch (type) {
+      case "true_false":
+        return __spreadProps(__spreadValues({}, baseNewQuestion), { questionType: "true_false", correctAnswer: true });
+      case "multiple_choice":
+        return __spreadProps(__spreadValues({}, baseNewQuestion), { questionType: "multiple_choice", options: [], correctAnswerId: "" });
+      case "multiple_response":
+        return __spreadProps(__spreadValues({}, baseNewQuestion), { questionType: "multiple_response", options: [], correctAnswerIds: [] });
+      case "short_answer":
+        return __spreadProps(__spreadValues({}, baseNewQuestion), { questionType: "short_answer", acceptedAnswers: [""], isCaseSensitive: false });
+      case "numeric":
+        return __spreadProps(__spreadValues({}, baseNewQuestion), { questionType: "numeric", answer: 0 });
+      case "fill_in_the_blanks": {
+        const blankId = generateUniqueId("blank_");
+        return __spreadProps(__spreadValues({}, baseNewQuestion), {
+          questionType: "fill_in_the_blanks",
+          segments: [
+            { type: "text", content: "Your text before " },
+            { type: "blank", id: blankId },
+            { type: "text", content: " and after." }
+          ],
+          answers: [{ blankId, acceptedValues: [""] }],
+          isCaseSensitive: false
+        });
+      }
+      case "sequence":
+        return __spreadProps(__spreadValues({}, baseNewQuestion), { questionType: "sequence", items: [], correctOrder: [] });
+      case "matching":
+        return __spreadProps(__spreadValues({}, baseNewQuestion), { questionType: "matching", prompts: [], options: [], correctAnswerMap: [], shuffleOptions: true });
+      case "drag_and_drop":
+        return __spreadProps(__spreadValues({}, baseNewQuestion), { questionType: "drag_and_drop", draggableItems: [], dropZones: [], answerMap: [] });
+      case "hotspot":
+        return __spreadProps(__spreadValues({}, baseNewQuestion), { questionType: "hotspot", imageUrl: "", hotspots: [], correctHotspotIds: [] });
+      case "blockly_programming":
+        return __spreadProps(__spreadValues({}, baseNewQuestion), {
+          questionType: "blockly_programming",
+          toolboxDefinition: '<xml xmlns="https://developers.google.com/blockly/xml"></xml>',
+          initialWorkspace: "",
+          solutionWorkspaceXML: "",
+          solutionGeneratedCode: ""
+        });
+      case "scratch_programming":
+        return __spreadProps(__spreadValues({}, baseNewQuestion), {
+          questionType: "scratch_programming",
+          toolboxDefinition: '<xml xmlns="https://developers.google.com/blockly/xml"></xml>',
+          initialWorkspace: "",
+          solutionWorkspaceXML: "",
+          solutionGeneratedCode: ""
+        });
+      case "coding":
+        return __spreadProps(__spreadValues({}, baseNewQuestion), {
+          questionType: "coding",
+          language: "javascript",
+          solutionCode: "",
+          testCases: [],
+          functionSignature: "",
+          points: 25
+          // Coding questions are worth more by default
+        });
+      default:
+        const _exhaustiveCheck = type;
+        throw new Error(`Question type "${_exhaustiveCheck}" is not supported for creation.`);
+    }
+  }
+  addQuestion(question) {
+    const newQuestion = __spreadValues({}, question);
+    if (newQuestion.id.startsWith("new_")) {
+      newQuestion.id = generateUniqueId(`${newQuestion.questionType}_`);
+    }
+    this.quiz.questions.push(newQuestion);
+    return this.quiz;
+  }
+  updateQuestion(updatedQuestion) {
+    const questionIndex = this.quiz.questions.findIndex((q) => q.id === updatedQuestion.id);
+    if (questionIndex === -1) {
+      throw new Error(`Question with ID "${updatedQuestion.id}" not found.`);
+    }
+    this.quiz.questions[questionIndex] = updatedQuestion;
+    return this.quiz;
+  }
+  deleteQuestionByIndex(index) {
+    if (index < 0 || index >= this.quiz.questions.length) {
+      throw new Error(`Invalid index ${index} for question deletion.`);
+    }
+    this.quiz.questions.splice(index, 1);
+    return this.quiz;
+  }
+  moveQuestion(fromIndex, toIndex) {
+    if (fromIndex < 0 || fromIndex >= this.quiz.questions.length || toIndex < 0 || toIndex >= this.quiz.questions.length) {
+      throw new Error("Invalid index for moving question.");
+    }
+    const [movedItem] = this.quiz.questions.splice(fromIndex, 1);
+    this.quiz.questions.splice(toIndex, 0, movedItem);
+    return this.quiz;
+  }
+};
+var BaseRawQuestionSchema = z.object({
+  questionType: z.string(),
+  prompt: z.string().min(1, { message: "Prompt cannot be empty." }),
+  points: z.number().optional(),
+  explanation: z.string().optional(),
+  topic: z.string().optional(),
+  difficulty: z.enum(["easy", "medium", "hard"]).optional(),
+  bloomLevel: z.string().optional()
+});
+var RawMCQSchema = BaseRawQuestionSchema.extend({
+  questionType: z.literal("multiple_choice"),
+  options: z.array(z.string()).min(2, { message: "Multiple Choice questions need at least 2 options." }),
+  correctAnswer: z.string({ required_error: "A correct answer is required." })
+});
+var RawMRQSchema = BaseRawQuestionSchema.extend({
+  questionType: z.literal("multiple_response"),
+  options: z.array(z.string()).min(2, { message: "Multiple Response questions need at least 2 options." }),
+  correctAnswers: z.array(z.string()).min(1, { message: "At least one correct answer is required." })
+});
+var RawTFSchema = BaseRawQuestionSchema.extend({
+  questionType: z.literal("true_false"),
+  correctAnswer: z.boolean({ required_error: "A correct answer (true/false) is required." })
+});
+var RawSASchema = BaseRawQuestionSchema.extend({
+  questionType: z.literal("short_answer"),
+  acceptedAnswers: z.array(z.string()).min(1, { message: "At least one accepted answer is required." })
+});
+var RawNumericSchema = BaseRawQuestionSchema.extend({
+  questionType: z.literal("numeric"),
+  answer: z.number({ required_error: "A numeric answer is required." }),
+  tolerance: z.number().optional()
+});
+var RawSequenceSchema = BaseRawQuestionSchema.extend({
+  questionType: z.literal("sequence"),
+  items: z.array(z.string()).min(2, { message: "Sequence questions need at least 2 items." }),
+  correctOrder: z.array(z.string()).min(2)
+});
+var RawMatchingSchema = BaseRawQuestionSchema.extend({
+  questionType: z.literal("matching"),
+  prompts: z.array(z.string()).min(1),
+  options: z.array(z.string()).min(1),
+  correctAnswerMap: z.record(z.string(), { required_error: "A map of correct answers is required." })
+});
+var RawFITBSchema = BaseRawQuestionSchema.extend({
+  questionType: z.literal("fill_in_the_blanks"),
+  sentenceWithPlaceholders: z.string().includes("{{", { message: "Sentence must contain at least one placeholder like {{placeholder}}." }),
+  blanks: z.record(z.array(z.string()).min(1), { required_error: "Blanks definitions are required." })
+});
+var AnyRawQuestionSchema = z.discriminatedUnion("questionType", [
+  RawMCQSchema,
+  RawMRQSchema,
+  RawTFSchema,
+  RawSASchema,
+  RawNumericSchema,
+  RawSequenceSchema,
+  RawMatchingSchema,
+  RawFITBSchema
+]);
+var QuestionImportService = class {
+  static processJSON(jsonString) {
+    try {
+      const rawData = JSON.parse(jsonString);
+      if (!Array.isArray(rawData)) {
+        return { validQuestions: [], errors: [{ index: 0, message: "JSON content must be an array of question objects.", data: rawData }] };
+      }
+      return this.processRawObjects(rawData);
+    } catch (e) {
+      const message = e instanceof Error ? e.message : "Invalid JSON format.";
+      return { validQuestions: [], errors: [{ index: 0, message, data: jsonString.substring(0, 500) }] };
+    }
+  }
+  static processTSV(tsvString) {
+    const lines = tsvString.split(/\r?\n/).filter((line) => line.trim() !== "");
+    if (lines.length < 2) {
+      return { validQuestions: [], errors: [{ index: 0, message: "TSV file must have a header and at least one data row.", data: tsvString }] };
+    }
+    const header = lines.shift().split("	").map((h) => h.trim());
+    const rawObjects = [];
+    const errors = [];
+    lines.forEach((line, index) => {
+      const values = line.split("	");
+      const rowObject = {};
+      header.forEach((h, i) => {
+        var _a;
+        rowObject[h] = ((_a = values[i]) == null ? void 0 : _a.trim()) || "";
+      });
+      try {
+        const transformedObject = this.transformTsvRowToRawObject(rowObject);
+        rawObjects.push(transformedObject);
+      } catch (e) {
+        const message = e instanceof Error ? e.message : "Error transforming TSV row.";
+        errors.push({ index: index + 2, message, data: line });
+      }
+    });
+    const processedResult = this.processRawObjects(rawObjects);
+    return { validQuestions: processedResult.validQuestions, errors: [...errors, ...processedResult.errors] };
+  }
+  static processRawObjects(rawObjects) {
+    const validQuestions = [];
+    const errors = [];
+    rawObjects.forEach((rawQ, index) => {
+      try {
+        const validatedRawQ = AnyRawQuestionSchema.parse(rawQ);
+        const question = this.createQuestionFromRawObject(validatedRawQ);
+        validQuestions.push(question);
+      } catch (e) {
+        const message = e instanceof z.ZodError ? e.errors.map((err) => `${err.path.join(".")} - ${err.message}`).join("; ") : e instanceof Error ? e.message : "Unknown validation error.";
+        errors.push({ index: index + 1, message, data: rawQ });
+      }
+    });
+    return { validQuestions, errors };
+  }
+  static transformTsvRowToRawObject(row) {
+    const { questionType, prompt, options, correctAnswer, points, explanation, topic, difficulty, bloomLevel, tolerance } = row;
+    if (!questionType) throw new Error("`questionType` column is missing or empty.");
+    const base = {
+      questionType,
+      prompt,
+      points: points ? parseInt(points, 10) : void 0,
+      explanation,
+      topic,
+      difficulty,
+      bloomLevel
+    };
+    switch (questionType) {
+      case "multiple_choice":
+        return __spreadProps(__spreadValues({}, base), { options: options.split("|"), correctAnswer });
+      case "multiple_response":
+        return __spreadProps(__spreadValues({}, base), { options: options.split("|"), correctAnswers: correctAnswer.split("|") });
+      case "true_false":
+        return __spreadProps(__spreadValues({}, base), { correctAnswer: correctAnswer.toLowerCase() === "true" });
+      case "short_answer":
+        return __spreadProps(__spreadValues({}, base), { acceptedAnswers: correctAnswer.split("|") });
+      case "numeric":
+        return __spreadProps(__spreadValues({}, base), { answer: parseFloat(correctAnswer), tolerance: tolerance ? parseFloat(tolerance) : void 0 });
+      case "sequence":
+        return __spreadProps(__spreadValues({}, base), { items: options.split("|"), correctOrder: correctAnswer.split("|") });
+      case "matching": {
+        const [promptsStr, optionsStr] = options.split("#");
+        const prompts = promptsStr.replace("prompts:", "").split("|");
+        const opts = optionsStr.replace("options:", "").split("|");
+        const correctAnswerMap = correctAnswer.split("|").reduce((acc, pair) => {
+          const [key, ...valParts] = pair.split(":");
+          acc[key] = valParts.join(":");
+          return acc;
+        }, {});
+        return __spreadProps(__spreadValues({}, base), { prompts, options: opts, correctAnswerMap });
+      }
+      case "fill_in_the_blanks": {
+        const blanks = correctAnswer.split("#").reduce((acc, part) => {
+          const [key, valuesStr] = part.split(":");
+          acc[key] = valuesStr.split("|");
+          return acc;
+        }, {});
+        return __spreadProps(__spreadValues({}, base), { sentenceWithPlaceholders: options, blanks });
+      }
+      default:
+        throw new Error(`Unsupported questionType "${questionType}" in TSV.`);
+    }
+  }
+  static createQuestionFromRawObject(validatedRawQ) {
+    const baseQuestionData = {
+      id: generateUniqueId(validatedRawQ.questionType),
+      prompt: validatedRawQ.prompt,
+      points: validatedRawQ.points,
+      explanation: validatedRawQ.explanation,
+      topic: validatedRawQ.topic,
+      difficulty: validatedRawQ.difficulty,
+      bloomLevel: validatedRawQ.bloomLevel
+    };
+    switch (validatedRawQ.questionType) {
+      case "multiple_choice": {
+        const options = validatedRawQ.options.map((text) => ({ id: generateUniqueId("opt_"), text }));
+        const correctOption = options.find((opt) => opt.text === validatedRawQ.correctAnswer);
+        if (!correctOption) throw new Error(`Correct answer "${validatedRawQ.correctAnswer}" not found in options.`);
+        return __spreadProps(__spreadValues({}, baseQuestionData), { questionType: "multiple_choice", options, correctAnswerId: correctOption.id });
+      }
+      case "multiple_response": {
+        const options = validatedRawQ.options.map((text) => ({ id: generateUniqueId("opt_mr_"), text }));
+        const correctIds = options.filter((opt) => validatedRawQ.correctAnswers.includes(opt.text)).map((opt) => opt.id);
+        if (correctIds.length !== validatedRawQ.correctAnswers.length) throw new Error("Some correct answers were not found in options.");
+        return __spreadProps(__spreadValues({}, baseQuestionData), { questionType: "multiple_response", options, correctAnswerIds: correctIds });
+      }
+      case "true_false":
+        return __spreadProps(__spreadValues({}, baseQuestionData), { questionType: "true_false", correctAnswer: validatedRawQ.correctAnswer });
+      case "short_answer":
+        return __spreadProps(__spreadValues({}, baseQuestionData), { questionType: "short_answer", acceptedAnswers: validatedRawQ.acceptedAnswers, isCaseSensitive: false });
+      case "numeric":
+        return __spreadProps(__spreadValues({}, baseQuestionData), { questionType: "numeric", answer: validatedRawQ.answer, tolerance: validatedRawQ.tolerance });
+      case "sequence": {
+        if (validatedRawQ.items.length !== validatedRawQ.correctOrder.length) {
+          throw new Error("The number of items must match the number of items in the correct order for a sequence question.");
+        }
+        const items = validatedRawQ.items.map((content) => ({ id: generateUniqueId("seqi_"), content }));
+        const correctOrder = validatedRawQ.correctOrder.map((orderText) => {
+          const foundItem = items.find((item) => item.content === orderText);
+          if (!foundItem) throw new Error(`Sequence item "${orderText}" in correctOrder not found in items list.`);
+          return foundItem.id;
+        });
+        return __spreadProps(__spreadValues({}, baseQuestionData), { questionType: "sequence", items, correctOrder });
+      }
+      case "matching": {
+        if (validatedRawQ.prompts.length !== Object.keys(validatedRawQ.correctAnswerMap).length) {
+          throw new Error("Each prompt must have a corresponding correct answer in the map for a matching question.");
+        }
+        const prompts = validatedRawQ.prompts.map((p) => ({ id: generateUniqueId("matp_"), content: p }));
+        const options = validatedRawQ.options.map((o) => ({ id: generateUniqueId("mato_"), content: o }));
+        const correctAnswerMap = Object.entries(validatedRawQ.correctAnswerMap).map(([promptText, optionText]) => {
+          const prompt = prompts.find((p) => p.content === promptText);
+          const option = options.find((o) => o.content === optionText);
+          if (!prompt || !option) throw new Error(`Matching pair "${promptText}":"${optionText}" not found in prompts/options.`);
+          return { promptId: prompt.id, optionId: option.id };
+        });
+        return __spreadProps(__spreadValues({}, baseQuestionData), { questionType: "matching", prompts, options, correctAnswerMap, shuffleOptions: true });
+      }
+      case "fill_in_the_blanks": {
+        const { sentenceWithPlaceholders, blanks } = validatedRawQ;
+        const segments = [];
+        const answers = [];
+        const placeholderMap = {};
+        Object.keys(blanks).forEach((placeholder) => {
+          const blankId = generateUniqueId("blank_");
+          placeholderMap[placeholder] = blankId;
+          answers.push({ blankId, acceptedValues: blanks[placeholder] });
+        });
+        const regex = /\{\{([^}]+)\}\}/g;
+        let lastIndex = 0;
+        let match;
+        while ((match = regex.exec(sentenceWithPlaceholders)) !== null) {
+          if (match.index > lastIndex) {
+            segments.push({ type: "text", content: sentenceWithPlaceholders.substring(lastIndex, match.index) });
+          }
+          const placeholder = match[1];
+          const blankId = placeholderMap[placeholder];
+          if (!blankId) throw new Error(`Placeholder "{{${placeholder}}}" found in sentence but not defined in blanks object.`);
+          segments.push({ type: "blank", id: blankId });
+          lastIndex = regex.lastIndex;
+        }
+        if (lastIndex < sentenceWithPlaceholders.length) {
+          segments.push({ type: "text", content: sentenceWithPlaceholders.substring(lastIndex) });
+        }
+        return __spreadProps(__spreadValues({}, baseQuestionData), { questionType: "fill_in_the_blanks", segments, answers, isCaseSensitive: false });
+      }
+    }
+    throw new Error(`Unhandled question type in createQuestionFromRawObject: ${validatedRawQ.questionType}`);
+  }
+};
+
+// src/services/UserConfigService.ts
+var LOCAL_STORAGE_PREFIX2 = "iqk_user_config_";
+var UserConfigService = class {
+  static getStorageKey(key) {
+    return `${LOCAL_STORAGE_PREFIX2}${key}`;
+  }
+  static setConfig(key, value) {
+    if (typeof window !== "undefined" && window.localStorage) {
+      try {
+        const serializedValue = JSON.stringify(value);
+        localStorage.setItem(this.getStorageKey(key), serializedValue);
+      } catch (e) {
+        console.error(`Error saving config key "${key}" to localStorage:`, e);
+      }
+    }
+  }
+  static getConfig(key, defaultValue = null) {
+    if (typeof window !== "undefined" && window.localStorage) {
+      try {
+        const storedValue = localStorage.getItem(this.getStorageKey(key));
+        if (storedValue !== null) {
+          return JSON.parse(storedValue);
+        }
+      } catch (e) {
+        console.error(`Error retrieving or parsing config key "${key}" from localStorage:`, e);
+        return defaultValue;
+      }
+    }
+    return defaultValue;
+  }
+  static removeConfig(key) {
+    if (typeof window !== "undefined" && window.localStorage) {
+      try {
+        localStorage.removeItem(this.getStorageKey(key));
+      } catch (e) {
+        console.error(`Error removing config key "${key}" from localStorage:`, e);
+      }
+    }
+  }
+  // --- Convenience Methods for Simple Configs ---
+  static getFullName() {
+    return this.getConfig("fullName", null);
+  }
+  static setFullName(name) {
+    this.setConfig("fullName", name);
+  }
+  static getWeeklyGoal() {
+    const goal = this.getConfig("weeklyGoal", 5);
+    return typeof goal === "number" ? goal : 5;
+  }
+  static setWeeklyGoal(goal) {
+    this.setConfig("weeklyGoal", goal);
+  }
+  static getLanguage() {
+    var _a;
+    return (_a = this.getConfig("language", "en")) != null ? _a : "en";
+  }
+  static setLanguage(language) {
+    this.setConfig("language", language);
+  }
+  // --- Methods for Advanced Goal Management ---
+  static getGoals() {
+    return this.getConfig("advanced_goals", []) || [];
+  }
+  static saveGoals(goals) {
+    this.setConfig("advanced_goals", goals);
+  }
+  /**
+   * Adds a new goal to the user's list. The goal object should not contain a description.
+   * @param newGoal A partial Goal object without id, description, isAchieved, or achievedAt.
+   */
+  static addGoal(newGoal) {
+    const goals = this.getGoals();
+    const goalToAdd = __spreadProps(__spreadValues({}, newGoal), {
+      id: generateUniqueId("goal_"),
+      isAchieved: false
+    });
+    this.saveGoals([...goals, goalToAdd]);
+  }
+  static updateGoal(updatedGoal) {
+    const goals = this.getGoals();
+    const index = goals.findIndex((g) => g.id === updatedGoal.id);
+    if (index > -1) {
+      goals[index] = updatedGoal;
+      this.saveGoals(goals);
+    }
+  }
+  static deleteGoal(goalId) {
+    const goals = this.getGoals();
+    const filteredGoals = goals.filter((g) => g.id !== goalId);
+    this.saveGoals(filteredGoals);
+  }
+};
+
+// src/services/PracticeHistoryService.ts
+var LOCAL_STORAGE_KEY = "iqk_practice_history_v2";
+var PracticeHistoryService = class {
+  static getPracticeHistory() {
+    if (typeof window === "undefined") return [];
+    try {
+      const storedData = localStorage.getItem(LOCAL_STORAGE_KEY);
+      return storedData ? JSON.parse(storedData) : [];
+    } catch (e) {
+      console.error("Error retrieving practice history:", e);
+      return [];
+    }
+  }
+  static saveHistory(history) {
+    if (typeof window !== "undefined") {
+      try {
+        localStorage.setItem(LOCAL_STORAGE_KEY, JSON.stringify(history));
+      } catch (e) {
+        console.error("Error saving practice history to localStorage:", e);
+      }
+    }
+  }
+  static saveCompletedPracticeSession(quizConfig, result, review = null) {
+    const history = this.getPracticeHistory();
+    const topicsCovered = Array.from(
+      new Set(quizConfig.questions.map((q) => JSON.stringify({
+        subject: q.subject || "Uncategorized",
+        category: q.category || "General",
+        topic: q.topic || "General Topic"
+      })))
+    ).map((s) => JSON.parse(s));
+    const newSession = {
+      id: `session_${Date.now()}_${Math.random().toString(36).substring(2, 7)}`,
+      timestamp: Date.now(),
+      quizConfig,
+      quizResult: result,
+      quizReview: review,
+      summary: {
+        topics: topicsCovered,
+        score: result.score,
+        maxScore: result.maxScore,
+        percentage: result.percentage
+      }
+    };
+    history.unshift(newSession);
+    this.saveHistory(history);
+    return newSession.id;
+  }
+  static updatePracticeReview(sessionId, review) {
+    const history = this.getPracticeHistory();
+    const sessionIndex = history.findIndex((s) => s.id === sessionId);
+    if (sessionIndex > -1) {
+      history[sessionIndex].quizReview = review;
+      this.saveHistory(history);
+    } else {
+      console.warn(`Could not find session with ID "${sessionId}" to update review.`);
+    }
+  }
+  static getPracticeSessionById(sessionId) {
+    return this.getPracticeHistory().find((s) => s.id === sessionId) || null;
+  }
+  static getPracticeHistorySummary() {
+    const history = this.getPracticeHistory();
+    return history.map((session) => ({
+      id: session.id,
+      timestamp: session.timestamp,
+      quizTitle: session.quizConfig.title,
+      topics: session.summary.topics,
+      score: session.summary.score,
+      maxScore: session.summary.maxScore,
+      percentage: session.summary.percentage
+    }));
+  }
+  static getPracticeStats() {
+    const history = this.getPracticeHistory();
+    if (history.length === 0) {
+      return {
+        totalSessions: 0,
+        currentStreak: 0,
+        longestStreak: 0,
+        activityCalendar: {},
+        performanceBySubject: [],
+        performanceByTopic: []
+      };
+    }
+    const toLocalDateString = (timestamp) => {
+      const date = new Date(timestamp);
+      const offset = date.getTimezoneOffset();
+      const adjustedDate = new Date(date.getTime() - offset * 60 * 1e3);
+      return adjustedDate.toISOString().split("T")[0];
+    };
+    const activityCalendar = {};
+    const uniquePracticeDays = /* @__PURE__ */ new Set();
+    history.forEach((session) => {
+      const dateStr = toLocalDateString(session.timestamp);
+      activityCalendar[dateStr] = (activityCalendar[dateStr] || 0) + 1;
+      uniquePracticeDays.add(dateStr);
+    });
+    const sortedDays = Array.from(uniquePracticeDays).sort().reverse();
+    let currentStreak = 0;
+    let longestStreak = 0;
+    if (sortedDays.length > 0) {
+      const today = /* @__PURE__ */ new Date();
+      const todayStr = toLocalDateString(today.getTime());
+      const yesterday = /* @__PURE__ */ new Date();
+      yesterday.setDate(today.getDate() - 1);
+      const yesterdayStr = toLocalDateString(yesterday.getTime());
+      if (sortedDays[0] === todayStr || sortedDays[0] === yesterdayStr) {
+        currentStreak = 1;
+        for (let i = 0; i < sortedDays.length - 1; i++) {
+          const currentDay = new Date(sortedDays[i]);
+          const nextDay = new Date(sortedDays[i + 1]);
+          const diffTime = currentDay.getTime() - nextDay.getTime();
+          const diffDays = Math.round(diffTime / (1e3 * 60 * 60 * 24));
+          if (diffDays === 1) {
+            currentStreak++;
+          } else {
+            break;
+          }
+        }
+      }
+    }
+    if (sortedDays.length > 0) {
+      let tempStreak = 1;
+      longestStreak = 1;
+      for (let i = 0; i < sortedDays.length - 1; i++) {
+        const currentDay = new Date(sortedDays[i]);
+        const nextDay = new Date(sortedDays[i + 1]);
+        const diffTime = currentDay.getTime() - nextDay.getTime();
+        const diffDays = Math.round(diffTime / (1e3 * 60 * 60 * 24));
+        if (diffDays === 1) {
+          tempStreak++;
+        } else {
+          tempStreak = 1;
+        }
+        if (tempStreak > longestStreak) {
+          longestStreak = tempStreak;
+        }
+      }
+    } else {
+      longestStreak = 0;
+    }
+    const subjectPerf = {};
+    const topicPerf = {};
+    history.forEach((session) => {
+      session.summary.topics.forEach((topicInfo) => {
+        if (session.summary.percentage !== null) {
+          if (!subjectPerf[topicInfo.subject]) subjectPerf[topicInfo.subject] = { total: 0, count: 0 };
+          subjectPerf[topicInfo.subject].total += session.summary.percentage;
+          subjectPerf[topicInfo.subject].count++;
+          if (!topicPerf[topicInfo.topic]) topicPerf[topicInfo.topic] = { total: 0, count: 0 };
+          topicPerf[topicInfo.topic].total += session.summary.percentage;
+          topicPerf[topicInfo.topic].count++;
+        }
+      });
+    });
+    const formatPerf = (perfData) => {
+      return Object.entries(perfData).map(([name, data]) => ({
+        name,
+        totalSessions: data.count,
+        averageScore: parseFloat((data.total / data.count).toFixed(2))
+      })).sort((a, b) => b.totalSessions - a.totalSessions);
+    };
+    return {
+      totalSessions: history.length,
+      currentStreak,
+      longestStreak,
+      activityCalendar,
+      performanceBySubject: formatPerf(subjectPerf),
+      performanceByTopic: formatPerf(topicPerf)
+    };
+  }
+  static clearHistory() {
+    if (typeof window !== "undefined") {
+      localStorage.removeItem(LOCAL_STORAGE_KEY);
+    }
+  }
+};
+
+// src/data/achievements.json
+var achievements_default = [
+  {
+    id: "first_session",
+    icon: "Rocket",
+    nameKey: "achievements.first_session.name",
+    descriptionKey: "achievements.first_session.description",
+    condition: {
+      type: "SESSION_COUNT",
+      params: { count: 1 }
+    }
+  },
+  {
+    id: "five_sessions",
+    icon: "BookOpen",
+    nameKey: "achievements.five_sessions.name",
+    descriptionKey: "achievements.five_sessions.description",
+    condition: {
+      type: "SESSION_COUNT",
+      params: { count: 5 }
+    }
+  },
+  {
+    id: "perfect_score",
+    icon: "Star",
+    nameKey: "achievements.perfect_score.name",
+    descriptionKey: "achievements.perfect_score.description",
+    condition: {
+      type: "PERFECT_SCORE",
+      params: {}
+    }
+  },
+  {
+    id: "streak_3_days",
+    icon: "Flame",
+    nameKey: "achievements.streak_3_days.name",
+    descriptionKey: "achievements.streak_3_days.description",
+    condition: {
+      type: "STREAK",
+      params: { days: 3 }
+    }
+  },
+  {
+    id: "ten_sessions",
+    icon: "Award",
+    nameKey: "achievements.ten_sessions.name",
+    descriptionKey: "achievements.ten_sessions.description",
+    condition: {
+      type: "SESSION_COUNT",
+      params: { count: 10 }
+    }
+  },
+  {
+    id: "streak_7_days",
+    icon: "Sparkles",
+    nameKey: "achievements.streak_7_days.name",
+    descriptionKey: "achievements.streak_7_days.description",
+    condition: {
+      type: "STREAK",
+      params: { days: 7 }
+    }
+  },
+  {
+    id: "weekend_warrior",
+    icon: "CalendarDays",
+    nameKey: "achievements.weekend_warrior.name",
+    descriptionKey: "achievements.weekend_warrior.description",
+    condition: {
+      type: "SESSION_ON_WEEKEND",
+      params: {}
+    }
+  },
+  {
+    id: "night_owl",
+    icon: "Moon",
+    nameKey: "achievements.night_owl.name",
+    descriptionKey: "achievements.night_owl.description",
+    condition: {
+      type: "SESSION_AFTER_HOUR",
+      params: { hour: 22 }
+    }
+  },
+  {
+    id: "polymath_prospect",
+    icon: "Library",
+    nameKey: "achievements.polymath_prospect.name",
+    descriptionKey: "achievements.polymath_prospect.description",
+    condition: {
+      type: "DISTINCT_SUBJECTS",
+      params: { count: 3 }
+    }
+  },
+  {
+    id: "subject_specialist",
+    icon: "Target",
+    nameKey: "achievements.subject_specialist.name",
+    descriptionKey: "achievements.subject_specialist.description",
+    condition: {
+      type: "SESSIONS_IN_SUBJECT",
+      params: { count: 5 }
+    }
+  },
+  {
+    id: "high_achiever",
+    icon: "TrendingUp",
+    nameKey: "achievements.high_achiever.name",
+    descriptionKey: "achievements.high_achiever.description",
+    condition: {
+      type: "CONSECUTIVE_HIGH_SCORE",
+      params: { count: 3, score: 90 }
+    }
+  },
+  {
+    id: "comeback_kid",
+    icon: "ChevronsUp",
+    nameKey: "achievements.comeback_kid.name",
+    descriptionKey: "achievements.comeback_kid.description",
+    condition: {
+      type: "SCORE_IMPROVEMENT",
+      params: { improvement: 20 }
+    }
+  },
+  {
+    id: "twenty_five_sessions",
+    icon: "Medal",
+    nameKey: "achievements.twenty_five_sessions.name",
+    descriptionKey: "achievements.twenty_five_sessions.description",
+    condition: {
+      type: "SESSION_COUNT",
+      params: { count: 25 }
+    }
+  },
+  {
+    id: "streak_14_days",
+    icon: "Gem",
+    nameKey: "achievements.streak_14_days.name",
+    descriptionKey: "achievements.streak_14_days.description",
+    condition: {
+      type: "STREAK",
+      params: { days: 14 }
+    }
+  },
+  {
+    id: "subject_master",
+    icon: "Crown",
+    nameKey: "achievements.subject_master.name",
+    descriptionKey: "achievements.subject_master.description",
+    condition: {
+      type: "SUBJECT_MASTERY",
+      params: { score: 90, sessions: 5 }
+    }
+  },
+  {
+    id: "centurion",
+    icon: "ShieldCheck",
+    nameKey: "achievements.centurion.name",
+    descriptionKey: "achievements.centurion.description",
+    condition: {
+      type: "SESSION_COUNT",
+      params: { count: 100 }
+    }
+  }
+];
+
+// src/services/AchievementService.ts
+var LOCAL_STORAGE_KEY2 = "iqk_unlocked_achievements_v2";
+var ALL_ACHIEVEMENT_DEFS = achievements_default;
+var conditionEvaluators = {
+  SESSION_COUNT: (params, history) => history.length >= params.count,
+  PERFECT_SCORE: (params, history) => history.some((s) => s.summary.percentage === 100),
+  STREAK: (params, history, stats) => stats.longestStreak >= params.days,
+  SESSION_ON_WEEKEND: (params, history) => history.some((s) => [0, 6].includes(new Date(s.timestamp).getDay())),
+  SESSION_AFTER_HOUR: (params, history) => history.some((s) => new Date(s.timestamp).getHours() >= params.hour),
+  DISTINCT_SUBJECTS: (params, history) => {
+    const subjects = new Set(history.flatMap((s) => s.summary.topics.map((t) => t.subject)));
+    return subjects.size >= params.count;
+  },
+  SESSIONS_IN_SUBJECT: (params, history) => {
+    const subjectCounts = history.flatMap((s) => s.summary.topics.map((t) => t.subject)).reduce((acc, subject) => {
+      acc[subject] = (acc[subject] || 0) + 1;
+      return acc;
+    }, {});
+    return Object.values(subjectCounts).some((count) => count >= params.count);
+  },
+  CONSECUTIVE_HIGH_SCORE: (params, history) => {
+    if (history.length < params.count) return false;
+    for (let i = 0; i <= history.length - params.count; i++) {
+      const recentSessions = history.slice(i, i + params.count);
+      if (recentSessions.every((s) => s.summary.percentage !== null && s.summary.percentage >= params.score)) {
+        return true;
+      }
+    }
+    return false;
+  },
+  SCORE_IMPROVEMENT: (params, history) => {
+    if (history.length < 2) return false;
+    for (let i = 0; i < history.length - 1; i++) {
+      const currentPercent = history[i].summary.percentage;
+      const previousPercent = history[i + 1].summary.percentage;
+      if (currentPercent !== null && previousPercent !== null && currentPercent - previousPercent >= params.improvement) {
+        return true;
+      }
+    }
+    return false;
+  },
+  SUBJECT_MASTERY: (params, history, stats) => {
+    return stats.performanceBySubject.some((s) => s.averageScore >= params.score && s.totalSessions >= params.sessions);
+  }
+};
+var AchievementService = class {
+  static getUnlockedAchievementsMap() {
+    if (typeof window === "undefined") return {};
+    try {
+      const storedData = localStorage.getItem(LOCAL_STORAGE_KEY2);
+      return storedData ? JSON.parse(storedData) : {};
+    } catch (e) {
+      console.error("Error retrieving unlocked achievements map:", e);
+      return {};
+    }
+  }
+  static saveUnlockedAchievementsMap(unlockedMap) {
+    if (typeof window !== "undefined") {
+      try {
+        localStorage.setItem(LOCAL_STORAGE_KEY2, JSON.stringify(unlockedMap));
+      } catch (e) {
+        console.error("Error saving unlocked achievements map:", e);
+      }
+    }
+  }
+  static checkAndUnlockAchievements(history, stats) {
+    const unlockedMap = this.getUnlockedAchievementsMap();
+    const newlyUnlocked = [];
+    let hasChanges = false;
+    ALL_ACHIEVEMENT_DEFS.forEach((achievementDef) => {
+      if (unlockedMap[achievementDef.id]) {
+        return;
+      }
+      const evaluator = conditionEvaluators[achievementDef.condition.type];
+      if (evaluator) {
+        const isUnlocked = evaluator(achievementDef.condition.params, history, stats);
+        if (isUnlocked) {
+          const unlockTime = Date.now();
+          unlockedMap[achievementDef.id] = unlockTime;
+          newlyUnlocked.push(achievementDef);
+          hasChanges = true;
+        }
+      } else {
+        console.warn(`No evaluator found for achievement condition type: "${achievementDef.condition.type}"`);
+      }
+    });
+    if (hasChanges) {
+      this.saveUnlockedAchievementsMap(unlockedMap);
+    }
+    return newlyUnlocked;
+  }
+  static getAllAchievementDefinitions() {
+    return ALL_ACHIEVEMENT_DEFS;
+  }
+  static getAllAchievementsWithStatus() {
+    const unlockedMap = this.getUnlockedAchievementsMap();
+    return ALL_ACHIEVEMENT_DEFS.map((def) => {
+      const unlockedAt = unlockedMap[def.id];
+      return {
+        id: def.id,
+        icon: def.icon,
+        name: def.nameKey,
+        description: def.descriptionKey,
+        unlockedAt: unlockedAt || void 0
+      };
+    });
+  }
+};
+
+// src/services/MotivationalQuotes.ts
+var QUOTE_BANK = [
+  { text: "H\u1ECDc, h\u1ECDc n\u1EEFa, h\u1ECDc m\xE3i.", author: "V.I. Lenin" },
+  { text: "H\xE0nh tr\xECnh v\u1EA1n d\u1EB7m b\u1EAFt \u0111\u1EA7u b\u1EB1ng m\u1ED9t b\u01B0\u1EDBc ch\xE2n.", author: "L\xE3o T\u1EED" },
+  { text: "C\xE1ch t\u1ED1t nh\u1EA5t \u0111\u1EC3 d\u1EF1 \u0111o\xE1n t\u01B0\u01A1ng lai l\xE0 t\u1EA1o ra n\xF3.", author: "Peter Drucker" },
+  { text: "\u0110\u1EEBng lo l\u1EAFng v\u1EC1 th\u1EA5t b\u1EA1i; h\xE3y lo l\u1EAFng v\u1EC1 nh\u1EEFng c\u01A1 h\u1ED9i b\u1EA1n b\u1ECF l\u1EE1 khi kh\xF4ng d\xE1m th\u1EED.", author: "Jack Canfield" },
+  { text: "Th\xE0nh c\xF4ng kh\xF4ng ph\u1EA3i l\xE0 cu\u1ED1i c\xF9ng, th\u1EA5t b\u1EA1i kh\xF4ng ph\u1EA3i l\xE0 ch\u1EBFt ng\u01B0\u1EDDi: l\xF2ng can \u0111\u1EA3m \u0111i ti\u1EBFp m\u1EDBi quan tr\u1ECDng.", author: "Winston Churchill" },
+  { text: "Ch\u1EC9 nh\u1EEFng ng\u01B0\u1EDDi d\xE1m th\u1EA5t b\u1EA1i l\u1EDBn m\u1EDBi c\xF3 th\u1EC3 \u0111\u1EA1t \u0111\u01B0\u1EE3c th\xE0nh c\xF4ng l\u1EDBn.", author: "Robert F. Kennedy" },
+  { text: "Ki\u1EBFn th\u1EE9c l\xE0 s\u1EE9c m\u1EA1nh.", author: "Francis Bacon" },
+  { text: "S\u1EF1 kh\xE1c bi\u1EC7t gi\u1EEFa b\xECnh th\u01B0\u1EDDng v\xE0 phi th\u01B0\u1EDDng ch\u1EC9 l\xE0 m\u1ED9t ch\xFAt n\u1ED7 l\u1EF1c.", author: "Jimmy Johnson" },
+  { text: "H\xE3y l\xE0 s\u1EF1 thay \u0111\u1ED5i m\xE0 b\u1EA1n mu\u1ED1n th\u1EA5y tr\xEAn th\u1EBF gi\u1EDBi.", author: "Mahatma Gandhi" },
+  { text: "H\xF4m nay b\u1EA1n \u0111\u1ECDc, ng\xE0y mai b\u1EA1n s\u1EBD l\xE3nh \u0111\u1EA1o.", author: "Margaret Fuller" },
+  { text: "R\u1EC5 c\u1EE7a gi\xE1o d\u1EE5c th\xEC \u0111\u1EAFng, nh\u01B0ng qu\u1EA3 c\u1EE7a n\xF3 th\xEC ng\u1ECDt.", author: "Aristotle" },
+  { text: "C\xE1ch \u0111\u1EC3 b\u1EAFt \u0111\u1EA7u l\xE0 ng\u1EEBng n\xF3i v\xE0 b\u1EAFt \u0111\u1EA7u l\xE0m.", author: "Walt Disney" },
+  { text: "K\u1EF7 lu\u1EADt l\xE0 c\u1EA7u n\u1ED1i gi\u1EEFa m\u1EE5c ti\xEAu v\xE0 th\xE0nh t\u1EF1u.", author: "Jim Rohn" },
+  { text: "B\u1EA1n kh\xF4ng c\u1EA7n ph\u1EA3i v\u0129 \u0111\u1EA1i \u0111\u1EC3 b\u1EAFt \u0111\u1EA7u, nh\u01B0ng b\u1EA1n ph\u1EA3i b\u1EAFt \u0111\u1EA7u \u0111\u1EC3 tr\u1EDF n\xEAn v\u0129 \u0111\u1EA1i.", author: "Zig Ziglar" },
+  { text: "Tin r\u1EB1ng b\u1EA1n c\xF3 th\u1EC3 v\xE0 b\u1EA1n \u0111\xE3 \u0111i \u0111\u01B0\u1EE3c n\u1EEDa \u0111\u01B0\u1EDDng.", author: "Theodore Roosevelt" },
+  { text: "M\u1ED9t ng\u01B0\u1EDDi kh\xF4ng bao gi\u1EDD m\u1EAFc sai l\u1EA7m l\xE0 ng\u01B0\u1EDDi kh\xF4ng bao gi\u1EDD th\u1EED b\u1EA5t c\u1EE9 \u0111i\u1EC1u g\xEC m\u1EDBi.", author: "Albert Einstein" },
+  { text: "Th\u1EED th\xE1ch l\xE0 th\u1EE9 l\xE0m cho cu\u1ED9c s\u1ED1ng th\xFA v\u1ECB v\xE0 v\u01B0\u1EE3t qua ch\xFAng l\xE0 \u0111i\u1EC1u l\xE0m cho cu\u1ED9c s\u1ED1ng c\xF3 \xFD ngh\u0129a.", author: "Joshua J. Marine" },
+  { text: "Thi\xEAn t\xE0i l\xE0 m\u1ED9t ph\u1EA7n tr\u0103m c\u1EA3m h\u1EE9ng v\xE0 ch\xEDn m\u01B0\u01A1i ch\xEDn ph\u1EA7n tr\u0103m m\u1ED3 h\xF4i.", author: "Thomas Edison" },
+  { text: "\u0110\u1EEBng \u0111\u1EC3 ng\xE0y h\xF4m qua chi\u1EBFm qu\xE1 nhi\u1EC1u th\u1EDDi gian c\u1EE7a ng\xE0y h\xF4m nay.", author: "Will Rogers" },
+  { text: "N\u1EBFu c\u01A1 h\u1ED9i kh\xF4ng g\xF5 c\u1EEDa, h\xE3y x\xE2y m\u1ED9t c\xE1nh c\u1EEDa.", author: "Milton Berle" }
+];
+var QuoteService = class {
+  /**
+   * Retrieves a random quote from the internal quote bank.
+   * @returns A quote object containing text and author.
+   */
+  static getRandomQuote() {
+    if (QUOTE_BANK.length === 0) {
+      return { text: "H\xE3y b\u1EAFt \u0111\u1EA7u h\xE0nh tr\xECnh h\u1ECDc t\u1EADp c\u1EE7a b\u1EA1n.", author: "QuizKit" };
+    }
+    const randomIndex = Math.floor(Math.random() * QUOTE_BANK.length);
+    return QUOTE_BANK[randomIndex];
+  }
+};
+
+// src/services/KnowledgeCardService.ts
+var LOCAL_STORAGE_KEY3 = "iqk_knowledge_cards_store";
+var GENERATION_FLAG_KEY = "iqk_card_generation_in_progress";
+var KnowledgeCardService = class {
+  static generateHash(str) {
+    let hash = 0;
+    if (str.length === 0) return hash.toString();
+    for (let i = 0; i < str.length; i++) {
+      const char = str.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash |= 0;
+    }
+    return hash.toString();
+  }
+  static getStore() {
+    if (typeof window === "undefined") {
+      return { sourceHash: null, conceptsPlan: [], generatedConcepts: {}, cards: [] };
+    }
+    try {
+      const storedData = localStorage.getItem(LOCAL_STORAGE_KEY3);
+      if (storedData) {
+        return JSON.parse(storedData);
+      }
+    } catch (e) {
+      console.error("Error reading Knowledge Card store from localStorage:", e);
+    }
+    return { sourceHash: null, conceptsPlan: [], generatedConcepts: {}, cards: [] };
+  }
+  static saveStore(store) {
+    if (typeof window !== "undefined") {
+      try {
+        localStorage.setItem(LOCAL_STORAGE_KEY3, JSON.stringify(store));
+      } catch (e) {
+        console.error("Error saving Knowledge Card store to localStorage:", e);
+      }
+    }
+  }
+  static getSourceHash() {
+    return this.getStore().sourceHash;
+  }
+  /**
+   * Saves a new card generation plan. This clears old cards and resets the generation progress.
+   * @param sourceHash The hash of the new source content.
+   * @param concepts An array of concept strings to be generated.
+   */
+  static saveCardPlan(sourceHash, concepts) {
+    const newStore = {
+      sourceHash,
+      conceptsPlan: concepts,
+      generatedConcepts: {},
+      cards: []
+    };
+    this.saveStore(newStore);
+  }
+  /**
+   * Saves a newly generated card to the store and marks its concept as completed.
+   * @param card The KnowledgeCard object to save.
+   */
+  static saveGeneratedCard(card) {
+    const store = this.getStore();
+    if (!store.cards.some((c) => c.id === card.id)) {
+      store.cards.push(card);
+      store.generatedConcepts[card.concept] = true;
+      this.saveStore(store);
+    }
+  }
+  /**
+   * Gets the list of concepts that are in the plan but have not been generated yet.
+   * @returns An array of concept strings that are pending generation.
+   */
+  static getPendingConcepts() {
+    const store = this.getStore();
+    return store.conceptsPlan.filter((concept) => !store.generatedConcepts[concept]);
+  }
+  /**
+   * Gets the current status of the card generation process.
+   * @returns An object with the total number of cards planned and the number completed.
+   */
+  static getGenerationStatus() {
+    const store = this.getStore();
+    return {
+      total: store.conceptsPlan.length,
+      completed: Object.keys(store.generatedConcepts).length
+    };
+  }
+  /**
+   * Checks if a generation process is currently marked as running in this browser tab/session.
+   * Uses sessionStorage to prevent multiple tabs from running the same process.
+   * @returns True if a process is marked as running, false otherwise.
+   */
+  static isGenerationInProgress() {
+    if (typeof window === "undefined") return false;
+    return sessionStorage.getItem(GENERATION_FLAG_KEY) === "true";
+  }
+  /**
+   * Sets or clears the flag indicating that a generation process is active.
+   * @param status The status to set (true for running, false for stopped).
+   */
+  static setGenerationStatus(status) {
+    if (typeof window !== "undefined") {
+      if (status) {
+        sessionStorage.setItem(GENERATION_FLAG_KEY, "true");
+      } else {
+        sessionStorage.removeItem(GENERATION_FLAG_KEY);
+      }
+    }
+  }
+  static getCards() {
+    return this.getStore().cards;
+  }
+  static getRandomCard() {
+    const cards = this.getCards();
+    if (cards.length === 0) return null;
+    const randomIndex = Math.floor(Math.random() * cards.length);
+    return cards[randomIndex];
+  }
+  static searchCards(query) {
+    const cards = this.getCards();
+    if (!query.trim()) return [];
+    const lowerCaseQuery = query.toLowerCase();
+    return cards.filter(
+      (card) => card.concept.toLowerCase().includes(lowerCaseQuery) || card.definition.toLowerCase().includes(lowerCaseQuery)
+    );
+  }
+};
+
+// src/services/metadataService.ts
+var LocalStorageManager = class {
+  constructor(key) {
+    this.key = `iqk_metadata_${key}`;
+  }
+  getAll() {
+    if (typeof window === "undefined") return [];
+    try {
+      const stored = localStorage.getItem(this.key);
+      return stored ? JSON.parse(stored) : [];
+    } catch (e) {
+      console.error(`Error reading from localStorage key ${this.key}:`, e);
+      return [];
+    }
+  }
+  saveAll(items) {
+    if (typeof window === "undefined") return;
+    try {
+      localStorage.setItem(this.key, JSON.stringify(items));
+    } catch (e) {
+      console.error(`Error writing to localStorage key ${this.key}:`, e);
+    }
+  }
+  add(item) {
+    const items = this.getAll();
+    if (items.some((i) => i.code === item.code)) {
+      throw new Error(`An item with code "${item.code}" already exists for ${this.key}.`);
+    }
+    const newItem = __spreadProps(__spreadValues({}, item), { id: generateUniqueId(`${this.key}_`) });
+    this.saveAll([...items, newItem]);
+    return newItem;
+  }
+  // ===== FIX IS HERE =====
+  // Changed the type of 'updates' to allow 'code' to be part of the update object.
+  update(id, updates) {
+    const items = this.getAll();
+    const index = items.findIndex((i) => i.id === id);
+    if (index === -1) {
+      console.warn(`Item with id "${id}" not found in ${this.key} for update.`);
+      return null;
+    }
+    const updatedItem = __spreadValues(__spreadValues({}, items[index]), updates);
+    items[index] = updatedItem;
+    this.saveAll(items);
+    return updatedItem;
+  }
+  // =======================
+  delete(code) {
+    const items = this.getAll();
+    const newItems = items.filter((i) => i.code !== code);
+    if (items.length === newItems.length) {
+      return false;
+    }
+    this.saveAll(newItems);
+    return true;
+  }
+};
+var subjectManager = new LocalStorageManager("subjects");
+var gradeLevelManager = new LocalStorageManager("grade_levels");
+var topicManager = new LocalStorageManager("topics");
+var categoryManager = new LocalStorageManager("categories");
+var bloomLevelManager = new LocalStorageManager("bloom_levels");
+var questionTypeManager = new LocalStorageManager("question_types");
+var learningObjectiveManager = new LocalStorageManager("learning_objectives");
+var contextManager = new LocalStorageManager("contexts");
+var approachManager = new LocalStorageManager("approaches");
+function mapRawDifficultyToStandard(rawDifficulty) {
+  switch (rawDifficulty) {
+    case "E":
+    case "E~M":
+      return "easy";
+    case "M":
+    case "M~H":
+      return "medium";
+    case "H":
+      return "hard";
+    default:
+      return "medium";
+  }
+}
+var _MetadataService = class _MetadataService {
+};
+// --- Subject Services ---
+_MetadataService.getSubjects = () => subjectManager.getAll().sort((a, b) => a.name.localeCompare(b.name));
+_MetadataService.addSubject = (name, code) => {
+  return subjectManager.add({ code, name, createdAt: (/* @__PURE__ */ new Date()).toISOString(), updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
+};
+_MetadataService.updateSubject = (id, name, code) => {
+  return subjectManager.update(id, { name, code, updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
+};
+_MetadataService.deleteSubject = (code) => {
+  const topics = _MetadataService.getTopics(code);
+  if (topics.length > 0) {
+    throw new Error("Cannot delete subject: It is referenced by topics.");
+  }
+  return subjectManager.delete(code);
+};
+// --- GradeLevel Services ---
+_MetadataService.getGradeLevels = () => gradeLevelManager.getAll().sort((a, b) => a.name.localeCompare(b.name));
+_MetadataService.addGradeLevel = (name, code) => gradeLevelManager.add({ name, code });
+_MetadataService.updateGradeLevel = (id, name, code) => gradeLevelManager.update(id, { name, code });
+_MetadataService.deleteGradeLevel = (code) => gradeLevelManager.delete(code);
+// --- Topic Services ---
+_MetadataService.getTopics = (subjectCode) => {
+  const allTopics = topicManager.getAll();
+  const filtered = subjectCode ? allTopics.filter((t) => t.subjectCode === subjectCode) : allTopics;
+  return filtered.sort((a, b) => a.name.localeCompare(b.name));
+};
+_MetadataService.addTopic = (name, code, subjectCode) => topicManager.add({ name, code, subjectCode });
+_MetadataService.updateTopic = (id, name, code, subjectCode) => topicManager.update(id, { name, code, subjectCode });
+_MetadataService.deleteTopic = (code) => topicManager.delete(code);
+// --- BloomLevel Services ---
+_MetadataService.getBloomLevels = () => bloomLevelManager.getAll().sort((a, b) => a.name.localeCompare(b.name));
+_MetadataService.addBloomLevel = (name, code, description) => bloomLevelManager.add({ name, code, description });
+_MetadataService.updateBloomLevel = (id, name, code, description) => bloomLevelManager.update(id, { name, code, description });
+_MetadataService.deleteBloomLevel = (code) => bloomLevelManager.delete(code);
+// --- QuestionType Services ---
+_MetadataService.getQuestionTypes = () => questionTypeManager.getAll().sort((a, b) => a.name.localeCompare(b.name));
+_MetadataService.addQuestionType = (name, code, description) => questionTypeManager.add({ name, code, description });
+_MetadataService.updateQuestionType = (id, name, code, description) => questionTypeManager.update(id, { name, code, description });
+_MetadataService.deleteQuestionType = (code) => questionTypeManager.delete(code);
+// --- Category Services ---
+_MetadataService.getCategories = () => categoryManager.getAll().sort((a, b) => a.name.localeCompare(b.name));
+_MetadataService.addCategory = (name, code, description) => categoryManager.add({ name, code, description });
+_MetadataService.updateCategory = (id, name, code, description) => categoryManager.update(id, { name, code, description });
+_MetadataService.deleteCategory = (code) => categoryManager.delete(code);
+// --- Context Services ---
+_MetadataService.getContexts = () => contextManager.getAll().sort((a, b) => a.name.localeCompare(b.name));
+_MetadataService.addContext = (name, code, description) => contextManager.add({ name, code, description });
+_MetadataService.updateContext = (id, name, code, description) => contextManager.update(id, { name, code, description });
+_MetadataService.deleteContext = (code) => contextManager.delete(code);
+// --- Approach Services ---
+_MetadataService.getApproaches = () => approachManager.getAll().sort((a, b) => a.code.localeCompare(b.code));
+_MetadataService.addApproach = (approachData) => {
+  const difficulty = mapRawDifficultyToStandard(approachData.rawDifficulty);
+  return approachManager.add(__spreadProps(__spreadValues({}, approachData), { difficulty }));
+};
+_MetadataService.updateApproach = (id, approachData) => {
+  const updates = __spreadValues({}, approachData);
+  if (approachData.rawDifficulty) {
+    updates.difficulty = mapRawDifficultyToStandard(approachData.rawDifficulty);
+  }
+  return approachManager.update(id, updates);
+};
+_MetadataService.deleteApproach = (code) => approachManager.delete(code);
+// --- LearningObjective Services ---
+_MetadataService.getLearningObjectives = (subjectCode) => {
+  const allLOs = learningObjectiveManager.getAll();
+  const filtered = subjectCode ? allLOs.filter((lo) => lo.subjectCode === subjectCode) : allLOs;
+  return filtered.sort((a, b) => a.name.localeCompare(b.name));
+};
+_MetadataService.addLearningObjective = (name, code, subjectCode, description) => learningObjectiveManager.add({ name, code, subjectCode, description });
+_MetadataService.updateLearningObjective = (id, name, code, subjectCode, description) => learningObjectiveManager.update(id, { name, code, subjectCode, description });
+_MetadataService.deleteLearningObjective = (code) => learningObjectiveManager.delete(code);
+var MetadataService = _MetadataService;
+
+// src/services/questionBankService.ts
+var LocalStorageManager2 = class {
+  constructor(key) {
+    this.key = key;
+  }
+  getAll() {
+    if (typeof window === "undefined") return [];
+    try {
+      const stored = localStorage.getItem(this.key);
+      return stored ? JSON.parse(stored) : [];
+    } catch (e) {
+      console.error(`Error reading from localStorage key ${this.key}:`, e);
+      return [];
+    }
+  }
+  saveAll(items) {
+    if (typeof window === "undefined") return;
+    try {
+      localStorage.setItem(this.key, JSON.stringify(items));
+    } catch (e) {
+      console.error(`Error writing to localStorage key ${this.key}:`, e);
+    }
+  }
+};
+var questionBankManager = new LocalStorageManager2("iqk_question_bank");
+var QuestionBankService = class {
+  static getQuestions(filters) {
+    let questions = questionBankManager.getAll();
+    if (filters) {
+      if (filters.subjectCode) {
+        questions = questions.filter((q) => q.subjectCode === filters.subjectCode);
+      }
+      if (filters.topicCode) {
+        questions = questions.filter((q) => q.topicCode === filters.topicCode);
+      }
+      if (filters.gradeLevelCode) {
+        questions = questions.filter((q) => q.gradeLevelCode === filters.gradeLevelCode);
+      }
+      if (filters.bloomLevelCode) {
+        questions = questions.filter((q) => q.bloomLevelCode === filters.bloomLevelCode);
+      }
+      if (filters.questionTypeCode) {
+        questions = questions.filter((q) => q.questionTypeCode === filters.questionTypeCode);
+      }
+      if (filters.difficulty) {
+        questions = questions.filter((q) => q.difficulty === filters.difficulty);
+      }
+      if (filters.searchTerm) {
+        const lowercasedTerm = filters.searchTerm.toLowerCase();
+        questions = questions.filter(
+          (q) => q.text.toLowerCase().includes(lowercasedTerm) || q.code.toLowerCase().includes(lowercasedTerm)
+        );
+      }
+    }
+    return questions.sort((a, b) => new Date(b.lastModified).getTime() - new Date(a.lastModified).getTime());
+  }
+  static getQuestionByCode(code) {
+    return questionBankManager.getAll().find((q) => q.code === code);
+  }
+  // CHANGE 2: Simplified function signature. It now takes the full object to be added.
+  static addQuestion(questionData) {
+    const allQuestions = questionBankManager.getAll();
+    if (allQuestions.some((q) => q.code === questionData.code)) {
+      throw new Error(`A question with code "${questionData.code}" already exists.`);
+    }
+    const newQuestion = __spreadProps(__spreadValues({}, questionData), {
+      id: generateUniqueId("qb_"),
+      lastModified: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    questionBankManager.saveAll([...allQuestions, newQuestion]);
+    return newQuestion;
+  }
+  // CHANGE 2: Simplified function signature.
+  static updateQuestion(id, updates) {
+    const allQuestions = questionBankManager.getAll();
+    const index = allQuestions.findIndex((q) => q.id === id);
+    if (index === -1) {
+      console.warn(`Question with id "${id}" not found for update.`);
+      return null;
+    }
+    const updatedQuestion = __spreadProps(__spreadValues(__spreadValues({}, allQuestions[index]), updates), {
+      lastModified: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    allQuestions[index] = updatedQuestion;
+    questionBankManager.saveAll(allQuestions);
+    return updatedQuestion;
+  }
+  static deleteQuestionByCode(code) {
+    const allQuestions = questionBankManager.getAll();
+    const newQuestions = allQuestions.filter((q) => q.code !== code);
+    if (allQuestions.length === newQuestions.length) {
+      return false;
+    }
+    questionBankManager.saveAll(newQuestions);
+    return true;
+  }
+};
+
+// src/services/HTMLLauncherGenerator.ts
+var escapeAttribute = (unsafe) => {
+  if (typeof unsafe !== "string") return "";
+  return unsafe.replace(/"/g, '"');
+};
+var generateLauncherHTML = (quizConfig, libraryJSPath, quizDataPath, blocklyCSSPath, mainCSSPath, title) => {
+  const pageTitle = escapeAttribute(title || quizConfig.title || "Interactive Quiz");
+  const relLibraryJSPath = libraryJSPath.startsWith("./") ? libraryJSPath : `./${libraryJSPath}`;
+  const relQuizDataPath = quizDataPath.startsWith("./") ? quizDataPath : `./${quizDataPath}`;
+  const relBlocklyCSSPath = blocklyCSSPath.startsWith("./") ? blocklyCSSPath : `./${blocklyCSSPath}`;
+  const relMainCSSPath = mainCSSPath.startsWith("./") ? mainCSSPath : `./${mainCSSPath}`;
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${pageTitle}</title>
+  <link rel="stylesheet" href="${escapeAttribute(relMainCSSPath)}">
+  <link rel="stylesheet" href="${escapeAttribute(relBlocklyCSSPath)}">
+  <style>
+    /* --- CSS \u0110\u1EC2 C\u0102N GI\u1EEEA CARD --- */
+    html, body {
+      height: 100%; /* \u0110\u1EA3m b\u1EA3o body chi\u1EBFm to\xE0n b\u1ED9 chi\u1EC1u cao */
+      margin: 0;
+    }
+    body { 
+      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol"; 
+      background-color: #f0f2f5; /* M\xE0u n\u1EC1n x\xE1m */
+      color: #1f2937; 
+      
+      /* S\u1EED d\u1EE5ng Flexbox \u0111\u1EC3 c\u0103n gi\u1EEFa */
+      display: flex;
+      justify-content: center; /* C\u0103n gi\u1EEFa theo chi\u1EC1u ngang */
+      align-items: center;   /* C\u0103n gi\u1EEFa theo chi\u1EC1u d\u1ECDc */
+      
+      padding: 20px; /* Th\xEAm m\u1ED9t ch\xFAt l\u1EC1 cho \u0111\u1EB9p m\u1EAFt tr\xEAn m\xE0n h\xECnh nh\u1ECF */
+      box-sizing: border-box; 
+    }
+    #root { 
+      width: 100%; 
+      max-width: 900px; /* Gi\u1EDBi h\u1EA1n chi\u1EC1u r\u1ED9ng t\u1ED1i \u0111a c\u1EE7a card quiz */
+      /* #root s\u1EBD t\u1EF1 \u0111\u1ED9ng co l\u1EA1i theo n\u1ED9i dung b\xEAn trong n\xF3, nh\u01B0ng kh\xF4ng v\u01B0\u1EE3t qu\xE1 900px */
+    }
+    /* C\xE1c style c\xF2n l\u1EA1i gi\u1EEF nguy\xEAn */
+    .loading-spinner { border: 4px solid #e5e7eb; border-top: 4px solid #3b82f6; border-radius: 50%; width: 40px; height: 40px; animation: spin 1s linear infinite; margin: 60px auto 20px auto; }
+    @keyframes spin { 0% { transform: rotate(0deg); } 100% { transform: rotate(360deg); } }
+    .status-message { text-align: center; padding: 20px; margin-top: 10px; color: #4b5563; }
+  </style>
+</head>
+<body>
+  <div id="root">
+    <!-- N\u1ED9i dung ban \u0111\u1EA7u s\u1EBD \u0111\u01B0\u1EE3c React thay th\u1EBF -->
+    <div class="loading-spinner" aria-label="Loading quiz content"></div>
+    <p class="status-message" role="status">Loading Quiz...</p>
+  </div>
+
+  <script type="module">
+    // ... To\xE0n b\u1ED9 ph\u1EA7n script gi\u1EEF nguy\xEAn nh\u01B0 c\u0169 ...
+    import { mountQuizPlayer } from '${escapeAttribute(relLibraryJSPath)}';
+
+    function showStatusMessage(message, isError = false) {
+        const rootEl = document.getElementById('root');
+        if (rootEl) {
+            rootEl.innerHTML = '';
+            const messageEl = document.createElement('p');
+            messageEl.textContent = message;
+            messageEl.className = 'status-message';
+            if(isError) messageEl.style.color = '#ef4444';
+            rootEl.appendChild(messageEl);
+        }
+    }
+
+    async function main() {
+      let quizConfigData;
+      try {
+        const response = await fetch('${escapeAttribute(relQuizDataPath)}');
+        if (!response.ok) {
+          throw new Error('Failed to load quiz data: Status ' + response.status + ' - ' + response.statusText);
+        }
+        quizConfigData = await response.json();
+      } catch (error) {
+        console.error("Error loading quiz data:", error);
+        showStatusMessage('Error: Could not load quiz configuration. ' + error.message, true);
+        return;
+      }
+
+      if (typeof mountQuizPlayer !== 'function') {
+        showStatusMessage('Error: Quiz mount function not found in the library bundle. The build might be corrupted.', true);
+        return;
+      }
+      
+      const rootElement = document.getElementById('root');
+      if (rootElement) {
+        rootElement.innerHTML = '';
+        mountQuizPlayer('root', quizConfigData);
+      } else {
+        console.error('Critical Error: Root element (#root) not found in the DOM.');
+        document.body.innerHTML = '<p style="color: red; text-align: center; padding: 20px;">Critical Error: Root HTML element not found.</p>';
+      }
+    }
+
+    if (document.readyState === 'loading') {
+      document.addEventListener('DOMContentLoaded', main);
+    } else {
+      main();
+    }
+  </script>
+</body>
+</html>`;
+};
+
+// src/services/SCORMManifestGenerator.ts
+var escapeXML = (unsafe) => {
+  if (typeof unsafe !== "string") return "";
+  return unsafe.replace(/[<>&'"]/g, (c) => {
+    switch (c) {
+      case "<":
+        return "&lt;";
+      case ">":
+        return "&gt;";
+      case "&":
+        return "&amp;";
+      case "'":
+        return "&apos;";
+      case '"':
+        return "&quot;";
+      default:
+        return c;
+    }
+  });
+};
+var generateSCORMManifest = (quizConfig, scormVersion, launcherFile = "index.html", libraryJSPath = "scorm-bundle/player.js", quizDataPath = "quiz_data.json", blocklyCSSPath = "blockly-styles.css", mainCSSPath = "styles.css") => {
+  var _a;
+  const uniqueId = `iqk_${quizConfig.id.replace(/[^a-zA-Z0-9_]/g, "_")}`;
+  const organizationId = `ORG-${uniqueId}`;
+  const itemId = `ITEM-${uniqueId}`;
+  const resourceId = `RES-${uniqueId}`;
+  const quizTitle = escapeXML(quizConfig.title);
+  const passingScore = (_a = quizConfig.settings) == null ? void 0 : _a.passingScorePercent;
+  const effectiveScormVersion = scormVersion;
+  const schemaVersion = effectiveScormVersion === "2004" ? "2004 4th Edition" : "1.2";
+  const adlcpNamespace = effectiveScormVersion === "2004" ? "http://www.adlnet.org/xsd/adlcp_v1p3" : "http://www.adlnet.org/xsd/adlcp_rootv1p2";
+  const imsmdNamespace = effectiveScormVersion === "2004" ? "http://www.imsglobal.org/xsd/imsmd_v1p2" : "http://www.imsglobal.org/xsd/imsmd_rootv1p2p1";
+  const xsiSchemaLocation = effectiveScormVersion === "2004" ? "http://www.imsglobal.org/xsd/imscp_v1p1 imscp_v1p1.xsd http://www.adlnet.org/xsd/adlcp_v1p3 adlcp_v1p3.xsd http://www.imsglobal.org/xsd/imsmd_v1p2 imsmd_v1p2p2.xsd" : "http://www.imsglobal.org/xsd/imscp_v1p1 imscp_v1p1.xsd http://www.adlnet.org/xsd/adlcp_rootv1p2 adlcp_rootv1p2.xsd http://www.imsglobal.org/xsd/imsmd_rootv1p2p1 imsmd_rootv1p2p1.xsd";
+  const files = [
+    launcherFile,
+    libraryJSPath,
+    quizDataPath,
+    blocklyCSSPath,
+    mainCSSPath
+  ].map((file) => `<file href="${escapeXML(file)}"/>`).join("\n      ");
+  const manifestHeader = effectiveScormVersion === "2004" ? `<?xml version="1.0" encoding="UTF-8"?>
+<manifest identifier="${uniqueId}-MANIFEST" version="1.0" 
+          xmlns="http://www.imsglobal.org/xsd/imscp_v1p1"
+          xmlns:adlcp="${adlcpNamespace}"
+          xmlns:imsmd="${imsmdNamespace}"
+          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+          xsi:schemaLocation="${xsiSchemaLocation}">` : (
+    // SCORM 1.2
+    `<?xml version="1.0" encoding="UTF-8"?>
+<manifest identifier="${uniqueId}-MANIFEST" version="1.2" 
+          xmlns="http://www.imsproject.org/xsd/imscp_rootv1p1p2"
+          xmlns:adlcp="${adlcpNamespace}"
+          xmlns:imsmd="${imsmdNamespace}"
+          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+          xsi:schemaLocation="${xsiSchemaLocation}">`
+  );
+  const organizationStructure = effectiveScormVersion === "2004" ? `<organizations default="${organizationId}">
+    <organization identifier="${organizationId}" structure="hierarchical">
+      <title>${quizTitle}</title>
+      <item identifier="${itemId}" identifierref="${resourceId}">
+        <title>${quizTitle}</title>
+        ${passingScore !== void 0 ? `<adlcp:masteryscore>${passingScore}</adlcp:masteryscore>` : ""}
+      </item>
+    </organization>
+  </organizations>` : (
+    // SCORM 1.2
+    `<organizations default="${organizationId}">
+    <organization identifier="${organizationId}">
+      <title>${quizTitle}</title>
+      <item identifier="${itemId}" identifierref="${resourceId}" isvisible="true">
+        <title>${quizTitle}</title>
+        ${passingScore !== void 0 ? `<adlcp:masteryscore>${passingScore}</adlcp:masteryscore>` : ""}
+      </item>
+    </organization>
+  </organizations>`
+  );
+  const resourceScormType = effectiveScormVersion === "2004" ? "sco" : "sco";
+  return `${manifestHeader}
+  <metadata>
+    <schema>ADL SCORM</schema>
+    <schemaversion>${schemaVersion}</schemaversion>
+    <imsmd:lom>
+      <imsmd:general>
+        <imsmd:title>
+          <imsmd:langstring xml:lang="en">${quizTitle}</imsmd:langstring>
+        </imsmd:title>
+        ${quizConfig.description ? `<imsmd:description><imsmd:langstring xml:lang="en">${escapeXML(quizConfig.description)}</imsmd:langstring></imsmd:description>` : ""}
+      </imsmd:general>
+    </imsmd:lom>
+  </metadata>
+  ${organizationStructure}
+  <resources>
+    <resource identifier="${resourceId}" type="webcontent" adlcp:scormtype="${resourceScormType}" href="${escapeXML(launcherFile)}">
+      ${files}
+    </resource>
+  </resources>
+</manifest>`;
+};
+var sanitizeFilename = (name) => {
+  return name.replace(/[^a-z0-9_.-]/gi, "_").toLowerCase();
+};
+var exportQuizAsSCORMZip = async (quiz, options) => {
+  try {
+    const zip = new JSZip();
+    const playerJSUrlToFetch = "/static/scorm-bundle/player.js";
+    const mainCSSUrlToFetch = "/static/scorm-bundle/styles.css";
+    const blocklyCSSUrlToFetch = "/blockly-styles.css";
+    const libraryJSPathInZip = "player.js";
+    const mainCSSPathInZip = "styles.css";
+    const blocklyCSSPathInZip = "blockly-styles.css";
+    const quizDataPathInZip = "quiz_data.json";
+    console.log(`Fetching Player JS from: ${playerJSUrlToFetch}`);
+    console.log(`Fetching Main CSS from: ${mainCSSUrlToFetch}`);
+    const [playerJSContent, mainCSSContent, blocklyCSSContent] = await Promise.all([
+      // Fetch file JS của player
+      fetch(playerJSUrlToFetch).then((res) => {
+        if (!res.ok) throw new Error(`Could not fetch Player JS at ${playerJSUrlToFetch}. Make sure the file exists in your app's public folder.`);
+        return res.text();
+      }),
+      // Fetch file CSS chính
+      fetch(mainCSSUrlToFetch).then((res) => {
+        if (!res.ok) throw new Error(`Could not fetch Main CSS at ${mainCSSUrlToFetch}. Make sure the file exists in your app's public folder.`);
+        return res.text();
+      }),
+      // Fetch file CSS của Blockly (tùy chọn)
+      fetch(blocklyCSSUrlToFetch).then((res) => {
+        if (!res.ok) {
+          console.warn(`Could not fetch ${blocklyCSSUrlToFetch}. This is okay if you don't use Blockly/Scratch questions.`);
+          return "";
+        }
+        return res.text();
+      })
+    ]);
+    zip.file(libraryJSPathInZip, playerJSContent);
+    zip.file(mainCSSPathInZip, mainCSSContent);
+    if (blocklyCSSContent) {
+      zip.file(blocklyCSSPathInZip, blocklyCSSContent);
+    }
+    const quizDataString = JSON.stringify(quiz, null, 2);
+    zip.file(quizDataPathInZip, quizDataString);
+    const manifestContent = generateSCORMManifest(
+      quiz,
+      options.scormVersion,
+      "index.html",
+      libraryJSPathInZip,
+      quizDataPathInZip,
+      blocklyCSSPathInZip,
+      mainCSSPathInZip
+    );
+    zip.file("imsmanifest.xml", manifestContent);
+    const launcherContent = generateLauncherHTML(
+      quiz,
+      libraryJSPathInZip,
+      quizDataPathInZip,
+      blocklyCSSPathInZip,
+      mainCSSPathInZip,
+      quiz.title
+    );
+    zip.file("index.html", launcherContent);
+    const blob = await zip.generateAsync({ type: "blob" });
+    const fileName = `${sanitizeFilename(quiz.title || "quiz")}_scorm_${options.scormVersion.replace(".", "_")}.zip`;
+    const link = document.createElement("a");
+    link.href = URL.createObjectURL(blob);
+    link.download = fileName;
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    URL.revokeObjectURL(link.href);
+    return { success: true, fileName };
+  } catch (err) {
+    console.error("Error creating SCORM ZIP:", err);
+    return { success: false, error: err instanceof Error ? err.message : "Unknown error during ZIP creation." };
+  }
+};
+
+// src/services/sampleQuiz.ts
+var trueFalseQ1 = {
+  id: generateUniqueId("tfq_"),
+  questionType: "true_false",
+  prompt: "B\u1EA7u tr\u1EDDi c\xF3 m\xE0u xanh do hi\u1EC7n t\u01B0\u1EE3ng t\xE1n x\u1EA1 Rayleigh.",
+  correctAnswer: true,
+  points: 10,
+  explanation: "T\xE1n x\u1EA1 Rayleigh khi\u1EBFn \xE1nh s\xE1ng xanh t\xE1n x\u1EA1 nhi\u1EC1u h\u01A1n c\xE1c m\xE0u kh\xE1c v\xEC n\xF3 truy\u1EC1n \u0111i d\u01B0\u1EDBi d\u1EA1ng s\xF3ng ng\u1EAFn h\u01A1n, nh\u1ECF h\u01A1n.",
+  difficulty: "easy",
+  topic: "V\u1EADt l\xFD",
+  category: "Khoa h\u1ECDc",
+  learningObjective: "Hi\u1EC3u v\u1EC1 quang h\u1ECDc kh\xED quy\u1EC3n c\u01A1 b\u1EA3n."
+};
+var mcq1 = {
+  id: generateUniqueId("mcq_"),
+  questionType: "multiple_choice",
+  prompt: "Th\u1EE7 \u0111\xF4 c\u1EE7a Ph\xE1p l\xE0 g\xEC?",
+  options: [
+    { id: generateUniqueId("opt_"), text: "Berlin" },
+    { id: generateUniqueId("opt_"), text: "Madrid" },
+    { id: generateUniqueId("opt_"), text: "Paris" },
+    { id: generateUniqueId("opt_"), text: "Rome" }
+  ],
+  correctAnswerId: "",
+  points: 15,
+  difficulty: "easy",
+  topic: "\u0110\u1ECBa l\xFD",
+  category: "Khoa h\u1ECDc X\xE3 h\u1ED9i"
+};
+var parisOption = mcq1.options.find((opt) => opt.text === "Paris");
+if (parisOption) {
+  mcq1.correctAnswerId = parisOption.id;
+}
+var mrq1_opt1_id = generateUniqueId("opt_");
+var mrq1_opt2_id = generateUniqueId("opt_");
+var mrq1_opt3_id = generateUniqueId("opt_");
+var mrq1_opt4_id = generateUniqueId("opt_");
+var mrq1_opt5_id = generateUniqueId("opt_");
+var mrq1 = {
+  id: generateUniqueId("mrq_"),
+  questionType: "multiple_response",
+  prompt: "Nh\u1EEFng h\xE0nh tinh n\xE0o sau \u0111\xE2y thu\u1ED9c H\u1EC7 M\u1EB7t Tr\u1EDDi c\xF3 v\xE0nh \u0111ai (rings)?",
+  options: [
+    { id: mrq1_opt1_id, text: "Sao Th\u1ED5 (Saturn)" },
+    { id: mrq1_opt2_id, text: "Sao M\u1ED9c (Jupiter)" },
+    { id: mrq1_opt3_id, text: "Sao Thi\xEAn V\u01B0\u01A1ng (Uranus)" },
+    { id: mrq1_opt4_id, text: "Sao H\u1EA3i V\u01B0\u01A1ng (Neptune)" },
+    { id: mrq1_opt5_id, text: "Tr\xE1i \u0110\u1EA5t (Earth)" }
+  ],
+  correctAnswerIds: [mrq1_opt1_id, mrq1_opt2_id, mrq1_opt3_id, mrq1_opt4_id],
+  points: 20,
+  explanation: "Sao Th\u1ED5 n\u1ED5i ti\u1EBFng v\u1EDBi h\u1EC7 th\u1ED1ng v\xE0nh \u0111ai ph\u1EE9c t\u1EA1p. Sao M\u1ED9c, Sao Thi\xEAn V\u01B0\u01A1ng v\xE0 Sao H\u1EA3i V\u01B0\u01A1ng c\u0169ng c\xF3 v\xE0nh \u0111ai, m\u1EB7c d\xF9 ch\xFAng m\u1EDD h\u01A1n v\xE0 kh\xF3 quan s\xE1t h\u01A1n nhi\u1EC1u so v\u1EDBi v\xE0nh \u0111ai c\u1EE7a Sao Th\u1ED5.",
+  difficulty: "medium",
+  topic: "Thi\xEAn v\u0103n h\u1ECDc",
+  category: "Khoa h\u1ECDc"
+};
+var shortAnswerQ1 = {
+  id: generateUniqueId("saq_"),
+  questionType: "short_answer",
+  prompt: "Ng\xF4n ng\u1EEF l\u1EADp tr\xECnh n\xE0o th\u01B0\u1EDDng \u0111\u01B0\u1EE3c s\u1EED d\u1EE5ng ch\u1EE7 y\u1EBFu cho ph\xE1t tri\u1EC3n web ph\xEDa client-side \u0111\u1EC3 l\xE0m cho c\xE1c trang web tr\u1EDF n\xEAn t\u01B0\u01A1ng t\xE1c?",
+  acceptedAnswers: ["JavaScript", "Javascript", "javascript", "JS", "js"],
+  points: 10,
+  explanation: "JavaScript l\xE0 ng\xF4n ng\u1EEF k\u1ECBch b\u1EA3n ch\xEDnh ch\u1EA1y tr\xEAn tr\xECnh duy\u1EC7t c\u1EE7a ng\u01B0\u1EDDi d\xF9ng \u0111\u1EC3 t\u1EA1o ra c\xE1c trang web t\u01B0\u01A1ng t\xE1c.",
+  difficulty: "easy",
+  topic: "Ph\xE1t tri\u1EC3n Web",
+  category: "C\xF4ng ngh\u1EC7",
+  isCaseSensitive: false
+};
+var numericQ1 = {
+  id: generateUniqueId("nq_"),
+  questionType: "numeric",
+  prompt: "Nhi\u1EC7t \u0111\u1ED9 s\xF4i c\u1EE7a n\u01B0\u1EDBc \u1EDF \xE1p su\u1EA5t kh\xED quy\u1EC3n ti\xEAu chu\u1EA9n l\xE0 bao nhi\xEAu \u0111\u1ED9 C?",
+  answer: 100,
+  tolerance: 1,
+  points: 10,
+  explanation: "N\u01B0\u1EDBc s\xF4i \u1EDF 100 \u0111\u1ED9 C (212 \u0111\u1ED9 F) \u1EDF \xE1p su\u1EA5t kh\xED quy\u1EC3n ti\xEAu chu\u1EA9n.",
+  difficulty: "easy",
+  topic: "H\xF3a h\u1ECDc",
+  category: "Khoa h\u1ECDc"
+};
+var fillInTheBlanksQ1 = {
+  id: generateUniqueId("fitb_"),
+  questionType: "fill_in_the_blanks",
+  prompt: "\u0110i\u1EC1n v\xE0o ch\u1ED7 tr\u1ED1ng \u0111\u1EC3 ho\xE0n th\xE0nh c\xE2u sau:",
+  segments: [
+    { type: "text", content: "N\u01B0\u1EDBc \u0111\u01B0\u1EE3c c\u1EA5u t\u1EA1o t\u1EEB hai nguy\xEAn t\u1ED1 l\xE0 " },
+    { type: "blank", id: "fitb_h" },
+    { type: "text", content: " v\xE0 " },
+    { type: "blank", id: "fitb_o" },
+    { type: "text", content: "." }
+  ],
+  answers: [
+    { blankId: "fitb_h", acceptedValues: ["Hydro", "Hydrogen", "H"] },
+    { blankId: "fitb_o", acceptedValues: ["Oxy", "Oxygen", "O"] }
+  ],
+  isCaseSensitive: false,
+  points: 15,
+  explanation: "N\u01B0\u1EDBc (H\u2082O) \u0111\u01B0\u1EE3c t\u1EA1o th\xE0nh t\u1EEB hai nguy\xEAn t\u1EED Hydro v\xE0 m\u1ED9t nguy\xEAn t\u1EED Oxy.",
+  difficulty: "easy",
+  topic: "H\xF3a h\u1ECDc C\u01A1 b\u1EA3n",
+  category: "Khoa h\u1ECDc"
+};
+var sequenceQ1_item1_id = generateUniqueId("seqi_");
+var sequenceQ1_item2_id = generateUniqueId("seqi_");
+var sequenceQ1_item3_id = generateUniqueId("seqi_");
+var sequenceQ1_item4_id = generateUniqueId("seqi_");
+var sequenceQ1 = {
+  id: generateUniqueId("seqq_"),
+  questionType: "sequence",
+  prompt: "S\u1EAFp x\u1EBFp c\xE1c h\xE0nh tinh sau theo th\u1EE9 t\u1EF1 t\u1EEB g\u1EA7n M\u1EB7t Tr\u1EDDi nh\u1EA5t \u0111\u1EBFn xa nh\u1EA5t:",
+  items: [
+    { id: sequenceQ1_item1_id, content: "Sao H\u1ECFa (Mars)" },
+    { id: sequenceQ1_item2_id, content: "Tr\xE1i \u0110\u1EA5t (Earth)" },
+    { id: sequenceQ1_item3_id, content: "Sao Th\u1EE7y (Mercury)" },
+    { id: sequenceQ1_item4_id, content: "Sao Kim (Venus)" }
+  ],
+  correctOrder: [sequenceQ1_item3_id, sequenceQ1_item4_id, sequenceQ1_item2_id, sequenceQ1_item1_id],
+  points: 20,
+  explanation: "Th\u1EE9 t\u1EF1 \u0111\xFAng c\u1EE7a c\xE1c h\xE0nh tinh t\u1EEB g\u1EA7n M\u1EB7t Tr\u1EDDi nh\u1EA5t l\xE0: Sao Th\u1EE7y, Sao Kim, Tr\xE1i \u0110\u1EA5t, Sao H\u1ECFa.",
+  difficulty: "medium",
+  topic: "Thi\xEAn v\u0103n h\u1ECDc",
+  category: "Khoa h\u1ECDc"
+};
+var matchingQ1_prompt_vn = generateUniqueId("matp_");
+var matchingQ1_prompt_jp = generateUniqueId("matp_");
+var matchingQ1_prompt_us = generateUniqueId("matp_");
+var matchingQ1_opt_hanoi = generateUniqueId("mato_");
+var matchingQ1_opt_tokyo = generateUniqueId("mato_");
+var matchingQ1_opt_dc = generateUniqueId("mato_");
+var matchingQ1 = {
+  id: generateUniqueId("matq_"),
+  questionType: "matching",
+  prompt: "H\xE3y gh\xE9p m\u1ED7i qu\u1ED1c gia v\u1EDBi th\u1EE7 \u0111\xF4 t\u01B0\u01A1ng \u1EE9ng.",
+  prompts: [
+    { id: matchingQ1_prompt_vn, content: "Vi\u1EC7t Nam" },
+    { id: matchingQ1_prompt_jp, content: "Nh\u1EADt B\u1EA3n" },
+    { id: matchingQ1_prompt_us, content: "Hoa K\u1EF3" }
+  ],
+  options: [
+    { id: matchingQ1_opt_tokyo, content: "Tokyo" },
+    { id: matchingQ1_opt_hanoi, content: "H\xE0 N\u1ED9i" },
+    { id: matchingQ1_opt_dc, content: "Washington D.C." }
+  ],
+  correctAnswerMap: [
+    { promptId: matchingQ1_prompt_vn, optionId: matchingQ1_opt_hanoi },
+    { promptId: matchingQ1_prompt_jp, optionId: matchingQ1_opt_tokyo },
+    { promptId: matchingQ1_prompt_us, optionId: matchingQ1_opt_dc }
+  ],
+  points: 15,
+  explanation: "H\xE0 N\u1ED9i l\xE0 th\u1EE7 \u0111\xF4 c\u1EE7a Vi\u1EC7t Nam, Tokyo l\xE0 c\u1EE7a Nh\u1EADt B\u1EA3n, v\xE0 Washington D.C. l\xE0 c\u1EE7a Hoa K\u1EF3.",
+  difficulty: "easy",
+  topic: "\u0110\u1ECBa l\xFD Th\u1EBF gi\u1EDBi",
+  shuffleOptions: true
+};
+var dndQ1_drag_apple = generateUniqueId("dndi_");
+var dndQ1_drag_banana = generateUniqueId("dndi_");
+var dndQ1_drag_orange = generateUniqueId("dndi_");
+var dndQ1_drop_red = generateUniqueId("dndz_");
+var dndQ1_drop_yellow = generateUniqueId("dndz_");
+var dndQ1_drop_orange_color = generateUniqueId("dndz_");
+var dragAndDropQ1 = {
+  id: generateUniqueId("dndq_"),
+  questionType: "drag_and_drop",
+  prompt: "K\xE9o c\xE1c lo\u1EA1i tr\xE1i c\xE2y v\xE0o \u0111\xFAng gi\u1ECF m\xE0u c\u1EE7a ch\xFAng (theo logic gh\xE9p n\u1ED1i \u0111\u01A1n gi\u1EA3n).",
+  draggableItems: [
+    { id: dndQ1_drag_apple, content: "T\xE1o" },
+    { id: dndQ1_drag_banana, content: "Chu\u1ED1i" },
+    { id: dndQ1_drag_orange, content: "Cam" }
+  ],
+  dropZones: [
+    { id: dndQ1_drop_red, label: "Gi\u1ECF \u0110\u1ECF" },
+    { id: dndQ1_drop_yellow, label: "Gi\u1ECF V\xE0ng" },
+    { id: dndQ1_drop_orange_color, label: "Gi\u1ECF Cam" }
+  ],
+  answerMap: [
+    { draggableId: dndQ1_drag_apple, dropZoneId: dndQ1_drop_red },
+    { draggableId: dndQ1_drag_banana, dropZoneId: dndQ1_drop_yellow },
+    { draggableId: dndQ1_drag_orange, dropZoneId: dndQ1_drop_orange_color }
+  ],
+  points: 15,
+  explanation: "T\xE1o th\u01B0\u1EDDng c\xF3 m\xE0u \u0111\u1ECF (gi\u1ECF \u0111\u1ECF), chu\u1ED1i m\xE0u v\xE0ng (gi\u1ECF v\xE0ng), v\xE0 cam c\xF3 m\xE0u cam (gi\u1ECF cam).",
+  difficulty: "easy",
+  topic: "M\xE0u s\u1EAFc v\xE0 V\u1EADt th\u1EC3",
+  backgroundImageUrl: "https://placehold.co/600x200.png",
+  imageAltText: "colored baskets"
+};
+var hotspotQ1_engine_left = generateUniqueId("hs_");
+var hotspotQ1_engine_right = generateUniqueId("hs_");
+var hotspotQ1_cockpit = generateUniqueId("hs_");
+var hotspotQ1 = {
+  id: generateUniqueId("hsq_"),
+  questionType: "hotspot",
+  prompt: "Nh\u1EA5p v\xE0o (c\xE1c) \u0111\u1ED9ng c\u01A1 c\u1EE7a m\xE1y bay trong h\xECnh.",
+  imageUrl: "https://placehold.co/600x400.png",
+  imageAltText: "airplane diagram",
+  hotspots: [
+    { id: hotspotQ1_engine_left, shape: "rect", coords: [150, 200, 80, 60], description: "\u0110\u1ED9ng c\u01A1 b\xEAn tr\xE1i" },
+    { id: hotspotQ1_engine_right, shape: "rect", coords: [370, 200, 80, 60], description: "\u0110\u1ED9ng c\u01A1 b\xEAn ph\u1EA3i" },
+    { id: hotspotQ1_cockpit, shape: "rect", coords: [250, 120, 100, 70], description: "Bu\u1ED3ng l\xE1i" }
+  ],
+  correctHotspotIds: [hotspotQ1_engine_left, hotspotQ1_engine_right],
+  points: 15,
+  explanation: "M\xE1y bay n\xE0y c\xF3 hai \u0111\u1ED9ng c\u01A1 ch\xEDnh, n\u1EB1m d\u01B0\u1EDBi c\xE1nh.",
+  difficulty: "medium",
+  topic: "H\xE0ng kh\xF4ng",
+  category: "K\u1EF9 thu\u1EADt"
+};
+var blocklyQ1 = {
+  id: generateUniqueId("blkq_"),
+  questionType: "blockly_programming",
+  prompt: "S\u1EED d\u1EE5ng c\xE1c kh\u1ED1i l\u1EC7nh \u0111\u1EC3 t\u1EA1o m\u1ED9t ch\u01B0\u01A1ng tr\xECnh in ra d\xF2ng ch\u1EEF 'Hello, World!' v\xE0o console.",
+  points: 25,
+  difficulty: "easy",
+  topic: "L\u1EADp tr\xECnh C\u01A1 b\u1EA3n",
+  category: "C\xF4ng ngh\u1EC7 Th\xF4ng tin",
+  toolboxDefinition: `
+    <xml xmlns="https://developers.google.com/blockly/xml">
+      <category name="Text" colour="%{BKY_TEXTS_HUE}">
+        <block type="text"></block>
+        <block type="text_print"></block>
+      </category>
+    </xml>
+  `,
+  initialWorkspace: `
+    <xml xmlns="https://developers.google.com/blockly/xml">
+      <block type="text_print" id="${generateUniqueId("blki_")}" x="70" y="70">
+        <value name="TEXT">
+          <shadow type="text" id="${generateUniqueId("blki_")}">
+            <field name="TEXT">abc</field>
+          </shadow>
+        </value>
+      </block>
+    </xml>
+  `,
+  solutionWorkspaceXML: `
+    <xml xmlns="https://developers.google.com/blockly/xml">
+      <block type="text_print" id="${generateUniqueId("blki_solution_")}" x="70" y="70">
+        <value name="TEXT">
+          <block type="text" id="${generateUniqueId("blki_text_solution_")}">
+            <field name="TEXT">Hello, World!</field>
+          </block>
+        </value>
+      </block>
+    </xml>
+  `,
+  solutionGeneratedCode: "window.alert('Hello, World!');",
+  // Normalized JS code
+  explanation: "Ch\u01B0\u01A1ng tr\xECnh c\u1EA7n s\u1EED d\u1EE5ng kh\u1ED1i 'print' v\u1EDBi \u0111\u1EA7u v\xE0o l\xE0 kh\u1ED1i v\u0103n b\u1EA3n ch\u1EE9a 'Hello, World!'."
+};
+var scratchQ1 = {
+  id: generateUniqueId("scrq_"),
+  questionType: "scratch_programming",
+  prompt: "D\xF9ng kh\u1ED1i l\u1EC7nh Scratch \u0111\u1EC3 di chuy\u1EC3n nh\xE2n v\u1EADt v\u1EC1 ph\xEDa tr\u01B0\u1EDBc 10 b\u01B0\u1EDBc khi c\u1EDD xanh \u0111\u01B0\u1EE3c click.",
+  points: 20,
+  difficulty: "easy",
+  topic: "L\u1EADp tr\xECnh Scratch",
+  category: "C\xF4ng ngh\u1EC7 Th\xF4ng tin",
+  toolboxDefinition: `
+    <xml xmlns="https://developers.google.com/blockly/xml">
+      <category name="Motion" colour="#4C97FF">
+        <block type="motion_movesteps"></block>
+      </category>
+      <category name="Events" colour="#FFBF00">
+        <block type="event_whenflagclicked"></block>
+      </category>
+    </xml>
+  `,
+  initialWorkspace: `
+    <xml xmlns="https://developers.google.com/blockly/xml"></xml>
+  `,
+  solutionWorkspaceXML: `
+    <xml xmlns="https://developers.google.com/blockly/xml">
+      <block type="event_whenflagclicked" id="${generateUniqueId("scr_event_")}" x="50" y="50">
+        <next>
+          <block type="motion_movesteps" id="${generateUniqueId("scr_motion_")}">
+            <value name="STEPS">
+              <shadow type="math_number">
+                <field name="NUM">10</field>
+              </shadow>
+            </value>
+          </block>
+        </next>
+      </block>
+    </xml>
+  `,
+  solutionGeneratedCode: "whenGreenFlagClicked(() => { move(10); });",
+  // Example pseudo-code or JS representation
+  explanation: "S\u1EED d\u1EE5ng kh\u1ED1i 'when green flag clicked' t\u1EEB Events v\xE0 kh\u1ED1i 'move 10 steps' t\u1EEB Motion."
+};
+var sampleQuiz = {
+  id: "sample-quiz-001",
+  title: "Sample Quiz for Testers",
+  description: "A short quiz with a few different question types to test the QuizKit functionality.",
+  questions: [
+    trueFalseQ1,
+    mcq1,
+    mrq1,
+    shortAnswerQ1,
+    numericQ1,
+    fillInTheBlanksQ1,
+    sequenceQ1,
+    matchingQ1,
+    dragAndDropQ1,
+    hotspotQ1,
+    blocklyQ1,
+    scratchQ1
+    // Added Scratch question
+  ],
+  settings: {
+    shuffleQuestions: true,
+    shuffleOptions: true,
+    showCorrectAnswers: "end_of_quiz",
+    passingScorePercent: 70,
+    timeLimitMinutes: 25
+  }
+};
+var emptyQuiz = {
+  id: generateUniqueId("quiz_"),
+  title: "New Quiz",
+  description: "",
+  questions: [],
+  settings: {
+    language: "English",
+    // <-- ĐÃ THÊM
+    shuffleQuestions: false,
+    shuffleOptions: false,
+    showCorrectAnswers: "end_of_quiz",
+    passingScorePercent: 0,
+    timeLimitMinutes: 0
+  }
+};
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+
+export { APIKeyService, AchievementService, GEMINI_API_KEY_SERVICE_NAME, KnowledgeCardService, MetadataService, PracticeHistoryService, QuestionBankService, QuestionImportService, QuizEditorService, QuizEngine, QuoteService, SCORMService, UserConfigService, cn, emptyQuiz, exportQuizAsSCORMZip, generateLauncherHTML, generateSCORMManifest, generateUniqueId, sampleQuiz };