task-o-matic-core 0.1.0

package/dist/test/utils/error-handling.test.js

@@ -0,0 +1,231 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert = __importStar(require("assert"));
+const task_o_matic_error_1 = require("../../utils/task-o-matic-error");
+describe("TaskOMaticError", () => {
+    describe("TaskOMaticError class", () => {
+        it("should create a TaskOMaticError with all properties", () => {
+            const error = new task_o_matic_error_1.TaskOMaticError("Test error", {
+                code: task_o_matic_error_1.TaskOMaticErrorCodes.UNEXPECTED_ERROR,
+                context: "Test context",
+                suggestions: ["Suggestion 1", "Suggestion 2"],
+                metadata: { key: "value" },
+            });
+            assert.strictEqual(error.name, "TaskOMaticError");
+            assert.strictEqual(error.message, "Test error");
+            assert.strictEqual(error.code, task_o_matic_error_1.TaskOMaticErrorCodes.UNEXPECTED_ERROR);
+            assert.strictEqual(error.context, "Test context");
+            assert.deepStrictEqual(error.suggestions, [
+                "Suggestion 1",
+                "Suggestion 2",
+            ]);
+            assert.deepStrictEqual(error.metadata, { key: "value" });
+            assert.ok(error.timestamp);
+            assert.ok(error.stack);
+        });
+        it("should create a TaskOMaticError with minimal properties", () => {
+            const error = new task_o_matic_error_1.TaskOMaticError("Minimal error", {
+                code: task_o_matic_error_1.TaskOMaticErrorCodes.UNEXPECTED_ERROR,
+            });
+            assert.strictEqual(error.name, "TaskOMaticError");
+            assert.strictEqual(error.message, "Minimal error");
+            assert.strictEqual(error.code, task_o_matic_error_1.TaskOMaticErrorCodes.UNEXPECTED_ERROR);
+            assert.ok(error.timestamp);
+        });
+        it("should include cause error", () => {
+            const cause = new Error("Original error");
+            const error = new task_o_matic_error_1.TaskOMaticError("Wrapped error", {
+                code: task_o_matic_error_1.TaskOMaticErrorCodes.UNEXPECTED_ERROR,
+                cause,
+            });
+            assert.strictEqual(error.cause, cause);
+        });
+    });
+    describe("getDetails()", () => {
+        it("should return formatted error details", () => {
+            const error = new task_o_matic_error_1.TaskOMaticError("Test error", {
+                code: task_o_matic_error_1.TaskOMaticErrorCodes.UNEXPECTED_ERROR,
+                context: "Test context",
+                suggestions: ["Suggestion 1"],
+                metadata: { key: "value" },
+            });
+            const details = error.getDetails();
+            assert.ok(details.includes("[TASK_O_MATIC_001]"));
+            assert.ok(details.includes("Test error"));
+            assert.ok(details.includes("Context: Test context"));
+            assert.ok(details.includes("Suggestions:"));
+            assert.ok(details.includes("Suggestion 1"));
+            assert.ok(details.includes("Metadata:"));
+        });
+    });
+    describe("toJSON()", () => {
+        it("should return structured error data", () => {
+            const error = new task_o_matic_error_1.TaskOMaticError("Test error", {
+                code: task_o_matic_error_1.TaskOMaticErrorCodes.UNEXPECTED_ERROR,
+                context: "Test context",
+                suggestions: ["Suggestion 1"],
+                metadata: { key: "value" },
+            });
+            const json = error.toJSON();
+            assert.strictEqual(json.name, "TaskOMaticError");
+            assert.strictEqual(json.code, task_o_matic_error_1.TaskOMaticErrorCodes.UNEXPECTED_ERROR);
+            assert.strictEqual(json.message, "Test error");
+            assert.strictEqual(json.context, "Test context");
+            assert.deepStrictEqual(json.suggestions, ["Suggestion 1"]);
+            assert.deepStrictEqual(json.metadata, { key: "value" });
+            assert.ok(json.timestamp);
+            assert.ok(json.stack);
+        });
+    });
+    describe("createStandardError()", () => {
+        it("should create a standardized error", () => {
+            const error = (0, task_o_matic_error_1.createStandardError)(task_o_matic_error_1.TaskOMaticErrorCodes.TASK_NOT_FOUND, "Task not found", {
+                context: "Task search failed",
+                suggestions: ["Check task ID", "List all tasks"],
+            });
+            assert.ok((0, task_o_matic_error_1.isTaskOMaticError)(error));
+            assert.strictEqual(error.code, task_o_matic_error_1.TaskOMaticErrorCodes.TASK_NOT_FOUND);
+            assert.strictEqual(error.message, "Task not found");
+            assert.strictEqual(error.context, "Task search failed");
+            assert.deepStrictEqual(error.suggestions, [
+                "Check task ID",
+                "List all tasks",
+            ]);
+        });
+    });
+    describe("formatStandardError()", () => {
+        it("should format an error with context and suggestions", () => {
+            const originalError = new Error("Original error");
+            const error = (0, task_o_matic_error_1.formatStandardError)(originalError, task_o_matic_error_1.TaskOMaticErrorCodes.STORAGE_ERROR, {
+                context: "Storage operation failed",
+                suggestions: ["Check permissions", "Retry operation"],
+            });
+            assert.ok((0, task_o_matic_error_1.isTaskOMaticError)(error));
+            assert.strictEqual(error.code, task_o_matic_error_1.TaskOMaticErrorCodes.STORAGE_ERROR);
+            assert.strictEqual(error.message, "Original error");
+            assert.strictEqual(error.context, "Storage operation failed");
+            assert.deepStrictEqual(error.suggestions, [
+                "Check permissions",
+                "Retry operation",
+            ]);
+            assert.strictEqual(error.cause, originalError);
+        });
+    });
+    describe("isTaskOMaticError()", () => {
+        it("should return true for TaskOMaticError instances", () => {
+            const error = new task_o_matic_error_1.TaskOMaticError("Test", {
+                code: task_o_matic_error_1.TaskOMaticErrorCodes.UNEXPECTED_ERROR,
+            });
+            assert.strictEqual((0, task_o_matic_error_1.isTaskOMaticError)(error), true);
+        });
+        it("should return false for regular Errors", () => {
+            const error = new Error("Regular error");
+            assert.strictEqual((0, task_o_matic_error_1.isTaskOMaticError)(error), false);
+        });
+        it("should return false for other values", () => {
+            assert.strictEqual((0, task_o_matic_error_1.isTaskOMaticError)("string error"), false);
+            assert.strictEqual((0, task_o_matic_error_1.isTaskOMaticError)(null), false);
+            assert.strictEqual((0, task_o_matic_error_1.isTaskOMaticError)(undefined), false);
+        });
+    });
+    describe("Standard error formatters", () => {
+        it("should format task not found error", () => {
+            const error = (0, task_o_matic_error_1.formatTaskNotFoundError)("task-123");
+            assert.ok((0, task_o_matic_error_1.isTaskOMaticError)(error));
+            assert.strictEqual(error.code, task_o_matic_error_1.TaskOMaticErrorCodes.TASK_NOT_FOUND);
+            assert.ok(error.message.includes("task-123"));
+            assert.ok(error.context);
+            assert.ok(error.suggestions);
+        });
+        it("should format invalid status transition error", () => {
+            const error = (0, task_o_matic_error_1.formatInvalidStatusTransitionError)("todo", "invalid");
+            assert.ok((0, task_o_matic_error_1.isTaskOMaticError)(error));
+            assert.strictEqual(error.code, task_o_matic_error_1.TaskOMaticErrorCodes.INVALID_TASK_STATUS);
+            assert.ok(error.message.includes("todo"));
+            assert.ok(error.message.includes("invalid"));
+            assert.ok(error.context);
+            assert.ok(error.suggestions);
+        });
+        it("should format storage error", () => {
+            const cause = new Error("Storage failed");
+            const error = (0, task_o_matic_error_1.formatStorageError)("save", cause);
+            assert.ok((0, task_o_matic_error_1.isTaskOMaticError)(error));
+            assert.strictEqual(error.code, task_o_matic_error_1.TaskOMaticErrorCodes.STORAGE_ERROR);
+            assert.ok(error.message.includes("save"));
+            assert.strictEqual(error.cause, cause);
+        });
+        it("should format AI operation error", () => {
+            const cause = new Error("AI failed");
+            const error = (0, task_o_matic_error_1.formatAIOperationError)("generate", cause);
+            assert.ok((0, task_o_matic_error_1.isTaskOMaticError)(error));
+            assert.strictEqual(error.code, task_o_matic_error_1.TaskOMaticErrorCodes.AI_OPERATION_FAILED);
+            assert.ok(error.message.includes("generate"));
+            assert.strictEqual(error.cause, cause);
+        });
+    });
+    describe("wrapErrorForBackwardCompatibility()", () => {
+        it("should return TaskOMaticError unchanged", () => {
+            const error = new task_o_matic_error_1.TaskOMaticError("Test", {
+                code: task_o_matic_error_1.TaskOMaticErrorCodes.UNEXPECTED_ERROR,
+            });
+            const wrapped = (0, task_o_matic_error_1.wrapErrorForBackwardCompatibility)(error);
+            assert.strictEqual(wrapped, error);
+        });
+        it("should return regular Error unchanged", () => {
+            const error = new Error("Regular error");
+            const wrapped = (0, task_o_matic_error_1.wrapErrorForBackwardCompatibility)(error);
+            assert.strictEqual(wrapped, error);
+        });
+        it("should convert non-Error values to Error", () => {
+            const wrapped1 = (0, task_o_matic_error_1.wrapErrorForBackwardCompatibility)("string error");
+            assert.ok(wrapped1 instanceof Error);
+            assert.ok(wrapped1.message.includes("string error"));
+            const wrapped2 = (0, task_o_matic_error_1.wrapErrorForBackwardCompatibility)({
+                message: "object error",
+            });
+            assert.ok(wrapped2 instanceof Error);
+            assert.ok(wrapped2.message.includes("object error"));
+        });
+    });
+    describe("Error codes", () => {
+        it("should have defined error codes", () => {
+            assert.ok(task_o_matic_error_1.TaskOMaticErrorCodes.UNEXPECTED_ERROR);
+            assert.ok(task_o_matic_error_1.TaskOMaticErrorCodes.TASK_NOT_FOUND);
+            assert.ok(task_o_matic_error_1.TaskOMaticErrorCodes.STORAGE_ERROR);
+            assert.ok(task_o_matic_error_1.TaskOMaticErrorCodes.AI_OPERATION_FAILED);
+        });
+    });
+});

package/dist/test/utils/file-utils.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=file-utils.test.d.ts.map

package/dist/test/utils/file-utils.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-utils.test.d.ts","sourceRoot":"","sources":["../../../src/test/utils/file-utils.test.ts"],"names":[],"mappings":""}

package/dist/test/utils/file-utils.test.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __importDefault(require("assert"));
+const path_1 = require("path");
+const fs_1 = require("fs");
+const file_utils_1 = require("../../utils/file-utils");
+const config_1 = require("../../lib/config");
+const task_o_matic_error_1 = require("../../utils/task-o-matic-error");
+describe("File Utilities", () => {
+    let testDir;
+    before(function () {
+        testDir = (0, path_1.join)(process.cwd(), "temp-test-file-utils");
+        if (!(0, fs_1.existsSync)(testDir)) {
+            (0, fs_1.mkdirSync)(testDir);
+        }
+        config_1.configManager.setWorkingDirectory(testDir);
+    });
+    after(function () {
+        try {
+            if ((0, fs_1.existsSync)(testDir)) {
+                (0, fs_1.rmdirSync)(testDir, { recursive: true });
+            }
+        }
+        catch (e) {
+            // Ignore cleanup errors
+        }
+    });
+    describe("Validation", () => {
+        it("validateFileExists should pass for existing file", () => {
+            const existingFile = (0, path_1.join)(testDir, "exist.txt");
+            (0, fs_1.writeFileSync)(existingFile, "content");
+            assert_1.default.doesNotThrow(() => (0, file_utils_1.validateFileExists)(existingFile));
+        });
+        it("validateFileExists should throw for missing file", () => {
+            const missingFile = (0, path_1.join)(testDir, "missing.txt");
+            assert_1.default.throws(() => (0, file_utils_1.validateFileExists)(missingFile), (err) => {
+                return err.code === task_o_matic_error_1.TaskOMaticErrorCodes.INVALID_INPUT;
+            });
+        });
+        it("validateFileExistsAsync should pass for existing file", async () => {
+            const existingFile = (0, path_1.join)(testDir, "exist-async.txt");
+            (0, fs_1.writeFileSync)(existingFile, "content");
+            await (0, file_utils_1.validateFileExistsAsync)(existingFile);
+        });
+    });
+    describe("Existence Check", () => {
+        it("fileExists should return true for existing file", () => {
+            const existingFile = (0, path_1.join)(testDir, "exist-check.txt");
+            (0, fs_1.writeFileSync)(existingFile, "content");
+            assert_1.default.strictEqual((0, file_utils_1.fileExists)(existingFile), true);
+        });
+        it("fileExists should return false for missing file", () => {
+            const missingFile = (0, path_1.join)(testDir, "missing-check.txt");
+            assert_1.default.strictEqual((0, file_utils_1.fileExists)(missingFile), false);
+        });
+    });
+    describe("PRD File", () => {
+        it("savePRDFile should save file to default location", () => {
+            const content = "# PRD Content";
+            const path = (0, file_utils_1.savePRDFile)(content);
+            assert_1.default.ok((0, fs_1.existsSync)(path));
+        });
+    });
+    describe("Stack File", () => {
+        it("saveStackFile should save and load json", () => {
+            const data = { foo: "bar" };
+            const path = (0, file_utils_1.saveStackFile)(data);
+            assert_1.default.ok((0, fs_1.existsSync)(path));
+            const loaded = (0, file_utils_1.loadStackFile)();
+            assert_1.default.deepStrictEqual(loaded, data);
+        });
+    });
+});

package/dist/test/utils/id-generator.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=id-generator.test.d.ts.map

package/dist/test/utils/id-generator.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"id-generator.test.d.ts","sourceRoot":"","sources":["../../../src/test/utils/id-generator.test.ts"],"names":[],"mappings":""}

package/dist/test/utils/id-generator.test.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __importDefault(require("assert"));
+const id_generator_1 = require("../../utils/id-generator");
+describe("TaskIDGenerator", () => {
+    describe("generate", () => {
+        it("should generate ID with default prefix", () => {
+            const id = id_generator_1.TaskIDGenerator.generate();
+            assert_1.default.ok(id.startsWith("task-"));
+            assert_1.default.ok(id_generator_1.TaskIDGenerator.validate(id));
+        });
+        it("should generate ID with custom prefix", () => {
+            const id = id_generator_1.TaskIDGenerator.generate("custom");
+            assert_1.default.ok(id.startsWith("custom-"));
+            assert_1.default.ok(id_generator_1.TaskIDGenerator.validate(id));
+        });
+    });
+    describe("validate", () => {
+        it("should validate timestamped format", () => {
+            assert_1.default.strictEqual(id_generator_1.TaskIDGenerator.validate("task-123456-abcdef12"), true);
+        });
+        it("should validate hierarchical format", () => {
+            assert_1.default.strictEqual(id_generator_1.TaskIDGenerator.validate("1.2.3"), true);
+        });
+        it("should reject invalid format", () => {
+            assert_1.default.strictEqual(id_generator_1.TaskIDGenerator.validate("invalid id"), false);
+        });
+    });
+    describe("Hierarchical IDs", () => {
+        it("should generate child ID", () => {
+            assert_1.default.strictEqual(id_generator_1.TaskIDGenerator.generateChildId("1", 1), "1.1");
+        });
+        it("should parse hierarchical ID", () => {
+            const result = id_generator_1.TaskIDGenerator.parseHierarchicalId("1.2.3");
+            assert_1.default.deepStrictEqual(result, { parentId: "1.2", childIndex: 3 });
+        });
+    });
+});

package/dist/test/utils/model-parser.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=model-parser.test.d.ts.map

package/dist/test/utils/model-parser.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-parser.test.d.ts","sourceRoot":"","sources":["../../../src/test/utils/model-parser.test.ts"],"names":[],"mappings":""}

package/dist/test/utils/model-parser.test.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __importDefault(require("assert"));
+const model_parser_1 = require("../../utils/model-parser");
+describe("Model Parser", () => {
+    it("should parse simple model string", () => {
+        const result = (0, model_parser_1.parseModelString)("gpt-4o");
+        assert_1.default.deepStrictEqual(result, {
+            provider: undefined,
+            model: "gpt-4o",
+            reasoning: undefined,
+        });
+    });
+    it("should parse provider and model", () => {
+        const result = (0, model_parser_1.parseModelString)("openai:gpt-4o");
+        assert_1.default.deepStrictEqual(result, {
+            provider: "openai",
+            model: "gpt-4o",
+            reasoning: undefined,
+        });
+    });
+    it("should parse model with reasoning default budget", () => {
+        const result = (0, model_parser_1.parseModelString)("gpt-4o;reasoning");
+        assert_1.default.deepStrictEqual(result, {
+            provider: undefined,
+            model: "gpt-4o",
+            reasoning: "2000",
+        });
+    });
+    it("should parse model with explicit reasoning budget", () => {
+        const result = (0, model_parser_1.parseModelString)("gpt-4o;reasoning=5000");
+        assert_1.default.deepStrictEqual(result, {
+            provider: undefined,
+            model: "gpt-4o",
+            reasoning: "5000",
+        });
+    });
+    it("should parse provider, model, and reasoning", () => {
+        const result = (0, model_parser_1.parseModelString)("anthropic:claude-3-5-sonnet;reasoning=1000");
+        assert_1.default.deepStrictEqual(result, {
+            provider: "anthropic",
+            model: "claude-3-5-sonnet",
+            reasoning: "1000",
+        });
+    });
+    it("should treat unknown provider as part of model name", () => {
+        const result = (0, model_parser_1.parseModelString)("unknown:model");
+        assert_1.default.deepStrictEqual(result, {
+            provider: undefined,
+            model: "unknown:model",
+            reasoning: undefined,
+        });
+    });
+    it("should handle complex model names", () => {
+        const result = (0, model_parser_1.parseModelString)("google/gemini-pro-1.5");
+        assert_1.default.deepStrictEqual(result, {
+            provider: undefined,
+            model: "google/gemini-pro-1.5",
+            reasoning: undefined,
+        });
+    });
+});

package/dist/test/validation.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=validation.test.d.ts.map

package/dist/test/validation.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.test.d.ts","sourceRoot":"","sources":["../../src/test/validation.test.ts"],"names":[],"mappings":""}

package/dist/test/validation.test.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __importDefault(require("assert"));
+const validation_1 = require("../lib/validation");
+describe("Validation Utils", () => {
+    describe("isValidAIProvider", () => {
+        it("should return true for valid providers", () => {
+            assert_1.default.strictEqual((0, validation_1.isValidAIProvider)("openrouter"), true);
+            assert_1.default.strictEqual((0, validation_1.isValidAIProvider)("openai"), true);
+            assert_1.default.strictEqual((0, validation_1.isValidAIProvider)("anthropic"), true);
+            assert_1.default.strictEqual((0, validation_1.isValidAIProvider)("custom"), true);
+        });
+        it("should return false for invalid providers", () => {
+            assert_1.default.strictEqual((0, validation_1.isValidAIProvider)("invalid"), false);
+            assert_1.default.strictEqual((0, validation_1.isValidAIProvider)(""), false);
+            assert_1.default.strictEqual((0, validation_1.isValidAIProvider)("gpt-4"), false);
+        });
+    });
+});

package/dist/types/callbacks.d.ts

@@ -0,0 +1,30 @@
+export type ProgressEvent = {
+    type: "started";
+    message: string;
+} | {
+    type: "progress";
+    message: string;
+    current?: number;
+    total?: number;
+} | {
+    type: "stream-chunk";
+    text: string;
+} | {
+    type: "reasoning-chunk";
+    text: string;
+} | {
+    type: "completed";
+    message: string;
+} | {
+    type: "info";
+    message: string;
+} | {
+    type: "warning";
+    message: string;
+};
+export interface ProgressCallback {
+    onProgress?: (event: ProgressEvent) => void;
+    onComplete?: (result: any) => void;
+    onError?: (error: Error) => void;
+}
+//# sourceMappingURL=callbacks.d.ts.map

package/dist/types/callbacks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"callbacks.d.ts","sourceRoot":"","sources":["../../src/types/callbacks.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,aAAa,GACrB;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACpC;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GACvE;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACtC;IAAE,IAAI,EAAE,iBAAiB,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACzC;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACtC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACjC;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAEzC,MAAM,WAAW,gBAAgB;IAC/B,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAC;IAC5C,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,IAAI,CAAC;IACnC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;CAClC"}

package/dist/types/callbacks.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });