@juki-team/commons 0.1.31

package/dist/dto/worksheet-submissions.d.ts

@@ -0,0 +1,64 @@
+import { type CodeEditorSheet, type CodeLanguage, type JkmdSheet, type QuizOptionsSheet, type QuizProblemSheet, type QuizTextSheet, type UserBasic, WorksheetType } from '../types/index.js';
+import type { SubmissionSummaryListResponseDTO } from './submission.js';
+import type { UserOrganizationBasicInfoResponseDTO } from './user.js';
+export type WorksheetResponseBasicInfoProcessed = {
+    submittedAt: number;
+    points: number;
+    isCompleted: boolean;
+};
+export interface QuizProblemSubmissionDTO extends Pick<QuizProblemSheet, 'id' | 'type'> {
+    language: CodeLanguage;
+    source: string;
+}
+export interface QuizProblemSubmissionResponseDTO extends WorksheetResponseBasicInfoProcessed, Omit<QuizProblemSubmissionDTO, 'source' | 'language'> {
+    submissionResult: SubmissionSummaryListResponseDTO;
+}
+export interface JkmdSubmissionDTO extends Pick<JkmdSheet, 'id' | 'type'> {
+    read: boolean;
+}
+export interface JkmdSubmissionResponseDTO extends WorksheetResponseBasicInfoProcessed, JkmdSubmissionDTO {
+}
+export interface CodeEditorSubmissionDTO extends Pick<CodeEditorSheet, 'id' | 'type' | 'files' | 'testCases'> {
+}
+export interface CodeEditorSubmissionResponseDTO extends WorksheetResponseBasicInfoProcessed, CodeEditorSubmissionDTO {
+}
+export interface QuizOptionsSubmissionDTO extends Pick<QuizOptionsSheet, 'id' | 'type'> {
+    checkedOptions: string[];
+}
+export interface QuizOptionsSubmissionResponseDTO extends WorksheetResponseBasicInfoProcessed, QuizOptionsSubmissionDTO {
+}
+export interface QuizTextSubmissionDTO extends Pick<QuizTextSheet, 'id' | 'type'> {
+    response: string;
+}
+export interface QuizTextSubmissionResponseDTO extends WorksheetResponseBasicInfoProcessed, QuizTextSubmissionDTO {
+}
+export type WorkSheetSubmissions = {
+    [WorksheetType.JK_MD]: {
+        [key: string]: JkmdSubmissionResponseDTO[];
+    };
+    [WorksheetType.CODE_EDITOR]: {
+        [key: string]: CodeEditorSubmissionResponseDTO[];
+    };
+    [WorksheetType.QUIZ_PROBLEM]: {
+        [key: string]: QuizProblemSubmissionResponseDTO[];
+    };
+    [WorksheetType.QUIZ_OPTIONS]: {
+        [key: string]: QuizOptionsSubmissionResponseDTO[];
+    };
+    [WorksheetType.QUIZ_TEXT]: {
+        [key: string]: QuizTextSubmissionResponseDTO[];
+    };
+};
+export interface WorksheetSubmissionsResponseDTO {
+    [key: string]: {
+        submissions: WorkSheetSubmissions;
+        user: UserBasic;
+    };
+}
+export interface WorksheetSubmissionsUsersResponseDTO {
+    [key: string]: UserOrganizationBasicInfoResponseDTO;
+}
+export interface WorksheetUserSubmissionsResponseDTO {
+    submissions: WorkSheetSubmissions;
+    user: UserBasic;
+}

package/dist/dto/worksheet-submissions.js

@@ -0,0 +1 @@
+import { WorksheetType, } from '../types/index.js';

package/dist/dto/worksheet.d.ts

@@ -0,0 +1,39 @@
+import type { BodyWorksheet, SummaryWorksheetsInPages, WorksheetBaseDocument } from '../types/index.js';
+import type { EntityMembersDTO, EntityMembersResponseDTO } from './entity.js';
+import type { UserOrganizationBasicInfoResponseDTO } from './user.js';
+export interface WorksheetUserResponseDTO {
+    isOwner: boolean;
+    isManager: boolean;
+    isSpectator: boolean;
+}
+export interface WorksheetSummaryListResponseDTO extends Pick<WorksheetBaseDocument, 'key' | 'name' | 'description'> {
+    updatedAt: Date;
+    content: SummaryWorksheetsInPages;
+    user: WorksheetUserResponseDTO;
+    owner: UserOrganizationBasicInfoResponseDTO;
+}
+export interface WorksheetDataResponseDTO extends Omit<WorksheetSummaryListResponseDTO, 'content'> {
+    folderId: string;
+    content: BodyWorksheet[];
+    members: EntityMembersResponseDTO;
+    quiz: WorksheetBaseDocument['quiz'];
+    slides: WorksheetBaseDocument['slides'];
+}
+export interface UpsertWorksheetDTO extends Omit<WorksheetBaseDocument, 'members' | 'key' | 'state'> {
+    members: EntityMembersDTO;
+}
+export interface WorksheetsProgressByUsersResponseDTO {
+    [key: string]: {
+        [key: string]: {
+            pages: {
+                totalPoints: number;
+                points: number;
+                percent: number;
+                worksheetPercent: number;
+            }[];
+            percent: number;
+            points: number;
+            totalPoints: number;
+        };
+    };
+}

package/dist/dto/worksheet.js

@@ -0,0 +1 @@
+export {};

package/dist/helpers/class.d.ts

@@ -0,0 +1,4 @@
+import type { AssignmentSessionCycleClassDataResponseDTO, ContestAssignmentSessionCycleClassDataResponseDTO, CourseAssignmentSessionCycleClassDataResponseDTO, WorksheetAssignmentSessionCycleClassDataResponseDTO } from '../dto/index.js';
+export declare const isWorksheetAssignment: (assignment: AssignmentSessionCycleClassDataResponseDTO) => assignment is WorksheetAssignmentSessionCycleClassDataResponseDTO;
+export declare const isCourseAssignment: (assignment: AssignmentSessionCycleClassDataResponseDTO) => assignment is CourseAssignmentSessionCycleClassDataResponseDTO;
+export declare const isContestAssignment: (assignment: AssignmentSessionCycleClassDataResponseDTO) => assignment is ContestAssignmentSessionCycleClassDataResponseDTO;

package/dist/helpers/class.js

@@ -0,0 +1,10 @@
+import { AssignmentClass } from '../types/index.js';
+export const isWorksheetAssignment = (assignment) => {
+    return assignment.type === AssignmentClass.WORKSHEET;
+};
+export const isCourseAssignment = (assignment) => {
+    return assignment.type === AssignmentClass.COURSE;
+};
+export const isContestAssignment = (assignment) => {
+    return assignment.type === AssignmentClass.CONTEST;
+};

package/dist/helpers/comments.d.ts

@@ -0,0 +1,4 @@
+export declare const getAssignmentCommentKey: (classKey: string, cycleKey: string, sessionKey: string, assignmentKey: string) => string;
+export declare const getAssignmentUserCommentKey: (classKey: string, cycleKey: string, sessionKey: string, assignmentKey: string, userNickname: string, userCompany: string) => string;
+export declare const getProblemCommentKey: (problemKey: string) => string;
+export declare const getContestCommentKey: (contestKey: string) => string;

package/dist/helpers/comments.js

@@ -0,0 +1,4 @@
+export const getAssignmentCommentKey = (classKey, cycleKey, sessionKey, assignmentKey) => `class:${classKey}|cycle:${cycleKey}|session:${sessionKey}|assignment:${assignmentKey}`;
+export const getAssignmentUserCommentKey = (classKey, cycleKey, sessionKey, assignmentKey, userNickname, userCompany) => `class:${classKey}|cycle:${cycleKey}|session:${sessionKey}|assignment:${assignmentKey}|user_nickname:${userNickname}|user_company:${userCompany}`;
+export const getProblemCommentKey = (problemKey) => `problem:${problemKey}`;
+export const getContestCommentKey = (contestKey) => `contest:${contestKey}`;

package/dist/helpers/commons.d.ts

@@ -0,0 +1,33 @@
+import type { Judge } from '../types/index.js';
+export declare function isStringJson(str: unknown): str is string;
+export declare function safeJsonParse(str: unknown): unknown;
+export declare function isObjectJson(obj: unknown): boolean;
+export declare function mex(array: number[]): number;
+export declare function range(start: number, end: number): number[];
+export declare function getPlainText(url: string): Promise<string>;
+export declare function objectUpdate(base: unknown, update: unknown): unknown;
+export declare function objectsUpdate(base: Record<string, unknown>, ...objects: Record<string, unknown>[]): Record<string, unknown>;
+export declare function consoleWarn(...warn: unknown[]): void;
+export declare function consoleInfo(...info: unknown[]): void;
+export declare function consoleError(...error: unknown[]): void;
+export declare function indexToLetters(index: number): string;
+export declare function lettersToIndex(index: string): number;
+export declare function getProblemJudgeKey(judge: Judge, key: string): string;
+/**
+ * https://stackoverflow.com/questions/10420352/converting-file-size-in-bytes-to-human-readable-string
+ * Format bytes as human-readable text.
+ *
+ * @param bytes Number of bytes.
+ * @param si True to use metric (SI) units, aka powers of 1000. False to use
+ *           binary (IEC), aka powers of 1024.
+ * @param dp Number of decimal places to display.
+ *
+ * @return Formatted string.
+ */
+export declare function humanFileSize(bytes: number, si?: boolean, dp?: number): string;
+export declare function stringToArrayBuffer(str: string): ArrayBuffer;
+export declare function chunkString(str: string, size: number): string[];
+export declare function getRandomString(length: number): string;
+export declare function join(array: (string | null | Date)[]): string;
+export declare function split(text: string): string[];
+export declare const areArraysDifferent: <T>(a: T[], b: T[]) => boolean;

package/dist/helpers/commons.js

@@ -0,0 +1,191 @@
+import { SEPARATOR_TOKEN, UPPERCASE_LETTERS } from '../constants/commons.js';
+export function isStringJson(str) {
+    try {
+        if (typeof str === 'string') {
+            JSON.parse(str);
+            return true;
+        }
+    }
+    catch {
+        return false;
+    }
+    return false;
+}
+export function safeJsonParse(str) {
+    try {
+        if (typeof str === 'string') {
+            return JSON.parse(str);
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+export function isObjectJson(obj) {
+    try {
+        return typeof JSON.stringify(obj) === 'string';
+    }
+    catch {
+        return false;
+    }
+}
+export function mex(array) {
+    let i = 0;
+    while (array.indexOf(i) !== -1) {
+        i++;
+    }
+    return i;
+}
+export function range(start, end) {
+    const result = [];
+    for (let i = start; i < end; i++) {
+        result.push(i);
+    }
+    return result;
+}
+export async function getPlainText(url) {
+    return await fetch(url)
+        .then((data) => data.text())
+        .catch((error) => {
+        console.error('ERROR:', error);
+        return '';
+    });
+}
+function mergeRecords(b, u) {
+    const mergeKeys = new Set([...Object.keys(b), ...Object.keys(u)]);
+    for (const key of mergeKeys) {
+        if (u[key] !== null && u[key] !== undefined && b[key] !== u[key]) {
+            b[key] = objectUpdate(b[key], u[key]);
+        }
+    }
+    return b;
+}
+export function objectUpdate(base, update) {
+    if (JSON.stringify(base) === JSON.stringify(update)) {
+        return base;
+    }
+    if (base !== null && update !== null && !Array.isArray(base) && typeof base === 'object' && typeof update === 'object') {
+        return mergeRecords(base, update);
+    }
+    if (update !== null && update !== undefined) {
+        return update;
+    }
+    return base;
+}
+export function objectsUpdate(base, ...objects) {
+    let newObject = { ...base };
+    for (const update of objects) {
+        newObject = objectUpdate(newObject, update);
+    }
+    return newObject;
+}
+export function consoleWarn(...warn) {
+    console.warn(new Date().toLocaleString(), ...warn);
+}
+export function consoleInfo(...info) {
+    console.info(new Date().toLocaleString(), ...info);
+}
+export function consoleError(...error) {
+    console.error(new Date().toLocaleString(), ...error);
+}
+export function indexToLetters(index) {
+    const d = Math.ceil(index / 26);
+    if (d === 1) {
+        return UPPERCASE_LETTERS.charAt(index - 1);
+    }
+    return UPPERCASE_LETTERS.charAt(d - 2) + UPPERCASE_LETTERS.charAt(index - 26 * (d - 1) - 1);
+}
+export function lettersToIndex(index) {
+    if (index.length) {
+        if (index.length === 1) {
+            const d = UPPERCASE_LETTERS.indexOf(index);
+            if (d !== -1) {
+                return d + 1;
+            }
+        }
+        else if (index.length === 2) {
+            const a = index.charAt(0);
+            const b = index.charAt(1);
+            const numA = lettersToIndex(a);
+            const numB = lettersToIndex(b);
+            return numA * 26 + numB;
+        }
+    }
+    return 0;
+}
+export function getProblemJudgeKey(judge, key) {
+    return `${judge}-${key}`;
+}
+/**
+ * https://stackoverflow.com/questions/10420352/converting-file-size-in-bytes-to-human-readable-string
+ * Format bytes as human-readable text.
+ *
+ * @param bytes Number of bytes.
+ * @param si True to use metric (SI) units, aka powers of 1000. False to use
+ *           binary (IEC), aka powers of 1024.
+ * @param dp Number of decimal places to display.
+ *
+ * @return Formatted string.
+ */
+export function humanFileSize(bytes, si = false, dp = 1) {
+    const thresh = si ? 1000 : 1024;
+    if (Math.abs(bytes) < thresh) {
+        return `${bytes} B`;
+    }
+    const units = si
+        ? ['kB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB']
+        : ['KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB'];
+    let u = -1;
+    let value = bytes;
+    const r = 10 ** dp;
+    do {
+        value /= thresh;
+        ++u;
+    } while (Math.round(Math.abs(value) * r) / r >= thresh && u < units.length - 1);
+    return `${value.toFixed(dp)} ${units[u]}`;
+}
+export function stringToArrayBuffer(str) {
+    const buf = new ArrayBuffer(str.length); //convert str to arrayBuffer
+    const view = new Uint8Array(buf); //create Uint8Array as viewer
+    for (let i = 0; i < str.length; i++) {
+        view[i] = str.charCodeAt(i) & 0xff; //convert to octet
+    }
+    return buf;
+}
+export function chunkString(str, size) {
+    const numChunks = Math.ceil(str.length / size);
+    const chunks = new Array(numChunks);
+    for (let i = 0, o = 0; i < numChunks; ++i, o += size) {
+        chunks[i] = str.substr(o, size);
+    }
+    return chunks;
+}
+export function getRandomString(length) {
+    const charset = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'; // 62
+    let retVal = '';
+    for (let i = 0; i < length; ++i) {
+        retVal += charset.charAt(Math.floor(Math.random() * charset.length));
+    }
+    return retVal;
+}
+export function join(array) {
+    return array.join(SEPARATOR_TOKEN);
+}
+export function split(text) {
+    return text.split(SEPARATOR_TOKEN);
+}
+export const areArraysDifferent = (a, b) => {
+    if (a === b) {
+        return false;
+    }
+    if (a.length !== b.length) {
+        return true;
+    }
+    for (let i = 0; i < b.length; i += 1) {
+        if (b[i] !== a[i]) {
+            return true;
+        }
+    }
+    return false;
+};

package/dist/helpers/contest.d.ts

@@ -0,0 +1,5 @@
+import type { ContestSettings } from '../types/index.js';
+export declare const isEndlessContest: (settings: Pick<ContestSettings, "startTimestamp" | "frozenTimestamp" | "quietTimestamp" | "endTimestamp" | "penalty"> | undefined) => boolean;
+export declare const isGlobalContest: (settings: Pick<ContestSettings, "startTimestamp" | "frozenTimestamp" | "quietTimestamp" | "endTimestamp" | "penalty"> | undefined) => boolean;
+export declare const isPastContest: (settings: Pick<ContestSettings, "endTimestamp"> | undefined) => boolean;
+export declare const isFutureContest: (settings: Pick<ContestSettings, "startTimestamp"> | undefined) => boolean;

package/dist/helpers/contest.js

@@ -0,0 +1,21 @@
+import { MAX_DATE, MIN_DATE } from '../constants/index.js';
+export const isEndlessContest = (settings) => {
+    return (settings?.startTimestamp === MIN_DATE.getTime() &&
+        settings?.frozenTimestamp === MAX_DATE.getTime() &&
+        settings?.quietTimestamp === MAX_DATE.getTime() &&
+        settings?.endTimestamp === MAX_DATE.getTime() &&
+        settings?.penalty === 0);
+};
+export const isGlobalContest = (settings) => {
+    return (settings?.startTimestamp === 0 &&
+        settings?.frozenTimestamp === 0 &&
+        settings?.quietTimestamp === 0 &&
+        settings?.endTimestamp === 0 &&
+        settings?.penalty === 0);
+};
+export const isPastContest = (settings) => {
+    return Date.now() > (settings?.endTimestamp ?? 0);
+};
+export const isFutureContest = (settings) => {
+    return (settings?.startTimestamp ?? 0) > Date.now();
+};

package/dist/helpers/document.d.ts

@@ -0,0 +1,14 @@
+import type { EntityMembersDTO, EntityMembersResponseDTO } from '../dto/index.js';
+import { EntityAccess, type EntityMembers, type EntityTeamsMemberUserData, type EntityUsersMemberUserData } from '../types/index.js';
+export declare const getDocumentAccess: (document: {
+    members: Pick<EntityMembers, "rankAdministrators" | "rankManagers" | "rankGuests" | "rankSpectators" | "rankParticipants">;
+} | undefined) => EntityAccess;
+export declare const isUserMember: (member: {
+    userId?: string;
+    teamId?: string;
+}) => member is EntityUsersMemberUserData;
+export declare const isTeamMember: (member: {
+    userId?: string;
+    teamId?: string;
+}) => member is EntityTeamsMemberUserData;
+export declare const toEntityMembersDTO: (members: EntityMembersResponseDTO) => EntityMembersDTO;

package/dist/helpers/document.js

@@ -0,0 +1,38 @@
+import { EntityAccess, EntityMembersRank, } from '../types/index.js';
+export const getDocumentAccess = (document) => {
+    const members = document?.members;
+    const adminRank = members?.rankAdministrators;
+    const adminClosed = adminRank === EntityMembersRank.NONE || adminRank === EntityMembersRank.CLOSE;
+    if (!adminClosed)
+        return EntityAccess.PRIVATE;
+    const spectatorsOpen = members?.rankSpectators === EntityMembersRank.OPEN;
+    const managersOpen = members?.rankManagers === EntityMembersRank.OPEN;
+    const managersClose = members?.rankManagers === EntityMembersRank.CLOSE;
+    if (spectatorsOpen && managersOpen)
+        return EntityAccess.EXPOSED;
+    if (spectatorsOpen && managersClose)
+        return EntityAccess.PUBLIC;
+    if (managersClose)
+        return EntityAccess.RESTRICTED;
+    return EntityAccess.PRIVATE;
+};
+export const isUserMember = (member) => {
+    return typeof member.userId === 'string';
+};
+export const isTeamMember = (member) => {
+    return typeof member.teamId === 'string';
+};
+export const toEntityMembersDTO = (members) => {
+    return {
+        rankAdministrators: members.rankAdministrators,
+        administrators: Object.keys(members.administrators),
+        rankManagers: members.rankManagers,
+        managers: Object.keys(members.managers),
+        rankParticipants: members.rankParticipants,
+        participants: Object.keys(members.participants),
+        rankGuests: members.rankGuests,
+        guests: Object.keys(members.guests),
+        rankSpectators: members.rankSpectators,
+        spectators: Object.keys(members.spectators),
+    };
+};

package/dist/helpers/file.d.ts

@@ -0,0 +1 @@
+export declare function removeExtension(fileName: string): string;

package/dist/helpers/file.js

@@ -0,0 +1,4 @@
+export function removeExtension(fileName) {
+    const i = fileName.lastIndexOf('.');
+    return i !== -1 ? fileName.substring(0, i) : fileName;
+}

package/dist/helpers/index.d.ts

@@ -0,0 +1,14 @@
+export * from './class.js';
+export * from './comments.js';
+export * from './commons.js';
+export * from './contest.js';
+export * from './document.js';
+export * from './file.js';
+export * from './interval.js';
+export * from './judging.js';
+export * from './object.js';
+export * from './responses.js';
+export * from './socket.js';
+export * from './time.js';
+export * from './user.js';
+export * from './worksheet.js';

package/dist/helpers/index.js

@@ -0,0 +1,14 @@
+export * from './class.js';
+export * from './comments.js';
+export * from './commons.js';
+export * from './contest.js';
+export * from './document.js';
+export * from './file.js';
+export * from './interval.js';
+export * from './judging.js';
+export * from './object.js';
+export * from './responses.js';
+export * from './socket.js';
+export * from './time.js';
+export * from './user.js';
+export * from './worksheet.js';

package/dist/helpers/interval.d.ts

@@ -0,0 +1,2 @@
+export declare const setAsyncInterval: (cb: () => Promise<void> | void, interval: number) => number;
+export declare const clearAsyncInterval: (intervalIndex: number) => void;

package/dist/helpers/interval.js

@@ -0,0 +1,22 @@
+// https://dev.to/jsmccrumb/asynchronous-setinterval-4j69
+const asyncIntervals = [];
+const runAsyncInterval = async (cb, interval, intervalIndex) => {
+    await cb();
+    if (asyncIntervals[intervalIndex]) {
+        setTimeout(() => runAsyncInterval(cb, interval, intervalIndex), interval);
+    }
+};
+export const setAsyncInterval = (cb, interval) => {
+    if (cb) {
+        const intervalIndex = asyncIntervals.length;
+        asyncIntervals.push(true);
+        void runAsyncInterval(cb, interval, intervalIndex);
+        return intervalIndex;
+    }
+    throw new Error('Callback must be a function');
+};
+export const clearAsyncInterval = (intervalIndex) => {
+    if (asyncIntervals[intervalIndex]) {
+        asyncIntervals[intervalIndex] = false;
+    }
+};

package/dist/helpers/judging.d.ts

@@ -0,0 +1,25 @@
+import { ProblemVerdict } from '../prisma/enums/index.js';
+import type { CodeEditorTestCase, DataLog, SubmissionTestCase, TestCaseVerdict } from '../types/index.js';
+export declare const getDataOfTestCase: (testCase: SubmissionTestCase, timeLimit: number, memoryLimit: number) => {
+    compilationError: boolean;
+    timeUsed: number;
+    timeLimitExceeded: boolean;
+    memoryUsed: number;
+    memoryLimitExceeded: boolean;
+    exitCode: number;
+    runtimeError: boolean;
+    failed: boolean;
+};
+export declare const getVerdictFromTestCase: (testCaseValue: CodeEditorTestCase, timeLimit: number, memoryLimit: number) => {
+    verdict: ProblemVerdict;
+    timeUsed: number;
+    memoryUsed: number;
+    exitCode: number;
+};
+export declare const mergeVerdicts: (first: TestCaseVerdict, second: TestCaseVerdict) => {
+    timeUsed: number;
+    memoryUsed: number;
+    exitCode: number;
+    verdict: ProblemVerdict;
+};
+export declare const getDataLog: (log: unknown) => DataLog;

package/dist/helpers/judging.js

@@ -0,0 +1,107 @@
+import { ProblemVerdict, SubmissionRunStatus } from '../prisma/enums/index.js';
+export const getDataOfTestCase = (testCase, timeLimit, memoryLimit) => {
+    const { timeUsed, memoryUsed, exitCode } = getDataLog(testCase?.log);
+    const timeLimitExceeded = timeUsed > timeLimit;
+    const memoryLimitExceeded = memoryUsed > memoryLimit;
+    const runtimeError = exitCode !== 0;
+    const compilationError = testCase?.status === SubmissionRunStatus.COMPILATION_ERROR;
+    return {
+        compilationError,
+        timeUsed,
+        timeLimitExceeded: timeLimitExceeded,
+        memoryUsed,
+        memoryLimitExceeded: memoryLimitExceeded,
+        exitCode,
+        runtimeError,
+        failed: !!testCase?.log && (timeLimitExceeded || memoryLimitExceeded || runtimeError),
+    };
+};
+function classifyOutput(testCaseValue) {
+    if (testCaseValue.out === testCaseValue.testOut)
+        return ProblemVerdict.AC;
+    const normalize = (s) => s.replaceAll(' ', '').replaceAll('\n', '');
+    if (normalize(testCaseValue.out) === normalize(testCaseValue.testOut)) {
+        return testCaseValue.withPE ? ProblemVerdict.PE : ProblemVerdict.AC;
+    }
+    return ProblemVerdict.WA;
+}
+function determineVerdict(testCaseValue, compilationError, timeLimitExceeded, memoryLimitExceeded, runtimeError) {
+    if (compilationError)
+        return ProblemVerdict.CE;
+    if (timeLimitExceeded)
+        return ProblemVerdict.TLE;
+    if (memoryLimitExceeded)
+        return ProblemVerdict.MLE;
+    if (runtimeError)
+        return ProblemVerdict.RE;
+    return classifyOutput(testCaseValue);
+}
+export const getVerdictFromTestCase = (testCaseValue, timeLimit, memoryLimit) => {
+    const { compilationError, timeLimitExceeded, memoryLimitExceeded, runtimeError, timeUsed, memoryUsed, exitCode } = getDataOfTestCase(testCaseValue, timeLimit, memoryLimit);
+    return {
+        verdict: determineVerdict(testCaseValue, compilationError, timeLimitExceeded, memoryLimitExceeded, runtimeError),
+        timeUsed,
+        memoryUsed,
+        exitCode,
+    };
+};
+const VERDICT_PRIORITY = [
+    ProblemVerdict.RE,
+    ProblemVerdict.TLE,
+    ProblemVerdict.MLE,
+    ProblemVerdict.WA,
+    ProblemVerdict.PE,
+    ProblemVerdict.PA,
+    ProblemVerdict.AC,
+];
+export const mergeVerdicts = (first, second) => {
+    const firstRank = VERDICT_PRIORITY.indexOf(first.verdict);
+    const secondRank = VERDICT_PRIORITY.indexOf(second.verdict);
+    const verdict = secondRank !== -1 && (firstRank === -1 || secondRank < firstRank) ? second.verdict : first.verdict;
+    return {
+        timeUsed: Math.max(first.timeUsed, second.timeUsed),
+        memoryUsed: Math.max(first.memoryUsed, second.memoryUsed),
+        exitCode: first.exitCode || second.exitCode,
+        verdict,
+    };
+};
+function parseLineValue(line, prefix) {
+    return parseInt(line.slice(prefix.length + 1), 10);
+}
+function parseStructuredLog(lines) {
+    let timeUsed = 0;
+    let memoryUsed = 0;
+    let exitCode = -1;
+    for (const line of lines) {
+        if (line.startsWith('time:')) {
+            timeUsed = (Number.isNaN(+line.split(':')[1]) ? 0 : +line.split(':')[1]) * 1000;
+        }
+        else if (line.startsWith('max-rss:')) {
+            memoryUsed = parseLineValue(line, 'max-rss');
+        }
+        else if (line.startsWith('exitcode:')) {
+            exitCode = parseLineValue(line, 'exitcode');
+        }
+    }
+    return { timeUsed, memoryUsed, exitCode };
+}
+function parseLegacyLog(lines) {
+    return {
+        timeUsed: +lines[0],
+        memoryUsed: +lines[1],
+        exitCode: +lines[2],
+    };
+}
+export const getDataLog = (log) => {
+    const lines = log?.split?.('\n') ?? [];
+    const raw = lines.length > 4
+        ? parseStructuredLog(lines)
+        : lines.length >= 3
+            ? parseLegacyLog(lines)
+            : { timeUsed: 0, memoryUsed: 0, exitCode: -1 };
+    return {
+        timeUsed: Number.isNaN(raw.timeUsed) ? 0 : raw.timeUsed,
+        memoryUsed: Number.isNaN(raw.memoryUsed) ? 0 : raw.memoryUsed,
+        exitCode: Number.isNaN(raw.exitCode) ? -1 : raw.exitCode,
+    };
+};

package/dist/helpers/object.d.ts

@@ -0,0 +1 @@
+export declare function memorySizeOf(obj: unknown): number;