@orjok/commons 1.0.2

package/dist/index.cjs

@@ -0,0 +1,1723 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/services/user.service.ts
+var UserService = class {
+  constructor(network) {
+    this.network = network;
+  }
+  async get(id) {
+    const result = await this.network.query(
+      `query GetUser($id: String!) {
+        getUser(id: $id) {
+          id fullName avatarUrl avatarConfig tier subscriptionExpiresAt
+          aiEvaluationRemaining questionCount packCount contestCount
+          EngineeringRating MedicalRating VarsityRating BCSRating
+          sscOverallRating sscPhysicsRating sscChemistryRating sscMathRating sscBiologyRating
+          hscOverallRating hscPhysicsRating hscChemistryRating hscMathRating hscBiologyRating
+          bcsOverallRating
+        }
+      }`,
+      { id }
+    );
+    return result.data.getUser;
+  }
+  async updateAvatar(input) {
+    const result = await this.network.mutate(
+      `mutation UpdateUser($input: UpdateUserInput!) {
+        updateUser(input: $input) {
+          id fullName avatarUrl avatarConfig
+        }
+      }`,
+      { input: { id: input.userId, avatarUrl: input.avatarUrl, avatarConfig: input.avatarConfig } }
+    );
+    return result.data.updateUser;
+  }
+  async getQuestions(userId, nextToken) {
+    const result = await this.network.query(
+      `query ListUserQuestions($owner: ID!, $nextToken: String, $sortDirection: ModelSortDirection) {
+        listQuestionObjectByOwnerAndCreatedAt(owner: $owner, sortDirection: $sortDirection, nextToken: $nextToken) {
+          items {
+            id question imageUrl language level difficulty type voteCount
+            verificationStatus owner packId createdAt
+            options { items { id content } }
+            tags { items { id tagId } }
+          }
+          nextToken
+        }
+      }`,
+      { owner: userId, nextToken, sortDirection: "DESC" }
+    );
+    return result.data.listQuestionObjectByOwnerAndCreatedAt;
+  }
+  async getPacks(userId, nextToken) {
+    const result = await this.network.query(
+      `query ListUserPacks($owner: ID!, $nextToken: String, $sortDirection: ModelSortDirection) {
+        listPackByOwnerAndCreatedAt(owner: $owner, sortDirection: $sortDirection, nextToken: $nextToken) {
+          items {
+            id name language level difficulty questionCount automaticNumbering
+            owner subjectId chapterId topicId verificationStatus createdAt
+            tags { items { id tagId } }
+          }
+          nextToken
+        }
+      }`,
+      { owner: userId, nextToken, sortDirection: "DESC" }
+    );
+    return result.data.listPackByOwnerAndCreatedAt;
+  }
+  async getCourses(userId) {
+    const result = await this.network.query(
+      `query ListUserCourses($owner: ID!, $sortDirection: ModelSortDirection) {
+        listCourseByOwnerAndCreatedAt(owner: $owner, sortDirection: $sortDirection) {
+          items {
+            id name description imageUrl videoCount fileCount price totalEnrolled owner createdAt
+          }
+        }
+      }`,
+      { owner: userId, sortDirection: "DESC" }
+    );
+    return result.data.listCourseByOwnerAndCreatedAt.items;
+  }
+  async getEnrolledCourses(userId) {
+    const result = await this.network.query(
+      `query ListEnrolledCourses($userId: ID!, $sortDirection: ModelSortDirection) {
+        listCourseEnrolledByUserIdAndCreatedAt(userId: $userId, sortDirection: $sortDirection) {
+          items {
+            id courseId userId score rank createdAt
+            course { id name description imageUrl price totalEnrolled }
+          }
+        }
+      }`,
+      { userId, sortDirection: "DESC" }
+    );
+    return result.data.listCourseEnrolledByUserIdAndCreatedAt.items;
+  }
+};
+
+// src/services/question.service.ts
+var QuestionService = class {
+  constructor(network) {
+    this.network = network;
+  }
+  async create(input) {
+    const result = await this.network.mutate(
+      `mutation CreateQuestion($question: String!, $answer: String!, $options: String!, $language: String!, $level: String!, $difficulty: String!, $type: String, $explanation: String, $tags: String, $imagePayload: String, $optionsImagesPayload: String, $packId: ID, $order: Int, $contestId: ID, $subjectId: ID, $chapterId: ID, $topicId: ID, $extra: String, $markingInstructions: String) {
+        createQuestion(question: $question, answer: $answer, options: $options, language: $language, level: $level, difficulty: $difficulty, type: $type, explanation: $explanation, tags: $tags, imagePayload: $imagePayload, optionsImagesPayload: $optionsImagesPayload, packId: $packId, order: $order, contestId: $contestId, subjectId: $subjectId, chapterId: $chapterId, topicId: $topicId, extra: $extra, markingInstructions: $markingInstructions) {
+          status questionId
+        }
+      }`,
+      input
+    );
+    return result.data.createQuestion;
+  }
+  async get(id) {
+    const result = await this.network.query(
+      `query GetQuestion($id: String!) {
+        getQuestionObject(id: $id) {
+          id question imageUrl language level difficulty type voteCount
+          verificationStatus owner packId subjectId chapterId topicId order createdAt
+          options { items { id content } }
+          tags { items { id tagId } }
+        }
+      }`,
+      { id }
+    );
+    return result.data.getQuestionObject;
+  }
+  async getFull(id) {
+    const result = await this.network.query(
+      `query GetFullQuestion($id: String!) {
+        getQuestionObject(id: $id) {
+          id question answer explanation extra imageUrl language level difficulty type
+          markingInstructions voteCount verificationStatus owner packId
+          subjectId chapterId topicId order createdAt
+          options { items { id content } }
+          tags { items { id tagId } }
+          user { id fullName avatarUrl }
+        }
+      }`,
+      { id }
+    );
+    return result.data.getQuestionObject;
+  }
+  async getAnswer(id) {
+    const result = await this.network.query(
+      `query GetAnswer($id: String!) {
+        getQuestionObject(id: $id) { answer }
+      }`,
+      { id }
+    );
+    if (!result.data.getQuestionObject) return null;
+    return { id, content: result.data.getQuestionObject.answer };
+  }
+  async getQuestionId(packId, order) {
+    const result = await this.network.query(
+      `query GetQuestionId($packId: ID!, $order: ModelIntKeyConditionInput) {
+        listQuestionObjectByPackIdAndOrder(packId: $packId, order: $order, limit: 1) {
+          items { id }
+        }
+      }`,
+      { packId, order: { eq: order } }
+    );
+    return _nullishCoalesce(_optionalChain([result, 'access', _2 => _2.data, 'access', _3 => _3.listQuestionObjectByPackIdAndOrder, 'access', _4 => _4.items, 'access', _5 => _5[0], 'optionalAccess', _6 => _6.id]), () => ( null));
+  }
+  async update(id, fields) {
+    const result = await this.network.mutate(
+      `mutation UpdateQuestion($input: UpdateQuestionObjectInput!) {
+        updateQuestionObject(input: $input) {
+          id question answer explanation extra imageUrl language level difficulty type
+          markingInstructions voteCount owner packId subjectId chapterId topicId order createdAt
+          options { items { id content } }
+        }
+      }`,
+      { input: { id, ...fields } }
+    );
+    return result.data.updateQuestionObject;
+  }
+  async delete(id) {
+    const result = await this.network.mutate(
+      `mutation DeleteQuestion($input: DeleteQuestionObjectInput!) {
+        deleteQuestionObject(input: $input) { id }
+      }`,
+      { input: { id } }
+    );
+    return result.data.deleteQuestionObject;
+  }
+  async vote(input) {
+    const result = await this.network.mutate(
+      `mutation Vote($questionId: ID!, $type: String!, $modelType: String!) {
+        vote(questionId: $questionId, type: $type, modelType: $modelType) {
+          status id
+        }
+      }`,
+      input
+    );
+    return result.data.vote;
+  }
+  async upVote(questionId) {
+    return this.vote({ questionId, type: "upvote", modelType: "question" });
+  }
+  async downVote(questionId) {
+    return this.vote({ questionId, type: "downvote", modelType: "question" });
+  }
+  async verify(id, userId) {
+    const result = await this.network.mutate(
+      `mutation VerifyQuestion($input: CreateVerificationInput!) {
+        createVerification(input: $input) { id verifiedObjectId type userId }
+      }`,
+      { input: { verifiedObjectId: id, type: "question", userId } }
+    );
+    return result.data.createVerification;
+  }
+  async report(id, reason) {
+    const result = await this.network.mutate(
+      `mutation ReportQuestion($input: CreateQuestionReportInput!) {
+        createQuestionReport(input: $input) { id }
+      }`,
+      { input: { questionId: id, reason } }
+    );
+    return result.data.createQuestionReport;
+  }
+  async addTags(input) {
+    const result = await this.network.mutate(
+      `mutation AddQuestionTag($tags: String!, $packId: ID, $questionId: ID) {
+        addQuestionTag(tags: $tags, packId: $packId, questionId: $questionId) {
+          status
+        }
+      }`,
+      input
+    );
+    return result.data.addQuestionTag;
+  }
+  async listBySubject(input) {
+    const variables = {
+      subjectId: input.id,
+      sortDirection: _nullishCoalesce(input.sortDirection, () => ( "DESC")),
+      limit: _nullishCoalesce(input.limit, () => ( 20)),
+      nextToken: input.nextToken
+    };
+    const result = await this.network.query(
+      `query ListQuestionsBySubject($subjectId: String!, $sortDirection: ModelSortDirection, $limit: Int, $nextToken: String) {
+        listQuestionObjectBySubjectIdAndCreatedAt(subjectId: $subjectId, sortDirection: $sortDirection, limit: $limit, nextToken: $nextToken) {
+          items {
+            id question imageUrl language level difficulty type voteCount
+            verificationStatus owner packId createdAt
+            options { items { id content } }
+          }
+          nextToken
+        }
+      }`,
+      variables
+    );
+    return result.data.listQuestionObjectBySubjectIdAndCreatedAt;
+  }
+  async listByChapter(input) {
+    const variables = {
+      chapterId: input.id,
+      sortDirection: _nullishCoalesce(input.sortDirection, () => ( "DESC")),
+      limit: _nullishCoalesce(input.limit, () => ( 20)),
+      nextToken: input.nextToken
+    };
+    const result = await this.network.query(
+      `query ListQuestionsByChapter($chapterId: String!, $sortDirection: ModelSortDirection, $limit: Int, $nextToken: String) {
+        listQuestionObjectByChapterIdAndCreatedAt(chapterId: $chapterId, sortDirection: $sortDirection, limit: $limit, nextToken: $nextToken) {
+          items {
+            id question imageUrl language level difficulty type voteCount
+            verificationStatus owner packId createdAt
+            options { items { id content } }
+          }
+          nextToken
+        }
+      }`,
+      variables
+    );
+    return result.data.listQuestionObjectByChapterIdAndCreatedAt;
+  }
+  async listByTopic(input) {
+    const variables = {
+      topicId: input.id,
+      sortDirection: _nullishCoalesce(input.sortDirection, () => ( "DESC")),
+      limit: _nullishCoalesce(input.limit, () => ( 20)),
+      nextToken: input.nextToken
+    };
+    const result = await this.network.query(
+      `query ListQuestionsByTopic($topicId: String!, $sortDirection: ModelSortDirection, $limit: Int, $nextToken: String) {
+        listQuestionObjectByTopicIdAndCreatedAt(topicId: $topicId, sortDirection: $sortDirection, limit: $limit, nextToken: $nextToken) {
+          items {
+            id question imageUrl language level difficulty type voteCount
+            verificationStatus owner packId createdAt
+            options { items { id content } }
+          }
+          nextToken
+        }
+      }`,
+      variables
+    );
+    return result.data.listQuestionObjectByTopicIdAndCreatedAt;
+  }
+  async listByRandomHash(input) {
+    const compositeKey = [input.language, input.difficulty].filter(Boolean).join("_");
+    const variables = {
+      subjectId: input.id,
+      sortDirection: _nullishCoalesce(input.sortDirection, () => ( "ASC")),
+      limit: _nullishCoalesce(input.limit, () => ( 1)),
+      language_difficulty_randomHash: input.randomHashFilter ? { beginsWith: compositeKey, ...input.randomHashFilter } : { beginsWith: compositeKey }
+    };
+    const result = await this.network.query(
+      `query ListByRandomHash($subjectId: String!, $language_difficulty_randomHash: ModelStringKeyConditionInput, $sortDirection: ModelSortDirection, $limit: Int) {
+        listQuestionObjectBySubjectIdAndLanguage_difficulty_randomHash(subjectId: $subjectId, language_difficulty_randomHash: $language_difficulty_randomHash, sortDirection: $sortDirection, limit: $limit) {
+          items {
+            id question imageUrl language level difficulty type voteCount
+            verificationStatus owner packId subjectId chapterId topicId createdAt
+            options { items { id content } }
+          }
+          nextToken
+        }
+      }`,
+      variables
+    );
+    return result.data.listQuestionObjectBySubjectIdAndLanguage_difficulty_randomHash;
+  }
+};
+
+// src/services/pack.service.ts
+var PackService = class {
+  constructor(network) {
+    this.network = network;
+  }
+  async create(input) {
+    const result = await this.network.mutate(
+      `mutation CreatePack($name: String!, $level: String!, $language: String!, $difficulty: String!, $automaticNumbering: Boolean, $subjectId: ID, $chapterId: ID, $topicId: ID) {
+        createPackObject(name: $name, level: $level, language: $language, difficulty: $difficulty, automaticNumbering: $automaticNumbering, subjectId: $subjectId, chapterId: $chapterId, topicId: $topicId) {
+          status id
+        }
+      }`,
+      input
+    );
+    return result.data.createPackObject;
+  }
+  async get(id) {
+    const result = await this.network.query(
+      `query GetPack($id: ID!) {
+        getPack(id: $id) {
+          id name language level difficulty questionCount automaticNumbering
+          owner subjectId chapterId topicId packGroupId verificationStatus createdAt
+          tags { items { id tagId } }
+          user { id fullName avatarUrl }
+        }
+      }`,
+      { id }
+    );
+    return result.data.getPack;
+  }
+  async getFull(id) {
+    const result = await this.network.query(
+      `query GetFullPack($id: ID!) {
+        getPack(id: $id) {
+          id name language level difficulty questionCount automaticNumbering
+          owner subjectId chapterId topicId packGroupId verificationStatus createdAt
+          tags { items { id tagId } }
+          user { id fullName avatarUrl }
+          questions(sortDirection: ASC, limit: 200) {
+            items {
+              id question answer explanation extra imageUrl language level difficulty type
+              markingInstructions voteCount owner order createdAt
+              options { items { id content } }
+              tags { items { id tagId } }
+            }
+          }
+        }
+      }`,
+      { id }
+    );
+    return result.data.getPack;
+  }
+  async update(id, fields) {
+    const result = await this.network.mutate(
+      `mutation UpdatePack($input: UpdatePackInput!) {
+        updatePack(input: $input) {
+          id name language level difficulty questionCount automaticNumbering
+          owner subjectId chapterId topicId verificationStatus createdAt
+        }
+      }`,
+      { input: { id, ...fields } }
+    );
+    return result.data.updatePack;
+  }
+  async delete(id) {
+    const result = await this.network.mutate(
+      `mutation DeletePack($input: DeletePackInput!) {
+        deletePack(input: $input) { id }
+      }`,
+      { input: { id } }
+    );
+    return result.data.deletePack;
+  }
+  async verify(id, userId) {
+    const result = await this.network.mutate(
+      `mutation VerifyPack($input: CreateVerificationInput!) {
+        createVerification(input: $input) { id verifiedObjectId type userId }
+      }`,
+      { input: { verifiedObjectId: id, type: "pack", userId } }
+    );
+    return result.data.createVerification;
+  }
+  async report(id, reason) {
+    const result = await this.network.mutate(
+      `mutation ReportPack($input: CreatePackReportInput!) {
+        createPackReport(input: $input) { id }
+      }`,
+      { input: { packId: id, reason } }
+    );
+    return result.data.createPackReport;
+  }
+  async submitExam(packId, selectedOptions) {
+    const result = await this.network.mutate(
+      `mutation SubmitPackExam($packId: ID!, $selectedOptions: String!) {
+        submitPackExam(packId: $packId, selectedOptions: $selectedOptions) {
+          status id
+        }
+      }`,
+      { packId, selectedOptions: JSON.stringify(selectedOptions) }
+    );
+    return result.data.submitPackExam;
+  }
+  async getExams(userId, nextToken) {
+    const result = await this.network.query(
+      `query ListPackExams($owner: ID!, $sortDirection: ModelSortDirection, $nextToken: String) {
+        listPackExamResultsByOwnerAndCreatedAt(owner: $owner, sortDirection: $sortDirection, nextToken: $nextToken) {
+          items {
+            id packId selectedOptions aiEvaluations owner createdAt
+            pack { id name language level difficulty questionCount }
+          }
+          nextToken
+        }
+      }`,
+      { owner: userId, sortDirection: "DESC", nextToken }
+    );
+    return result.data.listPackExamResultsByOwnerAndCreatedAt;
+  }
+  async getExamResult(resultId) {
+    const result = await this.network.query(
+      `query GetPackExamResult($id: ID!) {
+        getPackExamResults(id: $id) {
+          id packId selectedOptions aiEvaluations owner createdAt
+          pack { id name language level difficulty questionCount }
+        }
+      }`,
+      { id: resultId }
+    );
+    return result.data.getPackExamResults;
+  }
+  async listBySubject(input) {
+    const result = await this.network.query(
+      `query ListPacksBySubject($subjectId: String!, $sortDirection: ModelSortDirection, $limit: Int, $nextToken: String) {
+        listPackBySubjectIdAndCreatedAt(subjectId: $subjectId, sortDirection: $sortDirection, limit: $limit, nextToken: $nextToken) {
+          items {
+            id name language level difficulty questionCount owner createdAt verificationStatus
+            tags { items { id tagId } }
+          }
+          nextToken
+        }
+      }`,
+      { subjectId: input.id, sortDirection: "DESC", limit: _nullishCoalesce(input.limit, () => ( 20)), nextToken: input.nextToken }
+    );
+    return result.data.listPackBySubjectIdAndCreatedAt;
+  }
+  async listByChapter(input) {
+    const result = await this.network.query(
+      `query ListPacksByChapter($chapterId: String!, $sortDirection: ModelSortDirection, $limit: Int, $nextToken: String) {
+        listPackByChapterIdAndCreatedAt(chapterId: $chapterId, sortDirection: $sortDirection, limit: $limit, nextToken: $nextToken) {
+          items {
+            id name language level difficulty questionCount owner createdAt verificationStatus
+            tags { items { id tagId } }
+          }
+          nextToken
+        }
+      }`,
+      { chapterId: input.id, sortDirection: "DESC", limit: _nullishCoalesce(input.limit, () => ( 20)), nextToken: input.nextToken }
+    );
+    return result.data.listPackByChapterIdAndCreatedAt;
+  }
+  async listByTopic(input) {
+    const result = await this.network.query(
+      `query ListPacksByTopic($topicId: String!, $sortDirection: ModelSortDirection, $limit: Int, $nextToken: String) {
+        listPackByTopicIdAndCreatedAt(topicId: $topicId, sortDirection: $sortDirection, limit: $limit, nextToken: $nextToken) {
+          items {
+            id name language level difficulty questionCount owner createdAt verificationStatus
+            tags { items { id tagId } }
+          }
+          nextToken
+        }
+      }`,
+      { topicId: input.id, sortDirection: "DESC", limit: _nullishCoalesce(input.limit, () => ( 20)), nextToken: input.nextToken }
+    );
+    return result.data.listPackByTopicIdAndCreatedAt;
+  }
+  async listGroups(type, level) {
+    const queryField = level ? "listPackGroupByTypeLevelAndOrder" : "listPackGroupByTypeAndOrder";
+    const variables = level ? { typeLevel: `${type}_${level}`, sortDirection: "ASC" } : { type, sortDirection: "ASC" };
+    const result = await this.network.query(
+      level ? `query ListPackGroups($typeLevel: String!, $sortDirection: ModelSortDirection) {
+            listPackGroupByTypeLevelAndOrder(typeLevel: $typeLevel, sortDirection: $sortDirection) {
+              items { id name description imageUrl type level typeLevel packCount order }
+            }
+          }` : `query ListPackGroups($type: String!, $sortDirection: ModelSortDirection) {
+            listPackGroupByTypeAndOrder(type: $type, sortDirection: $sortDirection) {
+              items { id name description imageUrl type level typeLevel packCount order }
+            }
+          }`,
+      variables
+    );
+    return result.data[queryField].items;
+  }
+  async getGroup(id) {
+    const result = await this.network.query(
+      `query GetPackGroup($id: ID!) {
+        getPackGroup(id: $id) {
+          id name description imageUrl type level typeLevel packCount order
+          packs { items { id name language level difficulty questionCount owner createdAt verificationStatus } }
+        }
+      }`,
+      { id }
+    );
+    return result.data.getPackGroup;
+  }
+};
+
+// src/services/contest.service.ts
+var ContestService = class {
+  constructor(network) {
+    this.network = network;
+  }
+  async create(input) {
+    const result = await this.network.mutate(
+      `mutation MakeContest($name: String!, $description: String!, $level: String!, $language: String!, $startTime: AWSDateTime!, $endTime: AWSDateTime!, $subject: String!, $isRated: Boolean!, $questions: String!, $maximumParticipants: Int!, $solutionVideoUrl: String, $imageUrl: String) {
+        makeContest(name: $name, description: $description, level: $level, language: $language, startTime: $startTime, endTime: $endTime, subject: $subject, isRated: $isRated, questions: $questions, maximumParticipants: $maximumParticipants, solutionVideoUrl: $solutionVideoUrl, imageUrl: $imageUrl) {
+          status id
+        }
+      }`,
+      input
+    );
+    return result.data.makeContest;
+  }
+  async get(id) {
+    const result = await this.network.query(
+      `query GetContest($id: ID!) {
+        getContest(id: $id) {
+          id name description startTime endTime level language owner isRated subject
+          totalQuestions resultsPublished totalParticipants maximumParticipants
+          rankings globalPk solutionVideoUrl imageUrl
+        }
+      }`,
+      { id }
+    );
+    return result.data.getContest;
+  }
+  async getName(id) {
+    const result = await this.network.query(
+      `query GetContestName($id: ID!) { getContest(id: $id) { name } }`,
+      { id }
+    );
+    return _nullishCoalesce(_optionalChain([result, 'access', _7 => _7.data, 'access', _8 => _8.getContest, 'optionalAccess', _9 => _9.name]), () => ( null));
+  }
+  async list(nextToken, level) {
+    const variables = level ? { level, sortDirection: "DESC", nextToken } : { globalPk: "ALL", sortDirection: "DESC", nextToken };
+    const result = await this.network.query(
+      level ? `query ListContests($level: String!, $sortDirection: ModelSortDirection, $nextToken: String) {
+            listContestByLevelAndStartTime(level: $level, sortDirection: $sortDirection, nextToken: $nextToken) {
+              items { id name description startTime endTime level language owner isRated subject totalQuestions resultsPublished totalParticipants maximumParticipants solutionVideoUrl imageUrl }
+              nextToken
+            }
+          }` : `query ListContests($globalPk: String!, $sortDirection: ModelSortDirection, $nextToken: String) {
+            listContestByGlobalPkAndStartTime(globalPk: $globalPk, sortDirection: $sortDirection, nextToken: $nextToken) {
+              items { id name description startTime endTime level language owner isRated subject totalQuestions resultsPublished totalParticipants maximumParticipants solutionVideoUrl imageUrl }
+              nextToken
+            }
+          }`,
+      variables
+    );
+    const key = level ? "listContestByLevelAndStartTime" : "listContestByGlobalPkAndStartTime";
+    return result.data[key];
+  }
+  async participate(contestId) {
+    const result = await this.network.mutate(
+      `mutation ParticipateContest($contestId: ID!) {
+        participateContest(contestId: $contestId) { status id }
+      }`,
+      { contestId }
+    );
+    return result.data.participateContest;
+  }
+  async checkParticipation(contestId) {
+    const result = await this.network.query(
+      `query CheckParticipation($contestId: ID!) {
+        checkUserParticipation(contestId: $contestId) {
+          status participated selectedOptions score rank beforeRating afterRating
+        }
+      }`,
+      { contestId }
+    );
+    return result.data.checkUserParticipation;
+  }
+  async selectOption(contestId, optionId, order) {
+    const result = await this.network.mutate(
+      `mutation SelectContestOption($contestId: ID!, $optionId: String!, $order: Int!) {
+        selectContestOption(contestId: $contestId, optionId: $optionId, order: $order) { status }
+      }`,
+      { contestId, optionId, order }
+    );
+    return result.data.selectContestOption;
+  }
+  async getQuestions(contestId) {
+    const result = await this.network.query(
+      `query GetContestQuestions($contestId: ID!) {
+        getContestQuestions(contestId: $contestId) { status questions }
+      }`,
+      { contestId }
+    );
+    return result.data.getContestQuestions;
+  }
+  async getAnswers(contestId) {
+    const result = await this.network.query(
+      `query GetContestAnswers($contestId: ID!) {
+        getContestAnswers(contestId: $contestId) { status answers }
+      }`,
+      { contestId }
+    );
+    return result.data.getContestAnswers;
+  }
+  async publish(contestId) {
+    const result = await this.network.mutate(
+      `mutation PublishResults($contestId: ID!) {
+        publishContestResults(contestId: $contestId) { status }
+      }`,
+      { contestId }
+    );
+    return result.data.publishContestResults;
+  }
+  async getLeaderboard(contestId, nextToken) {
+    const result = await this.network.query(
+      `query GetLeaderboard($contestId: ID!, $sortDirection: ModelSortDirection, $nextToken: String) {
+        listContestParticipantByContestIdAndRank(contestId: $contestId, sortDirection: $sortDirection, nextToken: $nextToken) {
+          items { id contestId userId rank score afterRating beforeRating createdAt user { id fullName avatarUrl } }
+          nextToken
+        }
+      }`,
+      { contestId, sortDirection: "ASC", nextToken }
+    );
+    const data = result.data.listContestParticipantByContestIdAndRank;
+    return {
+      status: "success",
+      leaderboard: JSON.stringify(data.items),
+      nextToken: data.nextToken
+    };
+  }
+  async getUserResults(userId, nextToken) {
+    const result = await this.network.query(
+      `query GetUserResults($userId: ID!, $sortDirection: ModelSortDirection, $nextToken: String) {
+        listContestParticipantByUserIdAndCreatedAt(userId: $userId, sortDirection: $sortDirection, nextToken: $nextToken) {
+          items { id contestId userId rank score afterRating beforeRating selectedOptions createdAt contest { id name subject level startTime } }
+          nextToken
+        }
+      }`,
+      { userId, sortDirection: "DESC", nextToken }
+    );
+    return result.data.listContestParticipantByUserIdAndCreatedAt;
+  }
+  async updateSolutionVideo(contestId, url) {
+    const result = await this.network.mutate(
+      `mutation UpdateSolutionVideo($input: UpdateContestInput!) {
+        updateContest(input: $input) { id solutionVideoUrl }
+      }`,
+      { input: { id: contestId, solutionVideoUrl: url } }
+    );
+    return { status: result.data.updateContest ? "success" : "error" };
+  }
+};
+
+// src/services/course.service.ts
+var CourseService = class {
+  constructor(network) {
+    this.network = network;
+  }
+  async create(input) {
+    const result = await this.network.mutate(
+      `mutation MakeCourse($name: String!, $description: String!, $price: Int!, $imageUrl: String) {
+        makeCourse(name: $name, description: $description, price: $price, imageUrl: $imageUrl) { status courseId }
+      }`,
+      input
+    );
+    return result.data.makeCourse;
+  }
+  async get(id) {
+    const result = await this.network.query(
+      `query GetCourse($id: ID!) {
+        getCourse(id: $id) { id name description imageUrl videoCount fileCount price totalEnrolled owner createdAt }
+      }`,
+      { id }
+    );
+    return result.data.getCourse;
+  }
+  async getItems(courseId) {
+    const result = await this.network.query(
+      `query ListCourseItems($courseId: ID!, $sortDirection: ModelSortDirection) {
+        listCourseItemsByCourseIdAndOrder(courseId: $courseId, sortDirection: $sortDirection) {
+          items { id type name courseId parentId order owner }
+        }
+      }`,
+      { courseId, sortDirection: "ASC" }
+    );
+    return result.data.listCourseItemsByCourseIdAndOrder.items;
+  }
+  async createItem(input) {
+    const result = await this.network.mutate(
+      `mutation CreateCourseItem($courseId: ID!, $name: String!, $order: Int!, $type: CourseItemsType, $parentId: ID, $id: ID) {
+        createCourseItem(courseId: $courseId, name: $name, order: $order, type: $type, parentId: $parentId, id: $id) { status id }
+      }`,
+      input
+    );
+    return result.data.createCourseItem;
+  }
+  async updateItem(id, name, order) {
+    const result = await this.network.mutate(
+      `mutation UpdateCourseItem($input: UpdateCourseItemsInput!) {
+        updateCourseItems(input: $input) { id type name courseId parentId order owner }
+      }`,
+      { input: { id, name, order } }
+    );
+    return result.data.updateCourseItems;
+  }
+  async deleteItem(input) {
+    const result = await this.network.mutate(
+      `mutation DeleteCourseItem($id: ID!, $fileType: String!, $courseId: ID!, $parentId: ID) {
+        deleteCourseItem(id: $id, fileType: $fileType, courseId: $courseId, parentId: $parentId) { status }
+      }`,
+      input
+    );
+    return result.data.deleteCourseItem;
+  }
+  async enroll(input) {
+    const result = await this.network.mutate(
+      `mutation EnrollStudent($courseId: ID!, $userId: ID!) {
+        enrollStudent(courseId: $courseId, userId: $userId) { status id }
+      }`,
+      input
+    );
+    return result.data.enrollStudent;
+  }
+  async getEnrolledStudent(courseId, userId) {
+    const result = await this.network.query(
+      `query GetEnrolledStudent($courseId: ID!, $filter: ModelCourseEnrolledFilterInput) {
+        listCourseEnrolledByCourseIdAndCreatedAt(courseId: $courseId, filter: $filter) {
+          items { id courseId userId owner score rank createdAt }
+        }
+      }`,
+      { courseId, filter: { userId: { eq: userId } } }
+    );
+    return _nullishCoalesce(result.data.listCourseEnrolledByCourseIdAndCreatedAt.items[0], () => ( null));
+  }
+  async getEnrolledStudents(courseId, nextToken) {
+    const result = await this.network.query(
+      `query ListEnrolledStudents($courseId: ID!, $sortDirection: ModelSortDirection, $nextToken: String) {
+        listCourseEnrolledByCourseIdAndCreatedAt(courseId: $courseId, sortDirection: $sortDirection, nextToken: $nextToken) {
+          items { id courseId userId owner score rank createdAt user { id fullName avatarUrl } }
+          nextToken
+        }
+      }`,
+      { courseId, sortDirection: "DESC", nextToken }
+    );
+    return result.data.listCourseEnrolledByCourseIdAndCreatedAt;
+  }
+  async sendEnrollmentRequest(input) {
+    const result = await this.network.mutate(
+      `mutation SendEnrollmentRequest($input: CreateCourseEnrollmentRequestInput!) {
+        createCourseEnrollmentRequest(input: $input) { id }
+      }`,
+      { input: { courseId: input.courseId, name: input.name, phone: input.phone, transactionID: input.transactionId, coupon: input.couponId } }
+    );
+    return result.data.createCourseEnrollmentRequest;
+  }
+  async getSignedURL(input) {
+    const result = await this.network.query(
+      `query GetR2SignedURL($courseId: ID!, $fileName: String!, $fileType: String!, $parentId: ID) {
+        getR2SignedURL(courseId: $courseId, fileName: $fileName, fileType: $fileType, parentId: $parentId) { status signedURL }
+      }`,
+      input
+    );
+    return result.data.getR2SignedURL;
+  }
+  async getSignedFileURL(input) {
+    const result = await this.network.query(
+      `query GetR2SignedFileURL($courseId: ID!, $itemId: ID!, $key: ID!) {
+        getR2SignedFileURL(courseId: $courseId, itemId: $itemId, key: $key) { status signedURL }
+      }`,
+      input
+    );
+    return result.data.getR2SignedFileURL;
+  }
+  async createVideo(input) {
+    const result = await this.network.query(
+      `query CreateCourseVideo($courseId: ID!, $fileName: String!, $fileType: String!) {
+        createCourseVideo(courseId: $courseId, fileName: $fileName, fileType: $fileType) { status videoId }
+      }`,
+      input
+    );
+    return result.data.createCourseVideo;
+  }
+  async uploadVideoToBunny(input) {
+    const result = await this.network.mutate(
+      `mutation UploadR2VideoToBunny($key: String!, $videoId: String!, $fileType: String!) {
+        uploadR2VideoToBunny(key: $key, videoId: $videoId, fileType: $fileType) { status }
+      }`,
+      input
+    );
+    return result.data.uploadR2VideoToBunny;
+  }
+  async getLiveExams(courseId, nextToken) {
+    const result = await this.network.query(
+      `query ListLiveExams($courseId: ID!, $sortDirection: ModelSortDirection, $nextToken: String) {
+        listCourseLiveExamByCourseIdAndStartTime(courseId: $courseId, sortDirection: $sortDirection, nextToken: $nextToken) {
+          items { id courseId name startTime endTime owner totalParticipants resultsPublished }
+          nextToken
+        }
+      }`,
+      { courseId, sortDirection: "DESC", nextToken }
+    );
+    return result.data.listCourseLiveExamByCourseIdAndStartTime;
+  }
+  async createLiveExam(input) {
+    const result = await this.network.mutate(
+      `mutation MakeCourseLiveExam($courseId: ID!, $name: String!, $questions: String!, $startTime: AWSDateTime!, $endTime: AWSDateTime!) {
+        makeCourseLiveExam(courseId: $courseId, name: $name, questions: $questions, startTime: $startTime, endTime: $endTime) { status id }
+      }`,
+      input
+    );
+    return result.data.makeCourseLiveExam;
+  }
+  async getLiveExamQuestions(examId) {
+    const result = await this.network.query(
+      `query GetLiveExamQuestions($examId: ID!) {
+        getCourseLiveExamQuestions(examId: $examId) { status name startTime endTime questions selectedOptions }
+      }`,
+      { examId }
+    );
+    return result.data.getCourseLiveExamQuestions;
+  }
+  async participateLiveExam(examId) {
+    const result = await this.network.mutate(
+      `mutation ParticipateLiveExam($examId: ID!) {
+        participateCourseLiveExam(examId: $examId) { status }
+      }`,
+      { examId }
+    );
+    return result.data.participateCourseLiveExam;
+  }
+  async selectLiveExamOption(examId, optionId, order) {
+    const result = await this.network.mutate(
+      `mutation SelectLiveExamOption($examId: ID!, $optionId: ID!, $order: Int!) {
+        selectCourseLiveExamOption(examId: $examId, optionId: $optionId, order: $order) { status }
+      }`,
+      { examId, optionId, order }
+    );
+    return result.data.selectCourseLiveExamOption;
+  }
+  async getLiveExamLeaderboard(examId, nextToken) {
+    const result = await this.network.query(
+      `query GetLiveExamLeaderboard($examId: ID!, $nextToken: String) {
+        getCourseLiveExamLeaderboard(examId: $examId, nextToken: $nextToken) { status leaderboard nextToken totalParticipants }
+      }`,
+      { examId, nextToken }
+    );
+    return result.data.getCourseLiveExamLeaderboard;
+  }
+  async publishLiveExamResults(examId) {
+    const result = await this.network.mutate(
+      `mutation PublishLiveExamResults($examId: ID!) {
+        publishCourseLiveExamResults(examId: $examId) { status }
+      }`,
+      { examId }
+    );
+    return result.data.publishCourseLiveExamResults;
+  }
+};
+
+// src/services/curriculum.service.ts
+var CurriculumService = class {
+  constructor(network) {
+    this.network = network;
+  }
+  async createSubject(name, level) {
+    const result = await this.network.mutate(
+      `mutation MakeSubject($name: String!, $level: String!) {
+        makeSubject(name: $name, level: $level) { status id }
+      }`,
+      { name, level }
+    );
+    return result.data.makeSubject;
+  }
+  async createChapter(name, subjectId, order) {
+    const result = await this.network.mutate(
+      `mutation MakeChapter($name: String!, $subjectId: ID!, $order: Int!) {
+        makeChapter(name: $name, subjectId: $subjectId, order: $order) { status id }
+      }`,
+      { name, subjectId, order }
+    );
+    return result.data.makeChapter;
+  }
+  async createTopic(name, chapterId) {
+    const result = await this.network.mutate(
+      `mutation MakeTopic($name: String!, $chapterId: ID!) {
+        makeTopic(name: $name, chapterId: $chapterId) { status id }
+      }`,
+      { name, chapterId }
+    );
+    return result.data.makeTopic;
+  }
+  async getSubjects(level) {
+    const result = await this.network.query(
+      `query ListSubjects($level: String!) {
+        listSubjectByLevel(level: $level) {
+          items { id name level questionCount }
+        }
+      }`,
+      { level }
+    );
+    return result.data.listSubjectByLevel.items;
+  }
+  async getChapters(subjectId) {
+    const result = await this.network.query(
+      `query ListChapters($subjectId: ID!, $sortDirection: ModelSortDirection) {
+        listChapterBySubjectIdAndOrder(subjectId: $subjectId, sortDirection: $sortDirection) {
+          items { id name order subjectId questionCount }
+        }
+      }`,
+      { subjectId, sortDirection: "ASC" }
+    );
+    return result.data.listChapterBySubjectIdAndOrder.items;
+  }
+  async getTopics(chapterId) {
+    const result = await this.network.query(
+      `query ListTopics($chapterId: ID!) {
+        listTopicByChapterId(chapterId: $chapterId) {
+          items { id name chapterId questionCount }
+        }
+      }`,
+      { chapterId }
+    );
+    return result.data.listTopicByChapterId.items;
+  }
+};
+
+// src/services/media.service.ts
+var MediaService = class {
+  constructor(network, storage) {
+    this.network = network;
+    this.storage = storage;
+  }
+  async uploadImage(questionId, image) {
+    const result = await this.network.mutate(
+      `mutation UploadImage($questionId: ID!, $image: String!) {
+        uploadImage(questionId: $questionId, image: $image) { status imageUrl }
+      }`,
+      { questionId, image }
+    );
+    return result.data.uploadImage;
+  }
+  async deleteImage(imageUrl) {
+    const result = await this.network.mutate(
+      `mutation DeleteImage($imageUrl: ID!) {
+        deleteImage(imageUrl: $imageUrl) { status }
+      }`,
+      { imageUrl }
+    );
+    return result.data.deleteImage;
+  }
+  async getSignedURL(input) {
+    const result = await this.network.query(
+      `query GetR2SignedURL($courseId: ID!, $fileName: String!, $fileType: String!, $parentId: ID) {
+        getR2SignedURL(courseId: $courseId, fileName: $fileName, fileType: $fileType, parentId: $parentId) { status signedURL }
+      }`,
+      input
+    );
+    return result.data.getR2SignedURL;
+  }
+  async getSignedFileURL(input) {
+    const result = await this.network.query(
+      `query GetR2SignedFileURL($courseId: ID!, $itemId: ID!, $key: ID!) {
+        getR2SignedFileURL(courseId: $courseId, itemId: $itemId, key: $key) { status signedURL }
+      }`,
+      input
+    );
+    return result.data.getR2SignedFileURL;
+  }
+  async getFileUrl(path) {
+    if (!this.storage) throw new Error("StorageProvider not configured");
+    return this.storage.getFileUrl(path);
+  }
+  async uploadFile(path, data, options) {
+    if (!this.storage) throw new Error("StorageProvider not configured");
+    return this.storage.uploadFile(path, data, options);
+  }
+  async createVideo(input) {
+    const result = await this.network.query(
+      `query CreateCourseVideo($courseId: ID!, $fileName: String!, $fileType: String!) {
+        createCourseVideo(courseId: $courseId, fileName: $fileName, fileType: $fileType) { status videoId }
+      }`,
+      input
+    );
+    return result.data.createCourseVideo;
+  }
+  async uploadVideoToBunny(input) {
+    const result = await this.network.mutate(
+      `mutation UploadR2VideoToBunny($key: String!, $videoId: String!, $fileType: String!) {
+        uploadR2VideoToBunny(key: $key, videoId: $videoId, fileType: $fileType) { status }
+      }`,
+      input
+    );
+    return result.data.uploadR2VideoToBunny;
+  }
+};
+
+// src/services/progress.service.ts
+var ProgressService = class {
+  constructor(network) {
+    this.network = network;
+  }
+  async track(input) {
+    const result = await this.network.mutate(
+      `mutation TrackProgress($questionId: ID!, $isCorrect: Boolean!, $subjectId: ID, $chapterId: ID, $topicId: ID) {
+        trackPracticeProgress(questionId: $questionId, isCorrect: $isCorrect, subjectId: $subjectId, chapterId: $chapterId, topicId: $topicId) { status }
+      }`,
+      input
+    );
+    return result.data.trackPracticeProgress;
+  }
+  async getSubjectProgress(userId) {
+    const result = await this.network.query(
+      `query ListSubjectProgress($userId: String!) {
+        listUserSubjectProgressByUserIdAndSubjectId(userId: $userId) {
+          items { id userId subjectId practicedCount mistakeCount correctedCount accuracyScore }
+        }
+      }`,
+      { userId }
+    );
+    return result.data.listUserSubjectProgressByUserIdAndSubjectId.items;
+  }
+  async getChapterProgress(userId) {
+    const result = await this.network.query(
+      `query ListChapterProgress($userId: String!) {
+        listUserChapterProgressByUserIdAndChapterId(userId: $userId) {
+          items { id userId chapterId practicedCount mistakeCount correctedCount accuracyScore }
+        }
+      }`,
+      { userId }
+    );
+    return result.data.listUserChapterProgressByUserIdAndChapterId.items;
+  }
+  async getTopicProgress(userId) {
+    const result = await this.network.query(
+      `query ListTopicProgress($userId: String!) {
+        listUserTopicProgressByUserIdAndTopicId(userId: $userId) {
+          items { id userId topicId practicedCount mistakeCount correctedCount accuracyScore }
+        }
+      }`,
+      { userId }
+    );
+    return result.data.listUserTopicProgressByUserIdAndTopicId.items;
+  }
+  async getTopicMetrics(userId) {
+    const result = await this.network.query(
+      `query ListTopicMetrics($filter: ModelUserTopicMetricFilterInput) {
+        listUserTopicMetrics(filter: $filter) {
+          items { id userId topicId totalAttempted totalCorrect accuracy }
+        }
+      }`,
+      { filter: { userId: { eq: userId } } }
+    );
+    return result.data.listUserTopicMetrics.items;
+  }
+  async getMistakenQuestions(userId) {
+    const result = await this.network.query(
+      `query ListMistakes($userId: String!, $filter: ModelQuestionTrackingFilterInput) {
+        listQuestionTrackingByUserIdAndSubjectId(userId: $userId, filter: $filter) {
+          items { id userId questionId subjectId chapterId topicId status attempts }
+        }
+      }`,
+      { userId, filter: { status: { eq: "MISTAKE" } } }
+    );
+    return result.data.listQuestionTrackingByUserIdAndSubjectId.items;
+  }
+};
+
+// src/services/ai.service.ts
+var AIService = class {
+  constructor(network) {
+    this.network = network;
+  }
+  async evaluateWrittenAnswer(input) {
+    const result = await this.network.query(
+      `query EvaluateWrittenAnswer($question: String!, $userAnswer: String!, $correctAnswer: String!, $markingInstructions: String, $topicId: String, $topicName: String, $questionImageUrl: String) {
+        evaluateWrittenAnswer(question: $question, userAnswer: $userAnswer, correctAnswer: $correctAnswer, markingInstructions: $markingInstructions, topicId: $topicId, topicName: $topicName, questionImageUrl: $questionImageUrl) {
+          score maxScore feedback isCorrect markingExplanation improvementFeedback subquestions markLocation
+        }
+      }`,
+      input
+    );
+    return result.data.evaluateWrittenAnswer;
+  }
+};
+
+// src/services/news.service.ts
+var NewsService = class {
+  constructor(network) {
+    this.network = network;
+  }
+  async create(title, content, image, category, excerpt) {
+    const result = await this.network.mutate(
+      `mutation CreateNews($input: CreateNewsArticleInput!) {
+        createNewsArticle(input: $input) { id title content image category excerpt createdAt updatedAt }
+      }`,
+      { input: { title, content, image, category, excerpt } }
+    );
+    return result.data.createNewsArticle;
+  }
+  async list(nextToken) {
+    const result = await this.network.query(
+      `query ListNews($nextToken: String) {
+        listNewsArticles(nextToken: $nextToken) {
+          items { id title content image category excerpt createdAt updatedAt }
+          nextToken
+        }
+      }`,
+      { nextToken }
+    );
+    return result.data.listNewsArticles;
+  }
+  async get(id) {
+    const result = await this.network.query(
+      `query GetNews($id: ID!) {
+        getNewsArticle(id: $id) { id title content image category excerpt createdAt updatedAt }
+      }`,
+      { id }
+    );
+    return result.data.getNewsArticle;
+  }
+};
+
+// src/client.ts
+var OrjokClient = class {
+  constructor(config) {
+    this.auth = config.authProvider;
+    this.users = new UserService(config.networkProvider);
+    this.questions = new QuestionService(config.networkProvider);
+    this.packs = new PackService(config.networkProvider);
+    this.contests = new ContestService(config.networkProvider);
+    this.courses = new CourseService(config.networkProvider);
+    this.curriculum = new CurriculumService(config.networkProvider);
+    this.media = new MediaService(config.networkProvider, config.storageProvider);
+    this.progress = new ProgressService(config.networkProvider);
+    this.ai = new AIService(config.networkProvider);
+    this.news = new NewsService(config.networkProvider);
+  }
+};
+function createOrjokClient(config) {
+  return new OrjokClient(config);
+}
+
+// src/logic/elo.ts
+var TIERS = [
+  { name: "Iron", minRating: 0, maxRating: 799, color: "#6B7280" },
+  { name: "Bronze", minRating: 800, maxRating: 999, color: "#CD7F32" },
+  { name: "Silver", minRating: 1e3, maxRating: 1199, color: "#C0C0C0" },
+  { name: "Gold", minRating: 1200, maxRating: 1399, color: "#FFD700" },
+  { name: "Platinum", minRating: 1400, maxRating: 1599, color: "#00CED1" },
+  { name: "Diamond", minRating: 1600, maxRating: 1799, color: "#B9F2FF" },
+  { name: "Master", minRating: 1800, maxRating: 1999, color: "#9B59B6" },
+  { name: "Grandmaster", minRating: 2e3, maxRating: 2399, color: "#E74C3C" },
+  { name: "Challenger", minRating: 2400, maxRating: Infinity, color: "#F1C40F" }
+];
+function getEloTier(rating) {
+  return _nullishCoalesce(TIERS.find((t) => rating >= t.minRating && rating <= t.maxRating), () => ( TIERS[0]));
+}
+function getEloProgress(rating) {
+  const tier = getEloTier(rating);
+  if (tier.maxRating === Infinity) return 100;
+  const range = tier.maxRating - tier.minRating;
+  return Math.round((rating - tier.minRating) / range * 100);
+}
+function getAllTiers() {
+  return [...TIERS];
+}
+function getRatingForSubject(user, subject) {
+  const key = subject;
+  return _nullishCoalesce(user[key], () => ( 1e3));
+}
+function computeRatingDelta(beforeRating, afterRating) {
+  if (beforeRating == null || afterRating == null) return 0;
+  return afterRating - beforeRating;
+}
+
+// src/logic/exam.ts
+function filterQuestionsByMode(questions, mode) {
+  if (mode === "BOTH") return questions;
+  return questions.filter((q) => q.type === mode || !q.type && mode === "MCQ");
+}
+function calculateExamTime(questionCount, secondsPerQuestion = 60) {
+  return questionCount * secondsPerQuestion;
+}
+function formatExamTime(totalSeconds) {
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor(totalSeconds % 3600 / 60);
+  const seconds = totalSeconds % 60;
+  if (hours > 0) {
+    return `${hours}:${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}`;
+  }
+  return `${minutes}:${String(seconds).padStart(2, "0")}`;
+}
+function scoreExam(selectedOptions, correctAnswers) {
+  let correct = 0;
+  let incorrect = 0;
+  let unanswered = 0;
+  for (let i = 0; i < correctAnswers.length; i++) {
+    const selected = selectedOptions[i];
+    if (!selected) {
+      unanswered++;
+    } else if (selected === correctAnswers[i]) {
+      correct++;
+    } else {
+      incorrect++;
+    }
+  }
+  return { correct, incorrect, unanswered, total: correctAnswers.length };
+}
+function isImageAnswer(answer) {
+  if (!answer) return false;
+  return answer.startsWith("image::") || answer.startsWith("images::");
+}
+function parseImageKeys(answer) {
+  if (answer.startsWith("images::")) {
+    return answer.slice("images::".length).split(",").filter(Boolean);
+  }
+  if (answer.startsWith("image::")) {
+    const key = answer.slice("image::".length);
+    return key ? [key] : [];
+  }
+  return [];
+}
+function buildImageAnswer(keys) {
+  if (keys.length === 0) return "";
+  if (keys.length === 1) return `image::${keys[0]}`;
+  return `images::${keys.join(",")}`;
+}
+function normalizeDifficulty(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return void 0;
+  const capitalized = trimmed.charAt(0).toUpperCase() + trimmed.slice(1).toLowerCase();
+  if (capitalized === "Easy" || capitalized === "Medium" || capitalized === "Hard") {
+    return capitalized;
+  }
+  return void 0;
+}
+function detectQuestionType(option2, option3, option4) {
+  if (!option2.trim() && !option3.trim() && !option4.trim()) {
+    return "WRITTEN";
+  }
+  return "MCQ";
+}
+
+// src/logic/import-export.ts
+var MAX_QUESTIONS = 200;
+function parseFields(parts) {
+  let extra = "";
+  let difficulty;
+  let subjectId = "";
+  let chapterId = "";
+  let topicId = "";
+  let markingInstructions = "";
+  let id = "";
+  let imageUrl = "";
+  let answerImageUrl = "";
+  let option2ImageUrl = "";
+  let option3ImageUrl = "";
+  let option4ImageUrl = "";
+  if (parts.length >= 13) {
+    extra = _nullishCoalesce(_optionalChain([parts, 'access', _10 => _10[7], 'optionalAccess', _11 => _11.trim, 'call', _12 => _12()]), () => ( ""));
+    const rawDiff = _nullishCoalesce(_optionalChain([parts, 'access', _13 => _13[8], 'optionalAccess', _14 => _14.trim, 'call', _15 => _15()]), () => ( ""));
+    if (rawDiff) {
+      const cap = rawDiff.charAt(0).toUpperCase() + rawDiff.slice(1).toLowerCase();
+      if (cap === "Easy" || cap === "Medium" || cap === "Hard") difficulty = cap;
+    }
+    subjectId = _nullishCoalesce(_optionalChain([parts, 'access', _16 => _16[9], 'optionalAccess', _17 => _17.trim, 'call', _18 => _18()]), () => ( ""));
+    chapterId = _nullishCoalesce(_optionalChain([parts, 'access', _19 => _19[10], 'optionalAccess', _20 => _20.trim, 'call', _21 => _21()]), () => ( ""));
+    topicId = _nullishCoalesce(_optionalChain([parts, 'access', _22 => _22[11], 'optionalAccess', _23 => _23.trim, 'call', _24 => _24()]), () => ( ""));
+    markingInstructions = _nullishCoalesce(_optionalChain([parts, 'access', _25 => _25[12], 'optionalAccess', _26 => _26.trim, 'call', _27 => _27()]), () => ( ""));
+    if (parts.length > 13) id = _nullishCoalesce(_optionalChain([parts, 'access', _28 => _28[13], 'optionalAccess', _29 => _29.trim, 'call', _30 => _30()]), () => ( ""));
+    if (parts.length > 14) imageUrl = _nullishCoalesce(_optionalChain([parts, 'access', _31 => _31[14], 'optionalAccess', _32 => _32.trim, 'call', _33 => _33()]), () => ( ""));
+    if (parts.length > 15) answerImageUrl = _nullishCoalesce(_optionalChain([parts, 'access', _34 => _34[15], 'optionalAccess', _35 => _35.trim, 'call', _36 => _36()]), () => ( ""));
+    if (parts.length > 16) option2ImageUrl = _nullishCoalesce(_optionalChain([parts, 'access', _37 => _37[16], 'optionalAccess', _38 => _38.trim, 'call', _39 => _39()]), () => ( ""));
+    if (parts.length > 17) option3ImageUrl = _nullishCoalesce(_optionalChain([parts, 'access', _40 => _40[17], 'optionalAccess', _41 => _41.trim, 'call', _42 => _42()]), () => ( ""));
+    if (parts.length > 18) option4ImageUrl = _nullishCoalesce(_optionalChain([parts, 'access', _43 => _43[18], 'optionalAccess', _44 => _44.trim, 'call', _45 => _45()]), () => ( ""));
+  } else if (parts.length === 8) {
+    extra = _nullishCoalesce(_optionalChain([parts, 'access', _46 => _46[7], 'optionalAccess', _47 => _47.trim, 'call', _48 => _48()]), () => ( ""));
+  } else if (parts.length === 9) {
+    extra = _nullishCoalesce(_optionalChain([parts, 'access', _49 => _49[7], 'optionalAccess', _50 => _50.trim, 'call', _51 => _51()]), () => ( ""));
+    const rawDiff = _nullishCoalesce(_optionalChain([parts, 'access', _52 => _52[8], 'optionalAccess', _53 => _53.trim, 'call', _54 => _54()]), () => ( ""));
+    if (rawDiff) {
+      const cap = rawDiff.charAt(0).toUpperCase() + rawDiff.slice(1).toLowerCase();
+      if (cap === "Easy" || cap === "Medium" || cap === "Hard") difficulty = cap;
+    }
+  } else if (parts.length === 10) {
+    subjectId = _nullishCoalesce(_optionalChain([parts, 'access', _55 => _55[7], 'optionalAccess', _56 => _56.trim, 'call', _57 => _57()]), () => ( ""));
+    chapterId = _nullishCoalesce(_optionalChain([parts, 'access', _58 => _58[8], 'optionalAccess', _59 => _59.trim, 'call', _60 => _60()]), () => ( ""));
+    topicId = _nullishCoalesce(_optionalChain([parts, 'access', _61 => _61[9], 'optionalAccess', _62 => _62.trim, 'call', _63 => _63()]), () => ( ""));
+  } else if (parts.length === 11) {
+    extra = _nullishCoalesce(_optionalChain([parts, 'access', _64 => _64[7], 'optionalAccess', _65 => _65.trim, 'call', _66 => _66()]), () => ( ""));
+    subjectId = _nullishCoalesce(_optionalChain([parts, 'access', _67 => _67[8], 'optionalAccess', _68 => _68.trim, 'call', _69 => _69()]), () => ( ""));
+    chapterId = _nullishCoalesce(_optionalChain([parts, 'access', _70 => _70[9], 'optionalAccess', _71 => _71.trim, 'call', _72 => _72()]), () => ( ""));
+    topicId = _nullishCoalesce(_optionalChain([parts, 'access', _73 => _73[10], 'optionalAccess', _74 => _74.trim, 'call', _75 => _75()]), () => ( ""));
+  } else if (parts.length === 12) {
+    extra = _nullishCoalesce(_optionalChain([parts, 'access', _76 => _76[7], 'optionalAccess', _77 => _77.trim, 'call', _78 => _78()]), () => ( ""));
+    const rawDiff = _nullishCoalesce(_optionalChain([parts, 'access', _79 => _79[8], 'optionalAccess', _80 => _80.trim, 'call', _81 => _81()]), () => ( ""));
+    if (rawDiff) {
+      const cap = rawDiff.charAt(0).toUpperCase() + rawDiff.slice(1).toLowerCase();
+      if (cap === "Easy" || cap === "Medium" || cap === "Hard") difficulty = cap;
+    }
+    subjectId = _nullishCoalesce(_optionalChain([parts, 'access', _82 => _82[9], 'optionalAccess', _83 => _83.trim, 'call', _84 => _84()]), () => ( ""));
+    chapterId = _nullishCoalesce(_optionalChain([parts, 'access', _85 => _85[10], 'optionalAccess', _86 => _86.trim, 'call', _87 => _87()]), () => ( ""));
+    topicId = _nullishCoalesce(_optionalChain([parts, 'access', _88 => _88[11], 'optionalAccess', _89 => _89.trim, 'call', _90 => _90()]), () => ( ""));
+  }
+  return {
+    id: id || void 0,
+    imageUrl: imageUrl || void 0,
+    extra: extra || void 0,
+    difficulty,
+    subjectId: subjectId || void 0,
+    chapterId: chapterId || void 0,
+    topicId: topicId || void 0,
+    markingInstructions: markingInstructions || void 0,
+    answerImageUrl: answerImageUrl || void 0,
+    option2ImageUrl: option2ImageUrl || void 0,
+    option3ImageUrl: option3ImageUrl || void 0,
+    option4ImageUrl: option4ImageUrl || void 0
+  };
+}
+function buildQuestion(parts) {
+  const tags = parts.length >= 7 && parts[6] ? parts[6].split(",").map((t) => t.trim()).filter(Boolean) : [];
+  const opt2 = _nullishCoalesce(_optionalChain([parts, 'access', _91 => _91[2], 'optionalAccess', _92 => _92.trim, 'call', _93 => _93()]), () => ( ""));
+  const opt3 = _nullishCoalesce(_optionalChain([parts, 'access', _94 => _94[3], 'optionalAccess', _95 => _95.trim, 'call', _96 => _96()]), () => ( ""));
+  const opt4 = _nullishCoalesce(_optionalChain([parts, 'access', _97 => _97[4], 'optionalAccess', _98 => _98.trim, 'call', _99 => _99()]), () => ( ""));
+  const isWritten = parts.length < 6 || !opt2 && !opt3 && !opt4;
+  const extra = parseFields(parts);
+  return {
+    question: _nullishCoalesce(_optionalChain([parts, 'access', _100 => _100[0], 'optionalAccess', _101 => _101.trim, 'call', _102 => _102()]), () => ( "")),
+    answer: _nullishCoalesce(_optionalChain([parts, 'access', _103 => _103[1], 'optionalAccess', _104 => _104.trim, 'call', _105 => _105()]), () => ( "")),
+    option2: opt2,
+    option3: opt3,
+    option4: opt4,
+    explanation: _nullishCoalesce(_optionalChain([parts, 'access', _106 => _106[5], 'optionalAccess', _107 => _107.trim, 'call', _108 => _108()]), () => ( "")),
+    tags,
+    type: isWritten ? "WRITTEN" : "MCQ",
+    ...extra
+  };
+}
+function parseTextQuestions(text, keyword, minParts = 2) {
+  const lines = text.split("\n");
+  const questions = [];
+  const errors = [];
+  if (lines.length > MAX_QUESTIONS) {
+    errors.push(`Can't have more than ${MAX_QUESTIONS} questions/lines`);
+    return { questions, errors };
+  }
+  for (let idx = 0; idx < lines.length; idx++) {
+    const line = lines[idx];
+    const parts = line.split(keyword);
+    if (parts.length === 1 && (parts[0] === "\r" || parts[0] === "\n" || parts[0] === "")) {
+      continue;
+    }
+    if (parts.length < minParts || parts.length > 19) {
+      errors.push(`Line ${idx + 1} doesn't have between ${minParts} and 19 parts`);
+      continue;
+    }
+    questions.push(buildQuestion(parts));
+  }
+  return { questions, errors };
+}
+function parseCsvQuestions(rows) {
+  const questions = [];
+  const errors = [];
+  const dataRows = rows.slice(1);
+  if (dataRows.length > MAX_QUESTIONS) {
+    errors.push(`Can't have more than ${MAX_QUESTIONS} questions/lines`);
+    return { questions, errors };
+  }
+  for (let idx = 0; idx < dataRows.length; idx++) {
+    const line = dataRows[idx];
+    if (line.length < 2 || line.length > 19) {
+      errors.push(`Line ${idx + 2} doesn't have between 2 and 19 parts`);
+      continue;
+    }
+    questions.push(buildQuestion(line));
+  }
+  return { questions, errors };
+}
+function formatQuestionsToText(questions, keyword, packSubjectId, packChapterId, packTopicId) {
+  const lines = questions.map((q) => {
+    const activeSubject = q.subjectId || packSubjectId;
+    const activeChapter = q.chapterId || packChapterId;
+    const activeTopic = q.topicId || packTopicId;
+    const subjectSlug = activeSubject ? _nullishCoalesce(_optionalChain([activeSubject, 'access', _109 => _109.split, 'call', _110 => _110("::"), 'access', _111 => _111[0], 'optionalAccess', _112 => _112.trim, 'call', _113 => _113()]), () => ( "")) : "";
+    const chapterSlug = activeChapter ? _nullishCoalesce(_optionalChain([activeChapter, 'access', _114 => _114.split, 'call', _115 => _115("::"), 'access', _116 => _116[0], 'optionalAccess', _117 => _117.trim, 'call', _118 => _118()]), () => ( "")) : "";
+    const topicSlug = activeTopic ? _nullishCoalesce(_optionalChain([activeTopic, 'access', _119 => _119.split, 'call', _120 => _120("::"), 'access', _121 => _121[0], 'optionalAccess', _122 => _122.trim, 'call', _123 => _123()]), () => ( "")) : "";
+    const fields = [
+      q.question,
+      q.answer,
+      q.type === "WRITTEN" ? "" : q.option2,
+      q.type === "WRITTEN" ? "" : q.option3,
+      q.type === "WRITTEN" ? "" : q.option4,
+      q.explanation,
+      q.tags.join(", "),
+      _nullishCoalesce(q.extra, () => ( "")),
+      _nullishCoalesce(q.difficulty, () => ( "")),
+      subjectSlug,
+      chapterSlug,
+      topicSlug,
+      _nullishCoalesce(q.markingInstructions, () => ( "")),
+      _nullishCoalesce(q.id, () => ( "")),
+      _nullishCoalesce(q.imageUrl, () => ( "")),
+      _nullishCoalesce(q.answerImageUrl, () => ( "")),
+      _nullishCoalesce(q.option2ImageUrl, () => ( "")),
+      _nullishCoalesce(q.option3ImageUrl, () => ( "")),
+      _nullishCoalesce(q.option4ImageUrl, () => ( ""))
+    ];
+    return fields.map((f) => (f || "").trim()).join(keyword);
+  });
+  return lines.join("\n");
+}
+function formatQuestionsToCsv(questions, packSubjectId, packChapterId, packTopicId) {
+  const escapeCSV = (value) => `"${(value || "").replace(/"/g, '""')}"`;
+  const header = "Question,Answer,Option2,Option3,Option4,Explanation,Tags,Extra,Difficulty,Subject,Chapter,Topic,MarkingInstructions,Id,ImageUrl,AnswerImageUrl,Option2ImageUrl,Option3ImageUrl,Option4ImageUrl";
+  const rows = questions.map((q) => {
+    const activeSubject = q.subjectId || packSubjectId;
+    const activeChapter = q.chapterId || packChapterId;
+    const activeTopic = q.topicId || packTopicId;
+    const subjectSlug = activeSubject ? _nullishCoalesce(_optionalChain([activeSubject, 'access', _124 => _124.split, 'call', _125 => _125("::"), 'access', _126 => _126[0], 'optionalAccess', _127 => _127.trim, 'call', _128 => _128()]), () => ( "")) : "";
+    const chapterSlug = activeChapter ? _nullishCoalesce(_optionalChain([activeChapter, 'access', _129 => _129.split, 'call', _130 => _130("::"), 'access', _131 => _131[0], 'optionalAccess', _132 => _132.trim, 'call', _133 => _133()]), () => ( "")) : "";
+    const topicSlug = activeTopic ? _nullishCoalesce(_optionalChain([activeTopic, 'access', _134 => _134.split, 'call', _135 => _135("::"), 'access', _136 => _136[0], 'optionalAccess', _137 => _137.trim, 'call', _138 => _138()]), () => ( "")) : "";
+    return [
+      escapeCSV(q.question),
+      escapeCSV(q.answer),
+      escapeCSV(q.type === "WRITTEN" ? "" : q.option2),
+      escapeCSV(q.type === "WRITTEN" ? "" : q.option3),
+      escapeCSV(q.type === "WRITTEN" ? "" : q.option4),
+      escapeCSV(q.explanation),
+      escapeCSV(q.tags.join(", ")),
+      escapeCSV(q.extra),
+      escapeCSV(q.difficulty),
+      escapeCSV(subjectSlug),
+      escapeCSV(chapterSlug),
+      escapeCSV(topicSlug),
+      escapeCSV(q.markingInstructions),
+      escapeCSV(q.id),
+      escapeCSV(q.imageUrl),
+      escapeCSV(q.answerImageUrl),
+      escapeCSV(q.option2ImageUrl),
+      escapeCSV(q.option3ImageUrl),
+      escapeCSV(q.option4ImageUrl)
+    ].join(",");
+  });
+  return `${header}
+${rows.join("\n")}`;
+}
+
+// src/logic/media-url.ts
+function isStorageKey(value) {
+  return !value.startsWith("http://") && !value.startsWith("https://");
+}
+var MediaUrlCache = class {
+  constructor(ttlMs = 50 * 60 * 1e3) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.ttlMs = ttlMs;
+  }
+  get(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return void 0;
+    if (Date.now() >= entry.expiresAt) {
+      this.cache.delete(key);
+      return void 0;
+    }
+    return entry.url;
+  }
+  set(key, url) {
+    this.cache.set(key, { url, expiresAt: Date.now() + this.ttlMs });
+  }
+  clear() {
+    this.cache.clear();
+  }
+};
+var warnedNoStorage = false;
+async function resolveMediaUrl(value, storage, cache) {
+  if (!value || value.length === 0) return null;
+  if (!isStorageKey(value)) return value;
+  if (cache) {
+    const cached = cache.get(value);
+    if (cached) return cached;
+  }
+  if (!storage) {
+    if (!warnedNoStorage) {
+      warnedNoStorage = true;
+      console.warn("@orjok/commons: resolveMediaUrl called without a StorageProvider \u2014 returning raw key");
+    }
+    return value;
+  }
+  const { url } = await storage.getFileUrl(value);
+  _optionalChain([cache, 'optionalAccess', _139 => _139.set, 'call', _140 => _140(value, url)]);
+  return url;
+}
+async function resolveMediaUrls(obj, fields, storage, cache) {
+  const copy = { ...obj };
+  await Promise.all(
+    fields.map(async (field) => {
+      const val = copy[field];
+      if (typeof val === "string") {
+        copy[field] = await resolveMediaUrl(val, storage, cache);
+      }
+    })
+  );
+  return copy;
+}
+function _resetMediaUrlWarning() {
+  warnedNoStorage = false;
+}
+
+// src/logic/practice.ts
+function aggregateSubjectMetrics(progress) {
+  let totalPracticed = 0;
+  let totalMistakes = 0;
+  let totalCorrected = 0;
+  for (const p of progress) {
+    totalPracticed += _nullishCoalesce(p.practicedCount, () => ( 0));
+    totalMistakes += _nullishCoalesce(p.mistakeCount, () => ( 0));
+    totalCorrected += _nullishCoalesce(p.correctedCount, () => ( 0));
+  }
+  const accuracy = totalPracticed > 0 ? Math.round((totalPracticed - totalMistakes) / totalPracticed * 100) : 0;
+  return { totalPracticed, totalMistakes, totalCorrected, accuracy };
+}
+function aggregateChapterMetrics(progress) {
+  let totalPracticed = 0;
+  let totalMistakes = 0;
+  let totalCorrected = 0;
+  for (const p of progress) {
+    totalPracticed += _nullishCoalesce(p.practicedCount, () => ( 0));
+    totalMistakes += _nullishCoalesce(p.mistakeCount, () => ( 0));
+    totalCorrected += _nullishCoalesce(p.correctedCount, () => ( 0));
+  }
+  const accuracy = totalPracticed > 0 ? Math.round((totalPracticed - totalMistakes) / totalPracticed * 100) : 0;
+  return { totalPracticed, totalMistakes, totalCorrected, accuracy };
+}
+function aggregateTopicMetrics(progress) {
+  let totalPracticed = 0;
+  let totalMistakes = 0;
+  let totalCorrected = 0;
+  for (const p of progress) {
+    totalPracticed += _nullishCoalesce(p.practicedCount, () => ( 0));
+    totalMistakes += _nullishCoalesce(p.mistakeCount, () => ( 0));
+    totalCorrected += _nullishCoalesce(p.correctedCount, () => ( 0));
+  }
+  const accuracy = totalPracticed > 0 ? Math.round((totalPracticed - totalMistakes) / totalPracticed * 100) : 0;
+  return { totalPracticed, totalMistakes, totalCorrected, accuracy };
+}
+function calculateAccuracy(practiced, mistakes) {
+  if (practiced <= 0) return 0;
+  return Math.round((practiced - mistakes) / practiced * 100);
+}
+
+// src/utils/shuffle.ts
+function shuffle(array) {
+  const result = [...array];
+  let currentIndex = result.length;
+  while (currentIndex !== 0) {
+    const randomIndex = Math.floor(Math.random() * currentIndex);
+    currentIndex--;
+    [result[currentIndex], result[randomIndex]] = [result[randomIndex], result[currentIndex]];
+  }
+  return result;
+}
+function shuffleInPlace(array) {
+  let currentIndex = array.length;
+  while (currentIndex !== 0) {
+    const randomIndex = Math.floor(Math.random() * currentIndex);
+    currentIndex--;
+    [array[currentIndex], array[randomIndex]] = [array[randomIndex], array[currentIndex]];
+  }
+}
+
+// src/utils/bangla-numbers.ts
+var BANGLA_DIGITS = ["\u09E6", "\u09E7", "\u09E8", "\u09E9", "\u09EA", "\u09EB", "\u09EC", "\u09ED", "\u09EE", "\u09EF"];
+function engToBanglaNumber(num) {
+  return String(num).split("").map((digit) => {
+    const n = parseInt(digit, 10);
+    return !isNaN(n) ? BANGLA_DIGITS[n] : digit;
+  }).join("");
+}
+
+// src/utils/format-curriculum.ts
+function formatCurriculumName(idString, dbName) {
+  if (dbName) return dbName;
+  if (!idString) return "";
+  const namePart = _nullishCoalesce(idString.split("::")[0], () => ( ""));
+  const clean = namePart.replace(/[-_]/g, " ");
+  return clean.split(/\s+/).map((word) => {
+    if (!word) return "";
+    return word.charAt(0).toUpperCase() + word.slice(1);
+  }).join(" ");
+}
+
+// src/utils/relative-time.ts
+function getRelativeTime(startTime, endTime) {
+  const now = /* @__PURE__ */ new Date();
+  const start = new Date(startTime);
+  const end = endTime ? new Date(endTime) : null;
+  if (end && now >= start && now <= end) {
+    return "";
+  }
+  const diffInSeconds = Math.floor((start.getTime() - now.getTime()) / 1e3);
+  const absDiff = Math.abs(diffInSeconds);
+  const minute = 60;
+  const hour = minute * 60;
+  const day = hour * 24;
+  const week = day * 7;
+  const month = day * 30;
+  const year = day * 365;
+  if (diffInSeconds < 0) {
+    if (absDiff < minute) return "just now";
+    if (absDiff < hour) return `${Math.floor(absDiff / minute)} minutes ago`;
+    if (absDiff < day) return `${Math.floor(absDiff / hour)} hours ago`;
+    if (absDiff < week) return `${Math.floor(absDiff / day)} days ago`;
+    if (absDiff < month) return `${Math.floor(absDiff / week)} weeks ago`;
+    if (absDiff < year) return `${Math.floor(absDiff / month)} months ago`;
+    return `${Math.floor(absDiff / year)} years ago`;
+  } else {
+    if (absDiff < minute) return "in a moment";
+    if (absDiff < hour) return `in ${Math.floor(absDiff / minute)} minutes`;
+    if (absDiff < day) return `in ${Math.floor(absDiff / hour)} hours`;
+    if (absDiff < week) return `in ${Math.floor(absDiff / day)} days`;
+    if (absDiff < month) return `in ${Math.floor(absDiff / week)} weeks`;
+    if (absDiff < year) return `in ${Math.floor(absDiff / month)} months`;
+    return `in ${Math.floor(absDiff / year)} years`;
+  }
+}
+
+// src/utils/latex.ts
+function processLatexText(str) {
+  if (!str) return str;
+  const regex = /(\$\$(.*?)\$\$)|(\$(.*?)\$)/gs;
+  let lastIndex = 0;
+  let result = "";
+  let match;
+  while ((match = regex.exec(str)) !== null) {
+    const textBefore = str.substring(lastIndex, match.index);
+    result += textBefore.replace(/\\n/g, "\n");
+    const isDisplay = match[1] !== void 0;
+    const mathContent = isDisplay ? match[2] : match[4];
+    const delimiter = isDisplay ? "$$" : "$";
+    const processedMath = mathContent.replace(
+      /(\\text\s*\{[^{}]*\})|([\u0980-\u09FF]+(?:\s+[\u0980-\u09FF]+)*)/g,
+      (_, p1, p2) => {
+        if (p1) return p1;
+        return `\\text{${p2}}`;
+      }
+    );
+    result += delimiter + processedMath + delimiter;
+    lastIndex = regex.lastIndex;
+  }
+  const remainingText = str.substring(lastIndex);
+  result += remainingText.replace(/\\n/g, "\n");
+  return result;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.AIService = AIService; exports.ContestService = ContestService; exports.CourseService = CourseService; exports.CurriculumService = CurriculumService; exports.MediaService = MediaService; exports.MediaUrlCache = MediaUrlCache; exports.NewsService = NewsService; exports.OrjokClient = OrjokClient; exports.PackService = PackService; exports.ProgressService = ProgressService; exports.QuestionService = QuestionService; exports.UserService = UserService; exports._resetMediaUrlWarning = _resetMediaUrlWarning; exports.aggregateChapterMetrics = aggregateChapterMetrics; exports.aggregateSubjectMetrics = aggregateSubjectMetrics; exports.aggregateTopicMetrics = aggregateTopicMetrics; exports.buildImageAnswer = buildImageAnswer; exports.calculateAccuracy = calculateAccuracy; exports.calculateExamTime = calculateExamTime; exports.computeRatingDelta = computeRatingDelta; exports.createOrjokClient = createOrjokClient; exports.detectQuestionType = detectQuestionType; exports.engToBanglaNumber = engToBanglaNumber; exports.filterQuestionsByMode = filterQuestionsByMode; exports.formatCurriculumName = formatCurriculumName; exports.formatExamTime = formatExamTime; exports.formatQuestionsToCsv = formatQuestionsToCsv; exports.formatQuestionsToText = formatQuestionsToText; exports.getAllTiers = getAllTiers; exports.getEloProgress = getEloProgress; exports.getEloTier = getEloTier; exports.getRatingForSubject = getRatingForSubject; exports.getRelativeTime = getRelativeTime; exports.isImageAnswer = isImageAnswer; exports.isStorageKey = isStorageKey; exports.normalizeDifficulty = normalizeDifficulty; exports.parseCsvQuestions = parseCsvQuestions; exports.parseImageKeys = parseImageKeys; exports.parseTextQuestions = parseTextQuestions; exports.processLatexText = processLatexText; exports.resolveMediaUrl = resolveMediaUrl; exports.resolveMediaUrls = resolveMediaUrls; exports.scoreExam = scoreExam; exports.shuffle = shuffle; exports.shuffleInPlace = shuffleInPlace;
+//# sourceMappingURL=index.cjs.map