@doist/todoist-api-typescript 5.9.0 → 6.0.0

package/dist/{types → cjs/types}/entities.js

@@ -1,15 +1,4 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 var __rest = (this && this.__rest) || function (s, e) {
     var t = {};
     for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
@@ -23,8 +12,8 @@ var __rest = (this && this.__rest) || function (s, e) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JoinWorkspaceResultSchema = exports.WorkspacePlanDetailsSchema = exports.FormattedPriceListingSchema = exports.PlanPriceSchema = exports.WorkspaceInvitationSchema = exports.WorkspaceUserSchema = exports.WorkspaceRoleSchema = exports.WORKSPACE_ROLES = exports.ActivityEventSchema = exports.ActivityEventExtraDataSchema = exports.ColorSchema = exports.ProductivityStatsSchema = exports.CurrentUserSchema = exports.TimezoneInfoSchema = exports.UserSchema = exports.CommentSchema = exports.RawCommentSchema = exports.AttachmentSchema = exports.LabelSchema = exports.SectionSchema = exports.WorkspaceProjectSchema = exports.PersonalProjectSchema = exports.BaseProjectSchema = exports.TaskSchema = exports.DeadlineSchema = exports.DurationSchema = exports.DueDateSchema = void 0;
-var zod_1 = require("zod");
-var url_helpers_1 = require("../utils/url-helpers");
+const zod_1 = require("zod");
+const url_helpers_1 = require("../utils/url-helpers");
 exports.DueDateSchema = zod_1.z
     .object({
     isRecurring: zod_1.z.boolean(),
@@ -71,8 +60,8 @@ exports.TaskSchema = zod_1.z
     dayOrder: zod_1.z.number().int(),
     isCollapsed: zod_1.z.boolean(),
 })
-    .transform(function (data) {
-    return __assign(__assign({}, data), { url: (0, url_helpers_1.getTaskUrl)(data.id, data.content) });
+    .transform((data) => {
+    return Object.assign(Object.assign({}, data), { url: (0, url_helpers_1.getTaskUrl)(data.id, data.content) });
 });
 /**
  * Base schema for all project types in Todoist.
@@ -102,8 +91,8 @@ exports.BaseProjectSchema = zod_1.z.object({
 exports.PersonalProjectSchema = exports.BaseProjectSchema.extend({
     parentId: zod_1.z.string().nullable(),
     inboxProject: zod_1.z.boolean().optional().default(false),
-}).transform(function (data) {
-    return __assign(__assign({}, data), { url: (0, url_helpers_1.getProjectUrl)(data.id, data.name) });
+}).transform((data) => {
+    return Object.assign(Object.assign({}, data), { url: (0, url_helpers_1.getProjectUrl)(data.id, data.name) });
 });
 /**
  * Schema for workspace projects in Todoist.
@@ -116,8 +105,8 @@ exports.WorkspaceProjectSchema = exports.BaseProjectSchema.extend({
     role: zod_1.z.string().nullable(),
     status: zod_1.z.string(),
     workspaceId: zod_1.z.string(),
-}).transform(function (data) {
-    return __assign(__assign({}, data), { url: (0, url_helpers_1.getProjectUrl)(data.id, data.name) });
+}).transform((data) => {
+    return Object.assign(Object.assign({}, data), { url: (0, url_helpers_1.getProjectUrl)(data.id, data.name) });
 });
 exports.SectionSchema = zod_1.z
     .object({
@@ -133,8 +122,8 @@ exports.SectionSchema = zod_1.z
     isDeleted: zod_1.z.boolean(),
     isCollapsed: zod_1.z.boolean(),
 })
-    .transform(function (data) {
-    return __assign(__assign({}, data), { url: (0, url_helpers_1.getSectionUrl)(data.id, data.name) });
+    .transform((data) => {
+    return Object.assign(Object.assign({}, data), { url: (0, url_helpers_1.getSectionUrl)(data.id, data.name) });
 });
 exports.LabelSchema = zod_1.z.object({
     id: zod_1.z.string(),
@@ -173,16 +162,16 @@ exports.RawCommentSchema = zod_1.z
     reactions: zod_1.z.record(zod_1.z.string(), zod_1.z.array(zod_1.z.string())).nullable(),
     isDeleted: zod_1.z.boolean(),
 })
-    .refine(function (data) {
+    .refine((data) => {
     // At least one of itemId or projectId must be present
     return ((data.itemId !== undefined && data.projectId === undefined) ||
         (data.itemId === undefined && data.projectId !== undefined));
 }, {
     message: 'Exactly one of itemId or projectId must be provided',
 });
-exports.CommentSchema = exports.RawCommentSchema.transform(function (data) {
-    var itemId = data.itemId, rest = __rest(data, ["itemId"]);
-    return __assign(__assign({}, rest), { 
+exports.CommentSchema = exports.RawCommentSchema.transform((data) => {
+    const { itemId } = data, rest = __rest(data, ["itemId"]);
+    return Object.assign(Object.assign({}, rest), { 
         // Map itemId to taskId for backwards compatibility
         taskId: itemId });
 });
@@ -225,20 +214,20 @@ exports.CurrentUserSchema = zod_1.z.object({
     daysOff: zod_1.z.array(zod_1.z.number().int()),
     weekendStartDay: zod_1.z.number().int(),
 });
-var StreakSchema = zod_1.z.object({
+const StreakSchema = zod_1.z.object({
     count: zod_1.z.number(),
     start: zod_1.z.string(),
     end: zod_1.z.string(),
 });
-var CompletedItemSchema = zod_1.z.object({
+const CompletedItemSchema = zod_1.z.object({
     id: zod_1.z.string(),
     completed: zod_1.z.number(),
 });
-var ItemsWithDateSchema = zod_1.z.object({
+const ItemsWithDateSchema = zod_1.z.object({
     items: zod_1.z.array(CompletedItemSchema),
     totalCompleted: zod_1.z.number(),
 });
-var KarmaUpdateSchema = zod_1.z.object({
+const KarmaUpdateSchema = zod_1.z.object({
     time: zod_1.z.string(),
     newKarma: zod_1.z.number(),
     positiveKarma: zod_1.z.number(),
@@ -312,7 +301,7 @@ exports.ActivityEventSchema = zod_1.z
     eventDate: zod_1.z.string(),
     id: zod_1.z
         .union([zod_1.z.string(), zod_1.z.number()])
-        .transform(function (val) { var _a; return (_a = val === null || val === void 0 ? void 0 : val.toString()) !== null && _a !== void 0 ? _a : null; })
+        .transform((val) => { var _a; return (_a = val === null || val === void 0 ? void 0 : val.toString()) !== null && _a !== void 0 ? _a : null; })
         .nullable(),
     parentProjectId: zod_1.z.string().nullable(),
     parentItemId: zod_1.z.string().nullable(),

package/dist/cjs/types/errors.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TodoistRequestError = void 0;
+const ts_custom_error_1 = require("ts-custom-error");
+const authenticationErrorCodes = [401, 403];
+class TodoistRequestError extends ts_custom_error_1.CustomError {
+    // eslint-disable-next-line max-params
+    constructor(message, httpStatusCode, responseData) {
+        super(message);
+        this.message = message;
+        this.httpStatusCode = httpStatusCode;
+        this.responseData = responseData;
+        this.isAuthenticationError = () => {
+            if (!this.httpStatusCode) {
+                return false;
+            }
+            return authenticationErrorCodes.includes(this.httpStatusCode);
+        };
+        Object.defineProperty(this, 'name', { value: 'TodoistRequestError' });
+    }
+}
+exports.TodoistRequestError = TodoistRequestError;

package/dist/cjs/types/http.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNetworkError = isNetworkError;
+exports.isHttpError = isHttpError;
+/**
+ * Type guard to check if an error is a network error
+ */
+function isNetworkError(error) {
+    // Network errors in fetch are typically TypeError with specific messages
+    return ((error instanceof TypeError &&
+        (error.message.includes('fetch') ||
+            error.message.includes('network') ||
+            error.message.includes('Failed to fetch') ||
+            error.message.includes('NetworkError'))) ||
+        error.isNetworkError === true);
+}
+/**
+ * Type guard to check if an error is an HTTP error
+ */
+function isHttpError(error) {
+    return 'status' in error && typeof error.status === 'number';
+}

package/dist/cjs/utils/case-conversion.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.customCamelCase = customCamelCase;
+exports.camelCaseKeys = camelCaseKeys;
+exports.snakeCaseKeys = snakeCaseKeys;
+const camelcase_1 = __importDefault(require("camelcase"));
+const emoji_regex_1 = __importDefault(require("emoji-regex"));
+/**
+ * Checks if a string is a solitary emoji
+ */
+function isEmojiKey(input) {
+    const regex = (0, emoji_regex_1.default)();
+    const match = input.match(regex);
+    return match !== null && match.join('') === input;
+}
+/**
+ * Custom camelCase function that preserves emoji strings
+ */
+function customCamelCase(input) {
+    // If the value is a solitary emoji string, return the key as-is
+    if (isEmojiKey(input)) {
+        return input;
+    }
+    return (0, camelcase_1.default)(input);
+}
+/**
+ * Converts object keys from snake_case to camelCase recursively
+ */
+function camelCaseKeys(obj) {
+    if (obj === null || obj === undefined) {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map((item) => camelCaseKeys(item));
+    }
+    if (typeof obj === 'object' && obj.constructor === Object) {
+        const converted = {};
+        for (const [key, value] of Object.entries(obj)) {
+            const camelKey = customCamelCase(key);
+            converted[camelKey] = camelCaseKeys(value);
+        }
+        return converted;
+    }
+    return obj;
+}
+/**
+ * Converts object keys from camelCase to snake_case recursively
+ */
+function snakeCaseKeys(obj) {
+    if (obj === null || obj === undefined) {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map((item) => snakeCaseKeys(item));
+    }
+    if (typeof obj === 'object' && obj.constructor === Object) {
+        const converted = {};
+        for (const [key, value] of Object.entries(obj)) {
+            // Convert camelCase to snake_case
+            const snakeKey = key.replace(/([A-Z])/g, '_$1').toLowerCase();
+            converted[snakeKey] = snakeCaseKeys(value);
+        }
+        return converted;
+    }
+    return obj;
+}

package/dist/{utils → cjs/utils}/colors.js

@@ -192,7 +192,7 @@ exports.defaultColor = exports.charcoal;
  * @deprecated Use {@link getColorByKey} instead
  */
 function getColorById(colorId) {
-    var color = exports.colors.find(function (color) { return color.id === colorId; });
+    const color = exports.colors.find((color) => color.id === colorId);
     return color !== null && color !== void 0 ? color : exports.defaultColor;
 }
 /**
@@ -200,7 +200,7 @@ function getColorById(colorId) {
  * @deprecated Use {@link getColorByKey} instead
  */
 function getColorByName(colorName) {
-    var color = exports.colors.find(function (color) { return color.name === colorName; });
+    const color = exports.colors.find((color) => color.name === colorName);
     return color !== null && color !== void 0 ? color : exports.defaultColor;
 }
 /**
@@ -216,6 +216,6 @@ function getColorByName(colorName) {
  * ```
  */
 function getColorByKey(colorKey) {
-    var color = exports.colors.find(function (color) { return color.key === colorKey; });
+    const color = exports.colors.find((color) => color.key === colorKey);
     return color !== null && color !== void 0 ? color : exports.defaultColor;
 }

package/dist/cjs/utils/fetch-with-retry.js

@@ -0,0 +1,150 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchWithRetry = fetchWithRetry;
+const http_1 = require("../types/http");
+/**
+ * Default retry configuration matching the original axios-retry behavior
+ */
+const DEFAULT_RETRY_CONFIG = {
+    retries: 3,
+    retryCondition: http_1.isNetworkError,
+    retryDelay: (retryNumber) => {
+        // First retry: immediate (0ms delay)
+        // Subsequent retries: 500ms delay
+        return retryNumber === 1 ? 0 : 500;
+    },
+};
+/**
+ * Converts Headers object to a plain object
+ */
+function headersToObject(headers) {
+    const result = {};
+    headers.forEach((value, key) => {
+        result[key] = value;
+    });
+    return result;
+}
+/**
+ * Creates an AbortSignal that times out after the specified duration
+ */
+function createTimeoutSignal(timeoutMs, existingSignal) {
+    const controller = new AbortController();
+    // Timeout logic
+    const timeoutId = setTimeout(() => {
+        controller.abort(new Error(`Request timeout after ${timeoutMs}ms`));
+    }, timeoutMs);
+    // If there's an existing signal, forward its abort
+    if (existingSignal) {
+        if (existingSignal.aborted) {
+            clearTimeout(timeoutId);
+            controller.abort(existingSignal.reason);
+        }
+        else {
+            existingSignal.addEventListener('abort', () => {
+                clearTimeout(timeoutId);
+                controller.abort(existingSignal.reason);
+            }, { once: true });
+        }
+    }
+    // Clean up timeout when request completes
+    controller.signal.addEventListener('abort', () => {
+        clearTimeout(timeoutId);
+    });
+    return controller.signal;
+}
+/**
+ * Performs a fetch request with retry logic and timeout support
+ */
+async function fetchWithRetry(args) {
+    const { url, options = {}, retryConfig = {} } = args;
+    const config = Object.assign(Object.assign({}, DEFAULT_RETRY_CONFIG), retryConfig);
+    const { timeout, signal: userSignal } = options, fetchOptions = __rest(options, ["timeout", "signal"]);
+    let lastError;
+    for (let attempt = 0; attempt <= config.retries; attempt++) {
+        try {
+            // Set up timeout and signal handling
+            let requestSignal = userSignal || undefined;
+            if (timeout && timeout > 0) {
+                requestSignal = createTimeoutSignal(timeout, requestSignal);
+            }
+            const response = await fetch(url, Object.assign(Object.assign({}, fetchOptions), { signal: requestSignal }));
+            // Check if the response is successful
+            if (!response.ok) {
+                const errorMessage = `HTTP ${response.status}: ${response.statusText}`;
+                const error = new Error(errorMessage);
+                error.status = response.status;
+                error.statusText = response.statusText;
+                error.response = {
+                    data: undefined, // Will be set below if we can parse the response
+                    status: response.status,
+                    statusText: response.statusText,
+                    headers: headersToObject(response.headers),
+                };
+                // Try to get response body for error details
+                try {
+                    const responseText = await response.text();
+                    let responseData;
+                    try {
+                        responseData = responseText ? JSON.parse(responseText) : undefined;
+                    }
+                    catch (_a) {
+                        responseData = responseText;
+                    }
+                    error.data = responseData;
+                    error.response.data = responseData;
+                }
+                catch (_b) {
+                    // If we can't read the response body, that's OK
+                }
+                throw error;
+            }
+            // Parse response
+            const responseText = await response.text();
+            let data;
+            try {
+                data = responseText ? JSON.parse(responseText) : undefined;
+            }
+            catch (_c) {
+                // If JSON parsing fails, return the raw text
+                data = responseText;
+            }
+            return {
+                data,
+                status: response.status,
+                statusText: response.statusText,
+                headers: headersToObject(response.headers),
+            };
+        }
+        catch (error) {
+            lastError = error;
+            // Check if this error should trigger a retry
+            const shouldRetry = attempt < config.retries && config.retryCondition(lastError);
+            if (!shouldRetry) {
+                // Add network error flag for network errors
+                if ((0, http_1.isNetworkError)(lastError)) {
+                    const networkError = lastError;
+                    networkError.isNetworkError = true;
+                }
+                throw lastError;
+            }
+            // Wait before retrying
+            const delay = config.retryDelay(attempt + 1);
+            if (delay > 0) {
+                await new Promise((resolve) => setTimeout(resolve, delay));
+            }
+        }
+    }
+    // This should never be reached, but just in case
+    throw lastError || new Error('Request failed after retries');
+}

package/dist/cjs/utils/multipart-upload.js

@@ -0,0 +1,126 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadMultipartFile = uploadMultipartFile;
+const form_data_1 = __importDefault(require("form-data"));
+const fs_1 = require("fs");
+const path_1 = require("path");
+const fetch_with_retry_1 = require("./fetch-with-retry");
+/**
+ * Helper function to determine content-type from filename extension.
+ * @param fileName - The filename to analyze
+ * @returns The appropriate MIME type
+ */
+function getContentTypeFromFileName(fileName) {
+    const extension = fileName.toLowerCase().split('.').pop();
+    switch (extension) {
+        case 'png':
+            return 'image/png';
+        case 'jpg':
+        case 'jpeg':
+            return 'image/jpeg';
+        case 'gif':
+            return 'image/gif';
+        case 'webp':
+            return 'image/webp';
+        case 'svg':
+            return 'image/svg+xml';
+        default:
+            return 'application/octet-stream';
+    }
+}
+/**
+ * Uploads a file using multipart/form-data.
+ *
+ * This is a shared utility for uploading files to Todoist endpoints that require
+ * multipart/form-data content type (e.g., file uploads, workspace logo uploads).
+ *
+ * @param baseUrl - The base API URL (e.g., https://api.todoist.com/api/v1/)
+ * @param authToken - The authentication token
+ * @param endpoint - The relative endpoint path (e.g., 'uploads', 'workspaces/logo')
+ * @param file - The file content (Buffer, ReadableStream, or file system path)
+ * @param fileName - Optional file name (required for Buffer/Stream, optional for paths)
+ * @param additionalFields - Additional form fields to include (e.g., project_id, workspace_id)
+ * @param requestId - Optional request ID for idempotency
+ * @returns The response data from the server
+ *
+ * @example
+ * ```typescript
+ * // Upload from a file path
+ * const result = await uploadMultipartFile(
+ *   'https://api.todoist.com/api/v1/',
+ *   'my-token',
+ *   'uploads',
+ *   '/path/to/file.pdf',
+ *   undefined,
+ *   { project_id: '12345' }
+ * )
+ *
+ * // Upload from a Buffer
+ * const buffer = Buffer.from('file content')
+ * const result = await uploadMultipartFile(
+ *   'https://api.todoist.com/api/v1/',
+ *   'my-token',
+ *   'uploads',
+ *   buffer,
+ *   'document.pdf',
+ *   { project_id: '12345' }
+ * )
+ * ```
+ */
+async function uploadMultipartFile(args) {
+    const { baseUrl, authToken, endpoint, file, fileName, additionalFields, requestId } = args;
+    const form = new form_data_1.default();
+    // Determine file type and add to form data
+    if (typeof file === 'string') {
+        // File path - create read stream
+        const filePath = file;
+        const resolvedFileName = fileName || (0, path_1.basename)(filePath);
+        form.append('file', (0, fs_1.createReadStream)(filePath), resolvedFileName);
+    }
+    else if (Buffer.isBuffer(file)) {
+        // Buffer - require fileName
+        if (!fileName) {
+            throw new Error('fileName is required when uploading from a Buffer');
+        }
+        // Detect content-type from filename extension
+        const contentType = getContentTypeFromFileName(fileName);
+        form.append('file', file, {
+            filename: fileName,
+            contentType: contentType,
+        });
+    }
+    else {
+        // Stream - require fileName
+        if (!fileName) {
+            throw new Error('fileName is required when uploading from a stream');
+        }
+        form.append('file', file, fileName);
+    }
+    // Add additional fields to the form
+    for (const [key, value] of Object.entries(additionalFields)) {
+        if (value !== undefined && value !== null) {
+            form.append(key, value.toString());
+        }
+    }
+    // Build the full URL
+    const url = `${baseUrl}${endpoint}`;
+    // Prepare headers
+    const headers = Object.assign({ Authorization: `Bearer ${authToken}` }, form.getHeaders());
+    if (requestId) {
+        headers['X-Request-Id'] = requestId;
+    }
+    // Make the request using fetch
+    const response = await (0, fetch_with_retry_1.fetchWithRetry)({
+        url,
+        options: {
+            method: 'POST',
+            body: form, // FormData from 'form-data' package is compatible with fetch
+            headers,
+            timeout: 30000, // 30 second timeout for file uploads
+        },
+    });
+    return response.data;
+}

package/dist/{utils → cjs/utils}/processing-helpers.js

@@ -4,10 +4,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.customCamelCase = customCamelCase;
-var camelcase_1 = __importDefault(require("camelcase"));
-var emoji_regex_1 = __importDefault(require("emoji-regex"));
+const camelcase_1 = __importDefault(require("camelcase"));
+const emoji_regex_1 = __importDefault(require("emoji-regex"));
 function isEmojiKey(key) {
-    var regex = (0, emoji_regex_1.default)();
+    const regex = (0, emoji_regex_1.default)();
     return regex.test(key);
 }
 function customCamelCase(input) {

package/dist/{utils → cjs/utils}/sanitization.js

@@ -1,36 +1,25 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSanitizedContent = getSanitizedContent;
 exports.getSanitizedTasks = getSanitizedTasks;
-var BOLD_FORMAT = /(^|[\s!?,;>:]+)(?:\*\*|__|!!)(.+?)(\*\*|__|!!)(?=$|[\s!?,;><:]+)/gi;
-var ITALIC_FORMAT = /(^|[\s!?,;>:]+)(?:\*|_|!)(.+?)(\*|_|!)(?=$|[\s!?,;><:]+)/gi;
-var BOLD_ITALIC_FORMAT = /(^|[\s!?,;>:]+)(?:\*\*\*|___|!!!)(.+?)(\*\*\*|___|!!!)(?=$|[\s!?,;><:]+)/gi;
-var CODE_BLOCK_FORMAT = /```([\s\S]*?)```/gi;
-var CODE_INLINE_FORMAT = /`([^`]+)`/gi;
-var TODOIST_LINK = /((?:(?:onenote:)?[\w-]+):\/\/[^\s]+)\s+[[(]([^)]+)[\])]/gi;
-var MARKDOWN_LINK = /\[(.+?)\]\((.+?)\)/gi;
-var GMAIL_LINK = /\[\[gmail=(.+?),\s*(.+?)\]\]/gi;
-var OUTLOOK_LINK = /\[\[outlook=(.+?),\s*(.+?)\]\]/gi;
-var THUNDERBIRD_LINK = /\[\[thunderbird\n(.+)\n(.+)\n\s*\]\]/gi;
-var FAKE_SECTION_PREFIX = '* ';
-var FAKE_SECTION_SUFFIX = ':';
+const BOLD_FORMAT = /(^|[\s!?,;>:]+)(?:\*\*|__|!!)(.+?)(\*\*|__|!!)(?=$|[\s!?,;><:]+)/gi;
+const ITALIC_FORMAT = /(^|[\s!?,;>:]+)(?:\*|_|!)(.+?)(\*|_|!)(?=$|[\s!?,;><:]+)/gi;
+const BOLD_ITALIC_FORMAT = /(^|[\s!?,;>:]+)(?:\*\*\*|___|!!!)(.+?)(\*\*\*|___|!!!)(?=$|[\s!?,;><:]+)/gi;
+const CODE_BLOCK_FORMAT = /```([\s\S]*?)```/gi;
+const CODE_INLINE_FORMAT = /`([^`]+)`/gi;
+const TODOIST_LINK = /((?:(?:onenote:)?[\w-]+):\/\/[^\s]+)\s+[[(]([^)]+)[\])]/gi;
+const MARKDOWN_LINK = /\[(.+?)\]\((.+?)\)/gi;
+const GMAIL_LINK = /\[\[gmail=(.+?),\s*(.+?)\]\]/gi;
+const OUTLOOK_LINK = /\[\[outlook=(.+?),\s*(.+?)\]\]/gi;
+const THUNDERBIRD_LINK = /\[\[thunderbird\n(.+)\n(.+)\n\s*\]\]/gi;
+const FAKE_SECTION_PREFIX = '* ';
+const FAKE_SECTION_SUFFIX = ':';
 function removeStyleFormatting(input) {
     if (!input.includes('!') && !input.includes('*') && !input.includes('_')) {
         return input;
     }
     function removeMarkdown(match, prefix, text) {
-        return "".concat(prefix).concat(text);
+        return `${prefix}${text}`;
     }
     input = input.replace(BOLD_ITALIC_FORMAT, removeMarkdown);
     input = input.replace(BOLD_FORMAT, removeMarkdown);
@@ -74,13 +63,13 @@ function removeTodoistLinks(input) {
 }
 function removeAppLinks(input) {
     if (input.includes('gmail')) {
-        input = input.replace(GMAIL_LINK, function (match, id, text) { return text; });
+        input = input.replace(GMAIL_LINK, (match, id, text) => text);
     }
     if (input.includes('outlook')) {
-        input = input.replace(OUTLOOK_LINK, function (match, id, text) { return text; });
+        input = input.replace(OUTLOOK_LINK, (match, id, text) => text);
     }
     if (input.includes('thunderbird')) {
-        input = input.replace(THUNDERBIRD_LINK, function (match, text) { return text; });
+        input = input.replace(THUNDERBIRD_LINK, (match, text) => text);
     }
     return input;
 }
@@ -123,5 +112,5 @@ function getSanitizedContent(input) {
  * @returns Array of tasks with added sanitizedContent property
  */
 function getSanitizedTasks(tasks) {
-    return tasks.map(function (task) { return (__assign(__assign({}, task), { sanitizedContent: getSanitizedContent(task.content) })); });
+    return tasks.map((task) => (Object.assign(Object.assign({}, task), { sanitizedContent: getSanitizedContent(task.content) })));
 }