course-format-ts 1.0.0

package/dist/courseFormat/tasks/choice/ChoiceTask.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChoiceTask = void 0;
+const CheckStatus_1 = require("../../CheckStatus");
+const uiMessages_1 = require("../../uiMessages");
+const Task_1 = require("../Task");
+class ChoiceTask extends Task_1.Task {
+    constructor(name, id, position, updateDate, status) {
+        super(name, id, position, updateDate, status);
+        this.choiceOptions = [];
+        this.isMultipleChoice = false;
+        this.selectedVariants = [];
+        this.messageCorrect = (0, uiMessages_1.message)("check.correct.solution");
+        this.messageIncorrect = (0, uiMessages_1.message)("check.incorrect.solution");
+        this.canCheckLocally = true;
+    }
+    get itemType() {
+        return ChoiceTask.CHOICE_TASK_TYPE;
+    }
+    get isPluginTaskType() {
+        return false;
+    }
+    get isChangedOnFailed() {
+        return !this.canCheckLocally;
+    }
+    get isToSubmitToRemote() {
+        return this.status !== CheckStatus_1.CheckStatus.Unchecked;
+    }
+    get presentableQuizHeader() {
+        if (this.quizHeader)
+            return this.quizHeader;
+        return this.isMultipleChoice
+            ? (0, uiMessages_1.message)("course.creator.create.choice.task.multiple.label")
+            : (0, uiMessages_1.message)("course.creator.create.choice.task.single.label");
+    }
+    addSelectedVariant(variant) {
+        this.selectedVariants.push(variant);
+    }
+    removeSelectedVariant(variant) {
+        this.selectedVariants = this.selectedVariants.filter((value) => value !== variant);
+    }
+    clearSelectedVariants() {
+        this.selectedVariants = [];
+    }
+}
+exports.ChoiceTask = ChoiceTask;
+ChoiceTask.CHOICE_TASK_TYPE = "choice";

package/dist/courseFormat/tasks/matching/MatchingTask.d.ts

@@ -0,0 +1,10 @@
+import { CheckStatus } from "../../CheckStatus";
+import { SortingBasedTask } from "./SortingBasedTask";
+export declare class MatchingTask extends SortingBasedTask {
+    captions: string[];
+    constructor();
+    constructor(name: string);
+    constructor(name: string, id: number, position: number, updateDate: Date, status: CheckStatus);
+    get itemType(): string;
+    static MATCHING_TASK_TYPE: string;
+}

package/dist/courseFormat/tasks/matching/MatchingTask.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MatchingTask = void 0;
+const SortingBasedTask_1 = require("./SortingBasedTask");
+class MatchingTask extends SortingBasedTask_1.SortingBasedTask {
+    constructor(name, id, position, updateDate, status) {
+        super(name, id, position, updateDate, status);
+        this.captions = [];
+    }
+    get itemType() {
+        return MatchingTask.MATCHING_TASK_TYPE;
+    }
+}
+exports.MatchingTask = MatchingTask;
+MatchingTask.MATCHING_TASK_TYPE = "matching";

package/dist/courseFormat/tasks/matching/SortingBasedTask.d.ts

@@ -0,0 +1,16 @@
+import { CheckStatus } from "../../CheckStatus";
+import { Task } from "../Task";
+export declare abstract class SortingBasedTask extends Task {
+    private _options;
+    ordering: number[];
+    get options(): string[];
+    set options(value: string[]);
+    constructor();
+    constructor(name: string);
+    constructor(name: string, id: number, position: number, updateDate: Date, status: CheckStatus);
+    getOrderedOptions(): string[];
+    moveOptionUp(index: number): void;
+    moveOptionDown(index: number): void;
+    swapOptions(firstColumnIndex: number, secondColumnIndex: number): void;
+    restoreInitialOrdering(): void;
+}

package/dist/courseFormat/tasks/matching/SortingBasedTask.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SortingBasedTask = void 0;
+const loggerUtils_1 = require("../../loggerUtils");
+const Task_1 = require("../Task");
+class SortingBasedTask extends Task_1.Task {
+    get options() {
+        return this._options;
+    }
+    set options(value) {
+        this.ordering = value.map((_, index) => index);
+        this._options = value;
+    }
+    constructor(name, id, position, updateDate, status) {
+        super(name, id, position, updateDate, status);
+        this._options = [];
+        this.ordering = [];
+    }
+    getOrderedOptions() {
+        return this.options.map((_, index) => this.options[this.ordering[index]]);
+    }
+    moveOptionUp(index) {
+        const targetIndex = index - 1;
+        if (targetIndex < 0) {
+            const message = "There was an attempt to move the option up out of bounds";
+            (0, loggerUtils_1.logger)("SortingBasedTask").error(message);
+            throw new Error(message);
+        }
+        this.swapOptions(index, targetIndex);
+    }
+    moveOptionDown(index) {
+        const targetIndex = index + 1;
+        if (targetIndex === this.options.length) {
+            const message = "There was an attempt to move the option down out of bounds";
+            (0, loggerUtils_1.logger)("SortingBasedTask").error(message);
+            throw new Error(message);
+        }
+        this.swapOptions(index, targetIndex);
+    }
+    swapOptions(firstColumnIndex, secondColumnIndex) {
+        const firstOptionIndex = this.ordering[firstColumnIndex];
+        const secondOptionIndex = this.ordering[secondColumnIndex];
+        this.ordering[firstColumnIndex] = secondOptionIndex;
+        this.ordering[secondColumnIndex] = firstOptionIndex;
+    }
+    restoreInitialOrdering() {
+        this.ordering = this.options.map((_, index) => index);
+    }
+}
+exports.SortingBasedTask = SortingBasedTask;

package/dist/courseFormat/tasks/matching/SortingTask.d.ts

@@ -0,0 +1,9 @@
+import { CheckStatus } from "../../CheckStatus";
+import { SortingBasedTask } from "./SortingBasedTask";
+export declare class SortingTask extends SortingBasedTask {
+    constructor();
+    constructor(name: string);
+    constructor(name: string, id: number, position: number, updateDate: Date, status: CheckStatus);
+    get itemType(): string;
+    static SORTING_TASK_TYPE: string;
+}

package/dist/courseFormat/tasks/matching/SortingTask.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SortingTask = void 0;
+const SortingBasedTask_1 = require("./SortingBasedTask");
+class SortingTask extends SortingBasedTask_1.SortingBasedTask {
+    constructor(name, id, position, updateDate, status) {
+        super(name, id, position, updateDate, status);
+    }
+    get itemType() {
+        return SortingTask.SORTING_TASK_TYPE;
+    }
+}
+exports.SortingTask = SortingTask;
+SortingTask.SORTING_TASK_TYPE = "sorting";

package/dist/courseFormat/uiMessages.d.ts

@@ -0,0 +1,3 @@
+declare const FORMAT_BUNDLE = "messages.EduFormatBundle";
+export declare function message(key: string, ...params: Array<string | number>): string;
+export { FORMAT_BUNDLE };

package/dist/courseFormat/uiMessages.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FORMAT_BUNDLE = void 0;
+exports.message = message;
+const FORMAT_BUNDLE = "messages.EduFormatBundle";
+exports.FORMAT_BUNDLE = FORMAT_BUNDLE;
+function message(key, ...params) {
+    if (params.length === 0) {
+        return key;
+    }
+    return params.reduce((result, param, index) => {
+        return result.replace(new RegExp(`\\{${index}\\}`, "g"), String(param));
+    }, key);
+}

package/dist/disk-loader.d.ts

@@ -0,0 +1,4 @@
+import { Course } from "./courseFormat/Course";
+export declare function loadCourseProject(projectPath: string, options?: {
+    aesKey?: string;
+}): Promise<Course>;

package/dist/disk-loader.js

@@ -0,0 +1,389 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadCourseProject = loadCourseProject;
+const node_fs_1 = require("node:fs");
+const node_fs_2 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const yaml_1 = require("yaml");
+const CheckStatus_1 = require("./courseFormat/CheckStatus");
+const CourseMode_1 = require("./courseFormat/CourseMode");
+const Lesson_1 = require("./courseFormat/Lesson");
+const EduCourse_1 = require("./courseFormat/EduCourse");
+const CourseraCourse_1 = require("./courseFormat/CourseraCourse");
+const HyperskillCourse_1 = require("./courseFormat/hyperskill/HyperskillCourse");
+const StepikCourse_1 = require("./courseFormat/stepik/StepikCourse");
+const StepikLesson_1 = require("./courseFormat/stepik/StepikLesson");
+const EduTask_1 = require("./courseFormat/tasks/EduTask");
+const CodeTask_1 = require("./courseFormat/tasks/CodeTask");
+const NumberTask_1 = require("./courseFormat/tasks/NumberTask");
+const StringTask_1 = require("./courseFormat/tasks/StringTask");
+const OutputTask_1 = require("./courseFormat/tasks/OutputTask");
+const DataTask_1 = require("./courseFormat/tasks/DataTask");
+const TableTask_1 = require("./courseFormat/tasks/TableTask");
+const TheoryTask_1 = require("./courseFormat/tasks/TheoryTask");
+const IdeTask_1 = require("./courseFormat/tasks/IdeTask");
+const UnsupportedTask_1 = require("./courseFormat/tasks/UnsupportedTask");
+const RemoteEduTask_1 = require("./courseFormat/tasks/RemoteEduTask");
+const ChoiceTask_1 = require("./courseFormat/tasks/choice/ChoiceTask");
+const ChoiceOption_1 = require("./courseFormat/tasks/choice/ChoiceOption");
+const ChoiceOptionStatus_1 = require("./courseFormat/tasks/choice/ChoiceOptionStatus");
+const MatchingTask_1 = require("./courseFormat/tasks/matching/MatchingTask");
+const SortingTask_1 = require("./courseFormat/tasks/matching/SortingTask");
+const TaskFile_1 = require("./courseFormat/TaskFile");
+const COURSE_CONFIG = "course-info.yaml";
+const LESSON_CONFIG = "lesson-info.yaml";
+const TASK_CONFIG = "task-info.yaml";
+const TEST_AES_KEY = "DFC929E375655998A34E56A21C98651C";
+function createCourse(type) {
+    switch (type) {
+        case "hyperskill":
+            return new HyperskillCourse_1.HyperskillCourse();
+        case "coursera":
+            return new CourseraCourse_1.CourseraCourse();
+        case "stepik":
+            return new StepikCourse_1.StepikCourse();
+        default:
+            const course = new EduCourse_1.EduCourse();
+            return course;
+    }
+}
+function hydrateCourse(course, yaml) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    course.name = (_a = yaml.title) !== null && _a !== void 0 ? _a : "";
+    course.description = (_b = yaml.summary) !== null && _b !== void 0 ? _b : "";
+    course.programmingLanguage = (_c = yaml.programming_language) !== null && _c !== void 0 ? _c : "";
+    course.languageVersion = yaml.programming_language_version;
+    course.environment = (_d = yaml.environment) !== null && _d !== void 0 ? _d : course.environment;
+    course.solutionsHidden = (_e = yaml.solutions_hidden) !== null && _e !== void 0 ? _e : course.solutionsHidden;
+    course.environmentSettings = (_f = yaml.environment_settings) !== null && _f !== void 0 ? _f : course.environmentSettings;
+    course.customContentPath = (_g = yaml.custom_content_path) !== null && _g !== void 0 ? _g : course.customContentPath;
+    course.disabledFeatures = (_h = yaml.disabled_features) !== null && _h !== void 0 ? _h : course.disabledFeatures;
+    course.vendor = (_j = yaml.vendor) !== null && _j !== void 0 ? _j : course.vendor;
+    if (yaml.is_private !== undefined)
+        course.isMarketplacePrivate = yaml.is_private;
+    if (yaml.mode) {
+        course.courseMode = CourseMode_1.CourseMode.STUDENT;
+    }
+    else {
+        course.courseMode = CourseMode_1.CourseMode.EDUCATOR;
+    }
+}
+function loadCourseProject(projectPath_1) {
+    return __awaiter(this, arguments, void 0, function* (projectPath, options = {}) {
+        var _a;
+        const courseConfigPath = node_path_1.default.join(projectPath, COURSE_CONFIG);
+        const courseYaml = yield readRawYamlFile(courseConfigPath);
+        if (!courseYaml.title) {
+            throw new Error(`Missing 'title' in ${courseConfigPath}`);
+        }
+        if (!courseYaml.language) {
+            throw new Error(`Missing 'language' in ${courseConfigPath}`);
+        }
+        if (!courseYaml.programming_language) {
+            throw new Error(`Missing 'programming_language' in ${courseConfigPath}`);
+        }
+        const contentNames = ensureNamedContent(courseYaml.content, courseConfigPath);
+        const aesKey = (_a = options.aesKey) !== null && _a !== void 0 ? _a : getAesKey();
+        const course = createCourse(courseYaml.type);
+        hydrateCourse(course, courseYaml);
+        course.languageCode = courseYaml.language;
+        const lessons = yield Promise.all(contentNames.map((lessonName) => loadLesson(projectPath, lessonName, aesKey, courseYaml.type)));
+        for (const lesson of lessons) {
+            course.addLesson(lesson);
+        }
+        return course;
+    });
+}
+function createLesson(courseType) {
+    if (courseType === "stepik") {
+        return new StepikLesson_1.StepikLesson();
+    }
+    return new Lesson_1.Lesson();
+}
+function hydrateLesson(lesson, lessonName, yaml) {
+    lesson.name = lessonName;
+    if (yaml.custom_name) {
+        lesson.customPresentableName = yaml.custom_name;
+    }
+    if (yaml.tags) {
+        lesson.contentTags = yaml.tags;
+    }
+}
+function loadLesson(coursePath, lessonName, aesKey, courseType) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const lessonPath = node_path_1.default.join(coursePath, lessonName);
+        const lessonConfigPath = node_path_1.default.join(lessonPath, LESSON_CONFIG);
+        const lessonYaml = yield readRawYamlFile(lessonConfigPath);
+        const taskNames = ensureNamedContent(lessonYaml.content, lessonConfigPath);
+        const tasks = yield Promise.all(taskNames.map((taskName) => loadTask(lessonPath, taskName, aesKey)));
+        const lesson = createLesson(courseType);
+        hydrateLesson(lesson, lessonName, lessonYaml);
+        for (const task of tasks) {
+            lesson.addTask(task);
+        }
+        return lesson;
+    });
+}
+function createTask(taskType) {
+    switch (taskType) {
+        case "edu":
+        case "pycharm":
+            return new EduTask_1.EduTask();
+        case "code":
+            return new CodeTask_1.CodeTask();
+        case "number":
+            return new NumberTask_1.NumberTask();
+        case "string":
+            return new StringTask_1.StringTask();
+        case "output":
+            return new OutputTask_1.OutputTask();
+        case "dataset":
+            return new DataTask_1.DataTask();
+        case "table":
+            return new TableTask_1.TableTask();
+        case "theory":
+            return new TheoryTask_1.TheoryTask();
+        case "ide":
+            return new IdeTask_1.IdeTask();
+        case "unsupported":
+            return new UnsupportedTask_1.UnsupportedTask();
+        case "remote_edu":
+            return new RemoteEduTask_1.RemoteEduTask();
+        case "choice":
+            return new ChoiceTask_1.ChoiceTask();
+        case "matching":
+            return new MatchingTask_1.MatchingTask();
+        case "sorting":
+            return new SortingTask_1.SortingTask();
+        default:
+            return null;
+    }
+}
+function hydrateTask(task, taskName, yaml) {
+    var _a;
+    task.name = taskName;
+    if (yaml.status !== undefined && yaml.status !== null) {
+        const statusStr = String(yaml.status);
+        const statusMap = {
+            Unchecked: CheckStatus_1.CheckStatus.Unchecked,
+            Solved: CheckStatus_1.CheckStatus.Solved,
+            Failed: CheckStatus_1.CheckStatus.Failed,
+        };
+        task.status = (_a = statusMap[statusStr]) !== null && _a !== void 0 ? _a : CheckStatus_1.CheckStatus.Unchecked;
+    }
+    if (typeof yaml.record === "number") {
+        task.record = yaml.record;
+    }
+    if (yaml.feedback_link !== undefined) {
+        task.feedbackLink = String(yaml.feedback_link);
+    }
+    if (yaml.solution_hidden !== undefined) {
+        task.solutionHidden = Boolean(yaml.solution_hidden);
+    }
+    if (Array.isArray(yaml.tags)) {
+        task.contentTags = yaml.tags.map(String);
+    }
+}
+function hydrateChoiceTask(task, yaml) {
+    if (yaml.is_multiple_choice !== undefined) {
+        task.isMultipleChoice = Boolean(yaml.is_multiple_choice);
+    }
+    if (Array.isArray(yaml.options)) {
+        task.choiceOptions = yaml.options.map((opt) => {
+            var _a;
+            const option = new ChoiceOption_1.ChoiceOption();
+            option.text = String((_a = opt.text) !== null && _a !== void 0 ? _a : "");
+            if (opt.is_correct === true) {
+                option.status = ChoiceOptionStatus_1.ChoiceOptionStatus.CORRECT;
+            }
+            else if (opt.is_correct === false) {
+                option.status = ChoiceOptionStatus_1.ChoiceOptionStatus.INCORRECT;
+            }
+            return option;
+        });
+    }
+}
+function hydrateMatchingTask(task, yaml) {
+    if (Array.isArray(yaml.captions)) {
+        const captions = yaml.captions;
+        task.captions = captions.map((c) => {
+            var _a, _b;
+            const first = String((_a = c.first) !== null && _a !== void 0 ? _a : "");
+            const second = String((_b = c.second) !== null && _b !== void 0 ? _b : "");
+            return `${first} : ${second}`;
+        });
+    }
+    if (Array.isArray(yaml.options)) {
+        const opts = yaml.options;
+        task.options = opts.map(String);
+    }
+}
+function hydrateSortingTask(task, yaml) {
+    if (Array.isArray(yaml.options)) {
+        const opts = yaml.options;
+        task.options = opts.map(String);
+    }
+}
+function hydrateTableTask(task, yaml) {
+    if (yaml.is_multiple_choice !== undefined) {
+        task.isMultipleChoice = Boolean(yaml.is_multiple_choice);
+    }
+    if (Array.isArray(yaml.rows)) {
+        task.rows = yaml.rows.map(String);
+    }
+    if (Array.isArray(yaml.columns)) {
+        task.columns = yaml.columns.map(String);
+    }
+    if (Array.isArray(yaml.selected)) {
+        const sel = yaml.selected;
+        task.selected = sel.map((row) => row.map(Boolean));
+    }
+}
+function loadTask(lessonPath, taskName, aesKey) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const taskPath = node_path_1.default.join(lessonPath, taskName);
+        const taskConfigPath = node_path_1.default.join(taskPath, TASK_CONFIG);
+        const rawYaml = yield readRawYamlFile(taskConfigPath);
+        if (!rawYaml.type) {
+            throw new Error(`Missing 'type' in ${taskConfigPath}`);
+        }
+        const task = createTask(rawYaml.type);
+        if (!task) {
+            throw new Error(`Unknown task type '${rawYaml.type}' in ${taskConfigPath}`);
+        }
+        hydrateTask(task, taskName, rawYaml);
+        const files = rawYaml.files
+            ? yield Promise.all(rawYaml.files.map((file) => loadTaskFile(taskPath, file, aesKey)))
+            : [];
+        for (const taskFile of files) {
+            task.addTaskFileInstance(taskFile);
+        }
+        // Hydrate task-specific fields
+        if (task instanceof ChoiceTask_1.ChoiceTask) {
+            hydrateChoiceTask(task, rawYaml);
+        }
+        else if (task instanceof MatchingTask_1.MatchingTask) {
+            hydrateMatchingTask(task, rawYaml);
+        }
+        else if (task instanceof SortingTask_1.SortingTask) {
+            hydrateSortingTask(task, rawYaml);
+        }
+        else if (task instanceof TableTask_1.TableTask) {
+            hydrateTableTask(task, rawYaml);
+        }
+        return task;
+    });
+}
+function loadTaskFile(ownerPath, fileYaml, aesKey) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e;
+        if (!fileYaml.name) {
+            throw new Error(`Task file without name in ${ownerPath}`);
+        }
+        const isBinary = (_a = fileYaml.is_binary) !== null && _a !== void 0 ? _a : false;
+        const text = yield resolveTaskFileText(ownerPath, fileYaml, aesKey, isBinary);
+        const taskFile = new TaskFile_1.TaskFile();
+        taskFile.name = fileYaml.name;
+        taskFile.text = text !== null && text !== void 0 ? text : "";
+        taskFile.isVisible = (_b = fileYaml.visible) !== null && _b !== void 0 ? _b : true;
+        taskFile.isEditable = (_c = fileYaml.editable) !== null && _c !== void 0 ? _c : true;
+        taskFile.isPropagatable = (_d = fileYaml.propagatable) !== null && _d !== void 0 ? _d : true;
+        taskFile.isLearnerCreated = (_e = fileYaml.learner_created) !== null && _e !== void 0 ? _e : false;
+        return taskFile;
+    });
+}
+function resolveTaskFileText(ownerPath, fileYaml, aesKey, isBinary) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (fileYaml.encrypted_text) {
+            let decryptedText;
+            try {
+                decryptedText = decryptText(fileYaml.encrypted_text, aesKey);
+            }
+            catch (_a) {
+                decryptedText = undefined;
+            }
+            if (decryptedText && decryptedText.length > 0) {
+                return decryptedText;
+            }
+            const fileText = yield readTaskFileFromDisk(ownerPath, fileYaml.name, isBinary);
+            return fileText !== null && fileText !== void 0 ? fileText : decryptedText;
+        }
+        if (fileYaml.text !== undefined) {
+            return fileYaml.text;
+        }
+        return readTaskFileFromDisk(ownerPath, fileYaml.name, isBinary);
+    });
+}
+function readTaskFileFromDisk(ownerPath, name, isBinary) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!name)
+            return undefined;
+        const filePath = node_path_1.default.join(ownerPath, name);
+        try {
+            const buffer = yield node_fs_1.promises.readFile(filePath);
+            return isBinary ? buffer.toString("base64") : buffer.toString("utf8");
+        }
+        catch (_a) {
+            return undefined;
+        }
+    });
+}
+function ensureNamedContent(content, configPath) {
+    if (!content)
+        return [];
+    return content.map((name, index) => {
+        if (!name) {
+            throw new Error(`Unnamed item at position ${index + 1} in ${configPath}`);
+        }
+        return name;
+    });
+}
+function readRawYamlFile(filePath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const text = yield node_fs_1.promises.readFile(filePath, "utf8");
+        return (0, yaml_1.parse)(text);
+    });
+}
+function decryptText(encryptedText, aesKey) {
+    const key = Buffer.from(aesKey, "utf8");
+    const iv = Buffer.from(aesKey.slice(0, 16), "utf8");
+    const decipher = node_crypto_1.default.createDecipheriv("aes-256-cbc", key, iv);
+    const decrypted = Buffer.concat([
+        decipher.update(Buffer.from(encryptedText, "base64")),
+        decipher.final(),
+    ]);
+    return decrypted.toString("utf8");
+}
+function getAesKey() {
+    const keyFromFile = readAesKeyFromResources();
+    if (keyFromFile && keyFromFile.length === 32) {
+        return keyFromFile;
+    }
+    return TEST_AES_KEY;
+}
+function readAesKeyFromResources() {
+    const resourcePath = node_path_1.default.resolve(process.cwd(), "edu-format", "resources", "aes", "aes.properties");
+    try {
+        const data = (0, node_fs_2.readFileSync)(resourcePath, "utf8");
+        const match = data.split(/\r?\n/).find((line) => line.startsWith("aesKey="));
+        if (!match)
+            return null;
+        return match.slice("aesKey=".length).trim() || null;
+    }
+    catch (_a) {
+        return null;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+export { loadCourseProject } from "./disk-loader";
+export { loadCourseProjectFromZip } from "./zip-loader";
+export { EduCourse } from "./courseFormat/EduCourse";
+export { CourseraCourse } from "./courseFormat/CourseraCourse";
+export { HyperskillCourse } from "./courseFormat/hyperskill/HyperskillCourse";
+export { StepikCourse } from "./courseFormat/stepik/StepikCourse";
+export { Course } from "./courseFormat/Course";
+export { CourseMode } from "./courseFormat/CourseMode";
+export { Lesson } from "./courseFormat/Lesson";
+export { StepikLesson } from "./courseFormat/stepik/StepikLesson";
+export { FrameworkLesson } from "./courseFormat/FrameworkLesson";
+export { Section } from "./courseFormat/Section";
+export { TaskFile } from "./courseFormat/TaskFile";
+export { Task } from "./courseFormat/tasks/Task";
+export { EduTask } from "./courseFormat/tasks/EduTask";
+export { CodeTask } from "./courseFormat/tasks/CodeTask";
+export { AnswerTask } from "./courseFormat/tasks/AnswerTask";
+export { NumberTask } from "./courseFormat/tasks/NumberTask";
+export { StringTask } from "./courseFormat/tasks/StringTask";
+export { OutputTask } from "./courseFormat/tasks/OutputTask";
+export { DataTask } from "./courseFormat/tasks/DataTask";
+export { TableTask } from "./courseFormat/tasks/TableTask";
+export { TheoryTask } from "./courseFormat/tasks/TheoryTask";
+export { IdeTask } from "./courseFormat/tasks/IdeTask";
+export { UnsupportedTask } from "./courseFormat/tasks/UnsupportedTask";
+export { RemoteEduTask } from "./courseFormat/tasks/RemoteEduTask";
+export { ChoiceTask } from "./courseFormat/tasks/choice/ChoiceTask";
+export { MatchingTask } from "./courseFormat/tasks/matching/MatchingTask";
+export { SortingTask } from "./courseFormat/tasks/matching/SortingTask";
+export { Vendor } from "./models";
+export { CheckStatus } from "./courseFormat/CheckStatus";