joplin-plugin-my-calendar 1.2.3

package/dist/index.js

@@ -0,0 +1,3327 @@
+if (typeof module === 'undefined') { var module = { exports: {} }; }
+if (typeof exports === 'undefined') { var exports = module.exports; }
+
+/******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ({
+
+/***/ "./src/index.ts"
+/*!**********************!*\
+  !*** ./src/index.ts ***!
+  \**********************/
+(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+
+// src/index.ts
+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());
+    });
+};
+// NOT ONE import/require('api').
+// Only take API from a global object that plays Joplin Runner.
+(function bootstrap() {
+    const j = globalThis.joplin || window.joplin;
+    if (!j) {
+        // We are not in the plugin-wounder (or Runner have not yet thrown Joplin)-we do nothing.
+        console.log('[MyCalendar] no plugin API here (renderer).');
+        return;
+    }
+    try {
+        // IMPORTANT: REQUIRE PLUGINMAIN only after we've been convinced that there was a joplin.
+        // This way webpack will not overload the addiction earlier (and will not break RENDER).
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const runPlugin = (__webpack_require__(/*! ./main/pluginMain */ "./src/main/pluginMain.ts")["default"]);
+        j.plugins.register({
+            onStart: () => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    console.log('[MyCalendar] onStart (runner)');
+                    yield runPlugin(j);
+                }
+                catch (e) {
+                    console.error('[MyCalendar] onStart error (caught):', e);
+                }
+            }),
+        });
+    }
+    catch (e) {
+        console.error('[MyCalendar] failed to start plugin', e);
+    }
+})();
+
+
+/***/ },
+
+/***/ "./src/main/parsers/eventParser.ts"
+/*!*****************************************!*\
+  !*** ./src/main/parsers/eventParser.ts ***!
+  \*****************************************/
+(__unused_webpack_module, exports) {
+
+
+// src/main/parsers/eventParser.ts
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.parseEventsFromBody = parseEventsFromBody;
+const EVENT_BLOCK_RE = /(?:^|\r?\n)[ \t]*```mycalendar-event[ \t]*\r?\n([\s\S]*?)\r?\n[ \t]*```(?=\r?\n|$)/g;
+const DAY_MS = 24 * 60 * 60 * 1000;
+// Map: MO..SU -> 0..6 (Mon..Sun)
+const WD_MAP = { MO: 0, TU: 1, WE: 2, TH: 3, FR: 4, SA: 5, SU: 6 };
+function parseKeyVal(line) {
+    const m = line.match(/^\s*([a-zA-Z_]+)\s*:\s*(.+)\s*$/);
+    return m ? [m[1].toLowerCase(), m[2]] : null;
+}
+function parseByWeekdays(v) {
+    const arr = v.split(',').map(s => s.trim().toUpperCase()).filter(Boolean);
+    const out = [];
+    for (const t of arr)
+        if (t in WD_MAP)
+            out.push(WD_MAP[t]);
+    return out.length ? out : undefined;
+}
+function parseIntSafe(v) {
+    const n = v ? parseInt(v, 10) : NaN;
+    return Number.isFinite(n) && n >= 1 ? n : undefined;
+}
+function parseByMonthDay(v) {
+    const n = parseInt(v, 10);
+    return Number.isFinite(n) && n >= 1 && n <= 31 ? n : undefined;
+}
+function parseAllDayBool(v) {
+    const vv = v.trim().toLowerCase();
+    if (vv === 'true' || vv === '1' || vv === 'yes')
+        return true;
+    if (vv === 'false' || vv === '0' || vv === 'no')
+        return false;
+    return undefined;
+}
+function normalizeTz(z) {
+    if (!z)
+        return undefined;
+    const tz = z.trim();
+    if (!tz)
+        return undefined;
+    try {
+        // If the timezone is not IANA, Intl will throw RangeError
+        new Intl.DateTimeFormat('en-US', { timeZone: tz }).format(new Date());
+        return tz;
+    }
+    catch (_a) {
+        return undefined;
+    }
+}
+// "2025-08-12 10:00:00-04:00" | "2025-08-12T10:00:00-04:00" | Without offset (з tz)
+function parseDateTimeToUTC(text, tz) {
+    var _a;
+    const trimmed = text.trim();
+    if (!trimmed)
+        return null;
+    // Explicit offset or Z -> trust Date parsing (absolute moment)
+    if (/[+-]\d{2}:?\d{2}$/.test(trimmed) || /Z$/i.test(trimmed)) {
+        const canon = trimmed
+            .replace(' ', 'T')
+            .replace(/([+-]\d{2})(\d{2})$/, '$1:$2'); // +0300 -> +03:00
+        const d = new Date(canon);
+        return isNaN(d.getTime()) ? null : d.getTime();
+    }
+    // No offset: parse wall-clock components
+    const m = trimmed.match(/^([0-9]{4})-([0-9]{2})-([0-9]{2})[ T]([0-9]{2}):([0-9]{2})(?::([0-9]{2}))?$/);
+    if (!m) {
+        const d = new Date(trimmed.replace(' ', 'T'));
+        return isNaN(d.getTime()) ? null : d.getTime();
+    }
+    const y = Number(m[1]);
+    const mo = Number(m[2]);
+    const da = Number(m[3]);
+    const hh = Number(m[4]);
+    const mi = Number(m[5]);
+    const ss = Number((_a = m[6]) !== null && _a !== void 0 ? _a : '0');
+    // If tz is given but is invalid - DO NOT try to convert, return null (and the event will be skipped)
+    const safeTz = normalizeTz(tz);
+    // If tz is not provided -> interpret as device-local time (no conversion)
+    if (!safeTz) {
+        if (tz && tz.trim())
+            return null;
+        const d = new Date(`${m[1]}-${m[2]}-${m[3]}T${m[4]}:${m[5]}:${String(ss).padStart(2, '0')}`);
+        return isNaN(d.getTime()) ? null : d.getTime();
+    }
+    // tz provided without offset: interpret components as wall-clock time in that tz, then convert to UTC
+    const wallUtc = Date.UTC(y, mo - 1, da, hh, mi, ss);
+    const tzOffsetMs = (utcTs, zone) => {
+        try {
+            const fmt = new Intl.DateTimeFormat('en-US', {
+                timeZone: zone,
+                year: 'numeric',
+                month: '2-digit',
+                day: '2-digit',
+                hour: '2-digit',
+                minute: '2-digit',
+                second: '2-digit',
+                hour12: false,
+            });
+            const parts = fmt.formatToParts(new Date(utcTs)).reduce((a, p) => {
+                if (p.type !== 'literal')
+                    a[p.type] = p.value;
+                return a;
+            }, {});
+            const yy = Number(parts.year);
+            const mm = Number(parts.month) - 1;
+            const dd = Number(parts.day);
+            const h2 = Number(parts.hour);
+            const m2 = Number(parts.minute);
+            const s2 = Number(parts.second);
+            const asUtc = Date.UTC(yy, mm, dd, h2, m2, s2);
+            return asUtc - utcTs;
+        }
+        catch (_a) {
+            return null;
+        }
+    };
+    const off1 = tzOffsetMs(wallUtc, safeTz);
+    if (off1 == null)
+        return null;
+    let utc = wallUtc - off1;
+    const off2 = tzOffsetMs(utc, safeTz);
+    if (off2 == null)
+        return null;
+    // second-pass for DST boundary correctness
+    if (off2 !== off1)
+        utc = wallUtc - off2;
+    return utc;
+}
+function parseRepeatFreq(v) {
+    const vv = v.trim().toLowerCase();
+    if (vv === 'daily' || vv === 'weekly' || vv === 'monthly' || vv === 'yearly' || vv === 'none')
+        return vv;
+    return undefined;
+}
+function parseEventsFromBody(noteId, titleFallback, body) {
+    var _a, _b, _c, _d, _e;
+    const out = [];
+    let m;
+    // Defensive: avoid leaking RegExp.lastIndex across calls (EVENT_BLOCK_RE is /g)
+    EVENT_BLOCK_RE.lastIndex = 0;
+    while ((m = EVENT_BLOCK_RE.exec(body)) !== null) {
+        // IMPORTANT: reset per block (do not leak across blocks)
+        const block = m[1];
+        const lines = block.split('\n').map(l => l.trim()).filter(Boolean);
+        const fields = {};
+        for (const line of lines) {
+            const kv = parseKeyVal(line);
+            if (!kv)
+                continue;
+            const [k, v] = kv;
+            // store raw string values; interpret later (order-independent)
+            fields[k] = v;
+        }
+        const title = (((_a = fields.title) === null || _a === void 0 ? void 0 : _a.trim()) ? fields.title.trim() : titleFallback);
+        const description = fields.description;
+        const location = fields.location;
+        const color = fields.color;
+        const startText = fields.start;
+        const endText = fields.end;
+        const tz = (_b = fields.tz) === null || _b === void 0 ? void 0 : _b.trim();
+        const repeat = (_d = parseRepeatFreq((_c = fields.repeat) !== null && _c !== void 0 ? _c : '')) !== null && _d !== void 0 ? _d : 'none';
+        const repeatInterval = (_e = parseIntSafe(fields.repeat_interval)) !== null && _e !== void 0 ? _e : 1;
+        const byWeekdays = fields.byweekday ? parseByWeekdays(fields.byweekday) : undefined;
+        const byMonthDay = fields.bymonthday ? parseByMonthDay(fields.bymonthday) : undefined;
+        const allDay = fields.all_day ? parseAllDayBool(fields.all_day) : undefined;
+        if (!startText)
+            continue;
+        const startUtc = parseDateTimeToUTC(startText, tz);
+        if (startUtc == null)
+            continue;
+        let endUtc;
+        if (endText) {
+            const e = parseDateTimeToUTC(endText, tz);
+            if (e != null)
+                endUtc = e;
+        }
+        // repeat_until parsed AFTER tz is known (order-independent)
+        let repeatUntilUtc;
+        if (fields.repeat_until) {
+            const u = parseDateTimeToUTC(fields.repeat_until, tz);
+            if (u != null)
+                repeatUntilUtc = u;
+        }
+        if (allDay) {
+            if (endUtc != null) {
+                // ICS all-day uses exclusive end -> make it inclusive for UI
+                if (endUtc > startUtc)
+                    endUtc = endUtc - 1;
+                else
+                    endUtc = startUtc + DAY_MS - 1; // insurance
+            }
+            else {
+                // if end not provided, treat as one-day all-day
+                endUtc = startUtc + DAY_MS - 1;
+            }
+        }
+        out.push({
+            id: noteId,
+            title,
+            description,
+            location,
+            color,
+            startUtc,
+            endUtc,
+            tz,
+            startText,
+            endText,
+            repeat,
+            repeatInterval,
+            repeatUntilUtc,
+            byWeekdays,
+            byMonthDay,
+            allDay,
+        });
+    }
+    return out;
+}
+
+
+/***/ },
+
+/***/ "./src/main/parsers/icsParser.ts"
+/*!***************************************!*\
+  !*** ./src/main/parsers/icsParser.ts ***!
+  \***************************************/
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+// src/main/parsers/icsParser.ts
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.unfoldIcsLines = unfoldIcsLines;
+exports.unescapeIcsText = unescapeIcsText;
+exports.parseLineValue = parseLineValue;
+exports.normalizeRepeatFreq = normalizeRepeatFreq;
+exports.parseRRule = parseRRule;
+exports.parseMyCalKeyValueText = parseMyCalKeyValueText;
+exports.parseIcs = parseIcs;
+exports.parseImportText = parseImportText;
+const dateTimeUtils_1 = __webpack_require__(/*! ../utils/dateTimeUtils */ "./src/main/utils/dateTimeUtils.ts");
+function unfoldIcsLines(ics) {
+    const raw = ics.replace(/\r\n/g, '\n').replace(/\r/g, '\n').split('\n');
+    const out = [];
+    for (const line of raw) {
+        if (!line)
+            continue;
+        // folded line: starts with space/tab
+        if ((line.startsWith(' ') || line.startsWith('\t')) && out.length) {
+            out[out.length - 1] += line.slice(1);
+        }
+        else {
+            out.push(line);
+        }
+    }
+    return out;
+}
+function unescapeIcsText(s) {
+    // Protect escaped backslashes first, so "\\\\n" becomes literal "\n" not newline.
+    const BS = '\u0000';
+    return s
+        .replace(/\\\\/g, BS)
+        .replace(/\\n/gi, '\n')
+        .replace(/\\,/g, ',')
+        .replace(/\\;/g, ';')
+        .replace(new RegExp(BS, 'g'), '\\');
+}
+function parseLineValue(line) {
+    const i = line.indexOf(':');
+    if (i < 0)
+        return null;
+    const left = line.slice(0, i);
+    const value = line.slice(i + 1);
+    const parts = left.split(';').map(p => p.trim()).filter(Boolean);
+    const key = (parts[0] || '').toUpperCase();
+    const params = {};
+    for (let j = 1; j < parts.length; j++) {
+        const p = parts[j];
+        const eq = p.indexOf('=');
+        if (eq > 0) {
+            const k = p.slice(0, eq).toUpperCase();
+            let v = p.slice(eq + 1).trim();
+            // strip optional quotes: TZID="America/Toronto"
+            if (v.startsWith('"') && v.endsWith('"') && v.length >= 2)
+                v = v.slice(1, -1);
+            params[k] = v;
+        }
+    }
+    return { key, value, params };
+}
+function normalizeRepeatFreq(freq) {
+    if (!freq)
+        return undefined;
+    const f = freq.toLowerCase();
+    if (f === 'none')
+        return 'none';
+    if (f === 'daily' || f === 'weekly' || f === 'monthly' || f === 'yearly')
+        return f;
+    return undefined;
+}
+function hasMeaningfulEvent(ev) {
+    return !!(ev.uid ||
+        ev.title ||
+        ev.start ||
+        ev.end ||
+        ev.description ||
+        ev.location ||
+        ev.color ||
+        ev.repeat ||
+        ev.byweekday ||
+        ev.bymonthday ||
+        ev.repeat_until ||
+        (ev.valarms && ev.valarms.length));
+}
+function parseRRule(rrule) {
+    if (!rrule)
+        return {};
+    const parts = rrule.split(';').map(s => s.trim()).filter(Boolean);
+    const map = {};
+    for (const p of parts) {
+        const i = p.indexOf('=');
+        if (i > 0)
+            map[p.slice(0, i).toUpperCase()] = p.slice(i + 1);
+    }
+    const out = {};
+    const freq = normalizeRepeatFreq(map['FREQ']);
+    if (freq)
+        out.repeat = freq;
+    const interval = map['INTERVAL'] ? parseInt(map['INTERVAL'], 10) : NaN;
+    if (Number.isFinite(interval) && interval >= 1)
+        out.repeat_interval = interval;
+    // UNTIL is UTC in many feeds; keep as "+00:00" when Z
+    const until = map['UNTIL'] ? (0, dateTimeUtils_1.icsDateToMyCalText)(map['UNTIL']) : undefined;
+    if (until)
+        out.repeat_until = until;
+    if (map['BYDAY'])
+        out.byweekday = map['BYDAY'].trim();
+    if (map['BYMONTHDAY'])
+        out.bymonthday = map['BYMONTHDAY'].trim();
+    return out;
+}
+function stripInlineComment(line) {
+    const i = line.indexOf('#');
+    if (i < 0)
+        return line;
+    const before = line.slice(0, i);
+    if (/\s$/.test(before))
+        return before.trimEnd();
+    return line;
+}
+function parseMyCalKeyValueText(text) {
+    var _a;
+    const lines = text.replace(/\r\n/g, '\n').replace(/\r/g, '\n').split('\n');
+    const events = [];
+    let cur = {};
+    const flush = () => {
+        const hasAny = !!cur.uid || !!cur.title || !!cur.start || !!cur.end || !!cur.description || !!cur.location || !!cur.color ||
+            !!cur.repeat || !!cur.byweekday || !!cur.bymonthday || !!cur.repeat_until || !!(cur.valarms && cur.valarms.length);
+        if (hasAny) {
+            events.push(cur);
+            cur = {};
+        }
+    };
+    for (const raw of lines) {
+        const line0 = stripInlineComment(raw).trim();
+        if (!line0) {
+            flush();
+            continue;
+        }
+        if (line0 === '---') {
+            flush();
+            continue;
+        }
+        const m = line0.match(/^\s*([a-zA-Z_]+)\s*:\s*(.+)\s*$/);
+        if (!m)
+            continue;
+        const k = m[1].toLowerCase();
+        const v = m[2].trim();
+        if (k === 'uid')
+            cur.uid = v;
+        else if (k === 'recurrence_id')
+            cur.recurrence_id = v;
+        else if (k === 'title' || k === 'summary')
+            cur.title = v;
+        else if (k === 'description')
+            cur.description = v;
+        else if (k === 'location')
+            cur.location = v;
+        else if (k === 'color')
+            cur.color = v;
+        else if (k === 'start')
+            cur.start = v;
+        else if (k === 'end')
+            cur.end = v;
+        else if (k === 'tz')
+            cur.tz = v;
+        else if (k === 'valarm') {
+            try {
+                const obj = JSON.parse(v);
+                if (obj && typeof obj === 'object' && typeof obj.trigger === 'string') {
+                    ((_a = cur.valarms) !== null && _a !== void 0 ? _a : (cur.valarms = [])).push(obj);
+                }
+            }
+            catch (_b) {
+                // ignore
+            }
+        }
+        else if (k === 'repeat')
+            cur.repeat = normalizeRepeatFreq(v) || 'none';
+        else if (k === 'repeat_interval') {
+            const n = parseInt(v, 10);
+            if (Number.isFinite(n) && n >= 1)
+                cur.repeat_interval = n;
+        }
+        else if (k === 'repeat_until')
+            cur.repeat_until = v;
+        else if (k === 'byweekday')
+            cur.byweekday = v;
+        else if (k === 'bymonthday')
+            cur.bymonthday = v;
+    }
+    flush();
+    return events;
+}
+function parseIcs(ics) {
+    var _a;
+    const lines = unfoldIcsLines(ics);
+    const events = [];
+    let cur = null;
+    let curAlarm = null;
+    for (const line of lines) {
+        const L = line.trim();
+        if (!L)
+            continue;
+        if (L === 'BEGIN:VEVENT') {
+            cur = {};
+            curAlarm = null;
+            continue;
+        }
+        if (L === 'END:VEVENT') {
+            curAlarm = null;
+            if (cur && hasMeaningfulEvent(cur))
+                events.push(cur);
+            cur = null;
+            continue;
+        }
+        if (!cur)
+            continue;
+        if (L === 'BEGIN:VALARM') {
+            curAlarm = { trigger: '' };
+            continue;
+        }
+        if (L === 'END:VALARM') {
+            if (curAlarm && curAlarm.trigger) {
+                ((_a = cur.valarms) !== null && _a !== void 0 ? _a : (cur.valarms = [])).push(curAlarm);
+            }
+            curAlarm = null;
+            continue;
+        }
+        const parsed = parseLineValue(L);
+        if (!parsed)
+            continue;
+        const { key, value, params } = parsed;
+        if (curAlarm) {
+            if (key === 'TRIGGER') {
+                curAlarm.trigger = value.trim();
+                const rel = (params['RELATED'] || '').toUpperCase();
+                if (rel === 'START' || rel === 'END')
+                    curAlarm.related = rel;
+            }
+            else if (key === 'ACTION') {
+                curAlarm.action = value.trim();
+            }
+            else if (key === 'DESCRIPTION') {
+                curAlarm.description = unescapeIcsText(value);
+            }
+            else if (key === 'SUMMARY') {
+                curAlarm.summary = unescapeIcsText(value);
+            }
+            else if (key === 'REPEAT') {
+                const n = parseInt(value.trim(), 10);
+                if (Number.isFinite(n))
+                    curAlarm.repeat = n;
+            }
+            else if (key === 'DURATION') {
+                curAlarm.duration = value.trim();
+            }
+            continue;
+        }
+        const isDateOnly = (value, params) => (params['VALUE'] || '').toUpperCase() === 'DATE' || /^\d{8}$/.test(value.trim());
+        if (key === 'UID')
+            cur.uid = value.trim();
+        else if (key === 'SUMMARY')
+            cur.title = unescapeIcsText(value);
+        else if (key === 'DESCRIPTION')
+            cur.description = unescapeIcsText(value);
+        else if (key === 'LOCATION')
+            cur.location = unescapeIcsText(value);
+        else if (key === 'X-COLOR')
+            cur.color = value.trim();
+        else if (key === 'DTSTART') {
+            cur.start = (0, dateTimeUtils_1.icsDateToMyCalText)(value) || value.trim();
+            if (isDateOnly(value, params))
+                cur.all_day = true;
+            if (params['TZID'] && !cur.tz)
+                cur.tz = params['TZID'];
+        }
+        else if (key === 'DTEND') {
+            cur.end = (0, dateTimeUtils_1.icsDateToMyCalText)(value) || value.trim();
+            if (isDateOnly(value, params))
+                cur.all_day = true;
+            if (params['TZID'] && !cur.tz)
+                cur.tz = params['TZID'];
+        }
+        else if (key === 'RRULE') {
+            Object.assign(cur, parseRRule(value.trim()));
+        }
+        else if (key === 'RECURRENCE-ID') {
+            const ridVal = value.trim();
+            const tzid = params['TZID'];
+            const valType = (params['VALUE'] || '').toUpperCase(); // DATE / DATE-TIME
+            if (valType === 'DATE') {
+                cur.recurrence_id = `DATE:${ridVal}`;
+            }
+            else if (tzid) {
+                cur.recurrence_id = `${tzid}:${ridVal}`;
+                if (!cur.tz)
+                    cur.tz = tzid;
+            }
+            else {
+                cur.recurrence_id = ridVal;
+            }
+        }
+    }
+    return events;
+}
+function parseImportText(text) {
+    const t = text.trim();
+    if (/BEGIN:VCALENDAR/i.test(t) || /BEGIN:VEVENT/i.test(t))
+        return parseIcs(text);
+    return parseMyCalKeyValueText(text);
+}
+
+
+/***/ },
+
+/***/ "./src/main/pluginMain.ts"
+/*!********************************!*\
+  !*** ./src/main/pluginMain.ts ***!
+  \********************************/
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+// src/main/pluginMain.ts
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports["default"] = runPlugin;
+const calendarView_1 = __webpack_require__(/*! ./views/calendarView */ "./src/main/views/calendarView.ts");
+const eventsCache_1 = __webpack_require__(/*! ./services/eventsCache */ "./src/main/services/eventsCache.ts");
+const panelController_1 = __webpack_require__(/*! ./uiBridge/panelController */ "./src/main/uiBridge/panelController.ts");
+const settings_1 = __webpack_require__(/*! ./settings/settings */ "./src/main/settings/settings.ts");
+const uiSettings_1 = __webpack_require__(/*! ./uiBridge/uiSettings */ "./src/main/uiBridge/uiSettings.ts");
+const dateUtils_1 = __webpack_require__(/*! ./utils/dateUtils */ "./src/main/utils/dateUtils.ts");
+const logger_1 = __webpack_require__(/*! ./utils/logger */ "./src/main/utils/logger.ts");
+function expandOccurrencesInRange(ev, fromUtc, toUtc) {
+    var _a, _b, _c, _d, _e;
+    // Invariant: recurring events must have timezone
+    const tz = ev.tz || Intl.DateTimeFormat().resolvedOptions().timeZone;
+    if (ev.repeat !== 'none' && !ev.tz) {
+        (0, logger_1.warn)('occurrence', 'Recurring event has no timezone; using device timezone:', { tz, title: ev.title, id: ev.id });
+    }
+    const dur = ((_a = ev.endUtc) !== null && _a !== void 0 ? _a : ev.startUtc) - ev.startUtc;
+    const push = (start, out) => {
+        if (start > toUtc)
+            return false;
+        const end = dur ? start + dur : start;
+        if (end < fromUtc)
+            return true;
+        out.push(Object.assign(Object.assign({}, ev), { occurrenceId: `${ev.id}#${start}`, startUtc: start, endUtc: dur ? end : undefined }));
+        return true;
+    };
+    if (ev.repeat === 'none') {
+        const end = (_b = ev.endUtc) !== null && _b !== void 0 ? _b : ev.startUtc;
+        if (end < fromUtc || ev.startUtc > toUtc)
+            return [];
+        return [Object.assign(Object.assign({}, ev), { occurrenceId: `${ev.id}#${ev.startUtc}` })];
+    }
+    const out = [];
+    const base = new Date(ev.startUtc);
+    const baseY = base.getUTCFullYear(), baseM = base.getUTCMonth(), baseD = base.getUTCDate();
+    const baseH = base.getUTCHours(), baseMin = base.getUTCMinutes(), baseS = base.getUTCSeconds();
+    const until = (_c = ev.repeatUntilUtc) !== null && _c !== void 0 ? _c : toUtc;
+    const step = Math.max(1, ev.repeatInterval || 1);
+    if (ev.repeat === 'daily') {
+        const from2 = fromUtc - Math.max(0, dur);
+        let k = Math.floor((from2 - ev.startUtc) / (dateUtils_1.DAY_MS * step));
+        if (ev.startUtc + k * step * dateUtils_1.DAY_MS < from2)
+            k++;
+        if (k < 0)
+            k = 0;
+        for (;; k++) {
+            const start = ev.startUtc + k * step * dateUtils_1.DAY_MS;
+            if (start > until)
+                break;
+            if (!push(start, out))
+                break;
+        }
+        return out;
+    }
+    if (ev.repeat === 'weekly') {
+        const tz = ev.tz;
+        if (!tz) {
+            // recurring without tz cannot be expanded safely
+            return out; // or continue + warning
+        }
+        const baseLocal = (0, dateUtils_1.parseYmdHmsLocal)(ev.startText);
+        const baseWd = (0, dateUtils_1.weekdayMon0)(baseLocal.Y, baseLocal.M, baseLocal.D);
+        const list = ev.byWeekdays && ev.byWeekdays.length ? ev.byWeekdays : [baseWd];
+        const step = Math.max(1, ev.repeatInterval || 1);
+        const from2 = fromUtc - Math.max(0, dur);
+        // Monday of base week (local date)
+        const mondayBase = (0, dateUtils_1.addDaysYMD)(baseLocal.Y, baseLocal.M, baseLocal.D, -baseWd);
+        // Start from the week containing "fromUtc" in local TZ
+        const fromLocal = (0, dateUtils_1.getPartsInTz)(fromUtc, tz);
+        const fromWd = (0, dateUtils_1.weekdayMon0)(fromLocal.Y, fromLocal.M, fromLocal.D);
+        const mondayFrom = (0, dateUtils_1.addDaysYMD)(fromLocal.Y, fromLocal.M, fromLocal.D, -fromWd);
+        // Compute week index offset (in local calendar days)
+        const mondayBaseMs = Date.UTC(mondayBase.Y, mondayBase.M - 1, mondayBase.D);
+        const mondayFromMs = Date.UTC(mondayFrom.Y, mondayFrom.M - 1, mondayFrom.D);
+        let weeksDiff = Math.floor((mondayFromMs - mondayBaseMs) / (7 * dateUtils_1.DAY_MS));
+        if (weeksDiff < 0)
+            weeksDiff = 0;
+        let weekIndex = Math.floor(weeksDiff / step);
+        const until = Math.min(toUtc, (_d = ev.repeatUntilUtc) !== null && _d !== void 0 ? _d : Number.POSITIVE_INFINITY);
+        for (;;) {
+            const weekStart = (0, dateUtils_1.addDaysYMD)(mondayBase.Y, mondayBase.M, mondayBase.D, weekIndex * 7 * step);
+            for (const wd of list) {
+                const occ = (0, dateUtils_1.addDaysYMD)(weekStart.Y, weekStart.M, weekStart.D, wd);
+                const start = (0, dateUtils_1.zonedTimeToUtcMs)(occ.Y, occ.M, occ.D, baseLocal.h, baseLocal.m, baseLocal.sec, tz);
+                if (start < from2 || start > until)
+                    continue;
+                if (!push(start, out))
+                    return out;
+            }
+            // stop condition: next week start beyond range
+            const nextWeek = (0, dateUtils_1.addDaysYMD)(mondayBase.Y, mondayBase.M, mondayBase.D, (weekIndex + 1) * 7 * step);
+            const nextWeekStartUtc = (0, dateUtils_1.zonedTimeToUtcMs)(nextWeek.Y, nextWeek.M, nextWeek.D, 0, 0, 0, tz);
+            if (nextWeekStartUtc > toUtc)
+                break;
+            weekIndex++;
+        }
+        return out;
+    }
+    if (ev.repeat === 'monthly') {
+        const dom = (_e = ev.byMonthDay) !== null && _e !== void 0 ? _e : baseD;
+        const y = baseY;
+        let m = baseM;
+        let cursor = Date.UTC(y, m, dom, baseH, baseMin, baseS);
+        while (cursor < ev.startUtc) {
+            m += 1;
+            cursor = Date.UTC(y + Math.floor(m / 12), (m % 12 + 12) % 12, dom, baseH, baseMin, baseS);
+        }
+        for (;;) {
+            if (cursor > until)
+                break;
+            const cd = new Date(cursor);
+            // Ensure month is what we expect (no overflow like Jan 31 -> Feb 3)
+            const expectedM = (m % 12 + 12) % 12;
+            if (cd.getUTCMonth() === expectedM) {
+                if (!push(cursor, out))
+                    break;
+            }
+            m += step;
+            cursor = Date.UTC(y + Math.floor(m / 12), (m % 12 + 12) % 12, dom, baseH, baseMin, baseS);
+            if (cursor > toUtc && cursor > until)
+                break;
+        }
+        return out;
+    }
+    if (ev.repeat === 'yearly') {
+        let y = baseY;
+        let cursor = Date.UTC(y, baseM, baseD, baseH, baseMin, baseS);
+        while (cursor < ev.startUtc) {
+            y += 1;
+            cursor = Date.UTC(y, baseM, baseD, baseH, baseMin, baseS);
+        }
+        while (cursor < fromUtc) {
+            y += (step || 1);
+            cursor = Date.UTC(y, baseM, baseD, baseH, baseMin, baseS);
+        }
+        for (;;) {
+            if (cursor > until)
+                break;
+            const dt = new Date(cursor);
+            // Ensure month is still February (or whatever baseM was) - handles Leap Year Feb 29
+            if (dt.getUTCMonth() === baseM) {
+                if (!push(cursor, out))
+                    break;
+            }
+            y += (step || 1);
+            cursor = Date.UTC(y, baseM, baseD, baseH, baseMin, baseS);
+            if (cursor > toUtc && cursor > until)
+                break;
+        }
+        return out;
+    }
+    return out;
+}
+function expandAllInRange(evs, fromUtc, toUtc) {
+    const out = [];
+    for (const ev of evs)
+        out.push(...expandOccurrencesInRange(ev, fromUtc, toUtc));
+    out.sort((a, b) => a.startUtc - b.startUtc || a.occurrenceId.localeCompare(b.occurrenceId));
+    return out;
+}
+function pad2(n) {
+    return String(n).padStart(2, '0');
+}
+function fmtICS(tsUtc) {
+    const d = new Date(tsUtc);
+    return d.getUTCFullYear().toString() + pad2(d.getUTCMonth() + 1) + pad2(d.getUTCDate()) +
+        'T' + pad2(d.getUTCHours()) + pad2(d.getUTCMinutes()) + pad2(d.getUTCSeconds()) + 'Z';
+}
+function icsEscape(s) {
+    return (s || '').replace(/\\/g, '\\\\').replace(/;/g, '\\;').replace(/,/g, '\\,').replace(/\n/g, '\\n');
+}
+function buildICS(events, prodId = '-//MyCalendar//Joplin//EN') {
+    const lines = ['BEGIN:VCALENDAR', 'VERSION:2.0', `PRODID:${prodId}`, 'CALSCALE:GREGORIAN'];
+    for (const ev of events) {
+        const uid = ev.occurrenceId || `${ev.id}@mycalendar`;
+        lines.push('BEGIN:VEVENT');
+        lines.push(`UID:${icsEscape(uid)}`);
+        lines.push(`DTSTAMP:${fmtICS(Date.now())}`);
+        lines.push(`DTSTART:${fmtICS(ev.startUtc)}`);
+        if (ev.endUtc)
+            lines.push(`DTEND:${fmtICS(ev.endUtc)}`);
+        lines.push(`SUMMARY:${icsEscape(ev.title || 'Event')}`);
+        if (ev.location)
+            lines.push(`LOCATION:${icsEscape(ev.location)}`);
+        if (ev.description)
+            lines.push(`DESCRIPTION:${icsEscape(ev.description)}`);
+        if (ev.color)
+            lines.push(`X-COLOR:${icsEscape(ev.color)}`);
+        lines.push('END:VEVENT');
+    }
+    lines.push('END:VCALENDAR');
+    return lines.join('\r\n');
+}
+function getPanelsAny(joplin) {
+    var _a;
+    return (_a = joplin === null || joplin === void 0 ? void 0 : joplin.views) === null || _a === void 0 ? void 0 : _a.panels;
+}
+function safePostMessage(joplin, panelId, message) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const pm = (_b = (_a = joplin === null || joplin === void 0 ? void 0 : joplin.views) === null || _a === void 0 ? void 0 : _a.panels) === null || _b === void 0 ? void 0 : _b.postMessage;
+        if (typeof pm === 'function')
+            yield pm(panelId, message);
+    });
+}
+// Ensure UI always receives current settings when the webview (re)initializes.
+function registerUiMessageHandlers(joplin, panelId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const onMessage = (_a = getPanelsAny(joplin)) === null || _a === void 0 ? void 0 : _a.onMessage;
+        if (typeof onMessage !== 'function')
+            return;
+        yield onMessage(panelId, (msg) => __awaiter(this, void 0, void 0, function* () {
+            // Joplin sometimes wraps payload as { message: <payload> }
+            if (msg && typeof msg === 'object' && 'message' in msg && msg.message) {
+                msg = msg.message;
+            }
+            if (!msg || !msg.name)
+                return;
+            if (msg.name === 'uiLog') {
+                const source = msg.source ? `[UI:${msg.source}]` : '[UI]';
+                const level = msg.level || 'log';
+                const args = Array.isArray(msg.args) ? msg.args : [];
+                const restored = args.map((a) => {
+                    if (a && typeof a === 'object' && a.__error) {
+                        const e = new Error(a.message || 'UI error');
+                        e.stack = a.stack;
+                        return e;
+                    }
+                    return a;
+                });
+                switch (level) {
+                    case 'debug':
+                        (0, logger_1.dbg)(source, ...restored);
+                        break;
+                    case 'info':
+                        (0, logger_1.info)(source, ...restored);
+                        break;
+                    case 'warn':
+                        (0, logger_1.warn)(source, ...restored);
+                        break;
+                    case 'error':
+                        (0, logger_1.err)(source, ...restored);
+                        break;
+                    default:
+                        (0, logger_1.log)(source, ...restored);
+                        break;
+                }
+                return;
+            }
+            if (msg.name === 'uiReady') {
+                yield (0, uiSettings_1.pushUiSettings)(joplin, panelId);
+                // Force a redraw so weekStart takes effect immediately.
+                // const pm = joplin?.views?.panels?.postMessage;
+                // if (typeof pm === 'function') {
+                //     await pm(panelId, {name: 'redrawMonth'});
+                // }
+                yield safePostMessage(joplin, panelId, { name: 'redrawMonth' });
+                return;
+            }
+        }));
+    });
+}
+function runPlugin(joplin) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        (0, logger_1.log)('pluginMain', 'Plugin start');
+        yield (0, settings_1.registerSettings)(joplin);
+        const panel = yield (0, calendarView_1.createCalendarPanel)(joplin);
+        (0, logger_1.log)('pluginMain', 'Panel created:', panel);
+        yield registerUiMessageHandlers(joplin, panel);
+        yield (0, panelController_1.registerCalendarPanelController)(joplin, panel, {
+            expandAllInRange,
+            buildICS,
+        });
+        // warm up the cache after the UI already has handlers
+        void (() => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const all = yield (0, eventsCache_1.ensureAllEventsCache)(joplin);
+                (0, logger_1.log)('eventsCache', 'Events cached:', all.length);
+            }
+            catch (error) {
+                (0, logger_1.err)('eventsCache', 'Error warming up cache:', error);
+            }
+        }))();
+        const toggleState = {
+            visible: true,
+            // Indicates whether desktop menu/toolbar were registered successfully.
+            active: false,
+        };
+        yield registerToggleCommand(joplin, panel, toggleState);
+        yield joplin.commands.register({
+            name: 'mycalendar.open',
+            label: 'Open MyCalendar',
+            execute: () => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                yield joplin.views.panels.show(panel);
+                // Ensure the UI gets the latest weekStart when the panel becomes visible.
+                yield (0, uiSettings_1.pushUiSettings)(joplin, panel);
+                try {
+                    // const pm = joplin?.views?.panels?.postMessage;
+                    // if (typeof pm === 'function') await pm(panel, {name: 'redrawMonth'});
+                    yield safePostMessage(joplin, panel, { name: 'redrawMonth' });
+                }
+                catch (_err) {
+                    // ignore
+                }
+                try {
+                    const panelsAny = (_a = joplin.views) === null || _a === void 0 ? void 0 : _a.panels;
+                    if (panelsAny && typeof panelsAny.focus === 'function') {
+                        yield panelsAny.focus(panel);
+                    }
+                }
+                catch (_b) {
+                    // The mobile method is missing - it's expected
+                    (0, logger_1.log)('pluginMain', 'panels.focus not available on this platform');
+                }
+                // Sync toggle state
+                toggleState.visible = true;
+                // await toggleState.update();
+            }),
+        });
+        yield joplin.workspace.onNoteChange((_a) => __awaiter(this, [_a], void 0, function* ({ id }) {
+            if (id)
+                (0, eventsCache_1.invalidateNote)(id);
+        }));
+        yield joplin.workspace.onSyncComplete(() => __awaiter(this, void 0, void 0, function* () {
+            (0, eventsCache_1.invalidateAllEventsCache)();
+        }));
+        yield (0, uiSettings_1.pushUiSettings)(joplin, panel);
+        yield joplin.views.panels.show(panel);
+        yield joplin.settings.onChange(() => __awaiter(this, void 0, void 0, function* () {
+            yield (0, uiSettings_1.pushUiSettings)(joplin, panel);
+        }));
+        yield registerDesktopToggle(joplin, panel, toggleState);
+        // --- Create the import panel (desktop)
+        try {
+            const panelsAny = (_a = joplin.views) === null || _a === void 0 ? void 0 : _a.panels;
+            if (panelsAny && typeof panelsAny.focus === 'function') {
+                yield panelsAny.focus(panel);
+            }
+        }
+        catch (_b) {
+            // On mobile this method may be missing - it's expected
+            (0, logger_1.log)('pluginMain', 'panels.focus not available on this platform');
+        }
+    });
+}
+// Register the toggle command once. The label is intentionally static because
+// dynamic label updates are not reliably supported by Joplin's menu API.
+function registerToggleCommand(joplin, panel, toggleState) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield joplin.commands.register({
+            name: 'mycalendar.togglePanel',
+            label: 'Toggle My Calendar',
+            iconName: 'fas fa-calendar-alt',
+            execute: () => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b;
+                toggleState.visible = !toggleState.visible;
+                if (toggleState.visible) {
+                    yield joplin.views.panels.show(panel);
+                    (0, logger_1.log)('pluginMain', 'Toggle: Show');
+                }
+                else {
+                    if ((_b = (_a = joplin.views) === null || _a === void 0 ? void 0 : _a.panels) === null || _b === void 0 ? void 0 : _b.hide) {
+                        yield joplin.views.panels.hide(panel);
+                    }
+                    (0, logger_1.log)('pluginMain', 'Toggle: Hide');
+                }
+            }),
+        });
+    });
+}
+// === MyCalendar: safe desktop toggle helper ===
+function registerDesktopToggle(joplin, panel, toggleState) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e, _f;
+        try {
+            const canShow = !!((_b = (_a = joplin === null || joplin === void 0 ? void 0 : joplin.views) === null || _a === void 0 ? void 0 : _a.panels) === null || _b === void 0 ? void 0 : _b.show);
+            const canHide = !!((_d = (_c = joplin === null || joplin === void 0 ? void 0 : joplin.views) === null || _c === void 0 ? void 0 : _c.panels) === null || _d === void 0 ? void 0 : _d.hide);
+            const canMenu = !!((_f = (_e = joplin === null || joplin === void 0 ? void 0 : joplin.views) === null || _e === void 0 ? void 0 : _e.menuItems) === null || _f === void 0 ? void 0 : _f.create);
+            (0, logger_1.info)('pluginMain', 'Toggle capabilities:', { canShow, canHide, canMenu, panel });
+            if (!canShow || !canHide) {
+                (0, logger_1.info)('pluginMain', 'Toggle: panels.show/hide not available - skip');
+                return;
+            }
+            toggleState.active = true;
+            // Initial update to ensure label is correct
+            // (no-op) label is intentionally static
+            try {
+                yield joplin.views.menuItems.create('mycalendarToggleMenu', 'mycalendar.togglePanel', 'view', { accelerator: 'Ctrl+Alt+C' });
+                (0, logger_1.log)('pluginMain', 'Toggle menu item registered');
+            }
+            catch (e) {
+                (0, logger_1.warn)('pluginMain', 'Menu create failed (non-fatal):', e);
+            }
+            try {
+                yield joplin.views.toolbarButtons.create('mycalendarToolbarButton', 'mycalendar.togglePanel', 'noteToolbar');
+                (0, logger_1.log)('pluginMain', 'Toolbar button registered');
+            }
+            catch (e) {
+                (0, logger_1.warn)('pluginMain', 'Toolbar button create failed (non-fatal):', e);
+            }
+        }
+        catch (e) {
+            (0, logger_1.warn)('pluginMain', 'registerDesktopToggle failed (non-fatal):', e);
+        }
+    });
+}
+
+
+/***/ },
+
+/***/ "./src/main/services/alarmService.ts"
+/*!*******************************************!*\
+  !*** ./src/main/services/alarmService.ts ***!
+  \*******************************************/
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+// src/main/services/alarmService.ts
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.syncAlarmsForEvents = syncAlarmsForEvents;
+const occurrenceService_1 = __webpack_require__(/*! ./occurrenceService */ "./src/main/services/occurrenceService.ts");
+const dateTimeUtils_1 = __webpack_require__(/*! ../utils/dateTimeUtils */ "./src/main/utils/dateTimeUtils.ts");
+const noteBuilder_1 = __webpack_require__(/*! ./noteBuilder */ "./src/main/services/noteBuilder.ts");
+const joplinUtils_1 = __webpack_require__(/*! ../utils/joplinUtils */ "./src/main/utils/joplinUtils.ts");
+const settings_1 = __webpack_require__(/*! ../settings/settings */ "./src/main/settings/settings.ts");
+const joplinNoteService_1 = __webpack_require__(/*! ./joplinNoteService */ "./src/main/services/joplinNoteService.ts");
+function isNonNegativeFiniteNumber(v) {
+    return typeof v === 'number' && Number.isFinite(v) && v >= 0;
+}
+function buildDesiredAlarmsForEvent(ev, now, windowEnd) {
+    const desired = [];
+    const nowMs = now.getTime();
+    const windowEndMs = windowEnd.getTime();
+    if (!ev.valarms || ev.valarms.length === 0)
+        return desired;
+    const occs = (0, occurrenceService_1.expandOccurrences)(ev, now, windowEnd);
+    for (const occ of occs) {
+        for (const a of ev.valarms) {
+            const when = (0, dateTimeUtils_1.computeAlarmWhen)(a, occ);
+            if (!when)
+                continue;
+            const whenMs = when.getTime();
+            if (whenMs >= nowMs && whenMs <= windowEndMs) {
+                desired.push({ alarmTime: whenMs, eventTime: occ.start, trigger: a.trigger });
+            }
+        }
+    }
+    return desired;
+}
+function buildAlarmNoteBody(args) {
+    const eventTimeStr = (0, dateTimeUtils_1.formatAlarmTitleTime)(args.eventTime);
+    const triggerDesc = (0, dateTimeUtils_1.formatTriggerDescription)(args.trigger);
+    return (0, noteBuilder_1.buildAlarmBody)(args.eventTitle, eventTimeStr, args.eventNoteId, args.todoTitle, args.uid, args.rid, (0, dateTimeUtils_1.formatDateForAlarm)(new Date(args.alarmTime)), triggerDesc);
+}
+function syncAlarmsForEvents(joplin, events, importedEventNotes, existingAlarms, targetFolderId, onStatus, options, 
+// Legacy argument support (if needed, though we prefer options object)
+legacyAlarmsEnabled) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const say = (t) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (onStatus)
+                    yield onStatus(t);
+            }
+            catch ( /* ignore */_a) { /* ignore */
+            }
+        });
+        const resolvedOptions = typeof options === 'number' ? { alarmRangeDays: options } : (options !== null && options !== void 0 ? options : {});
+        // Handle legacy argument if provided and options didn't specify it
+        if (legacyAlarmsEnabled !== undefined && resolvedOptions.alarmsEnabled === undefined) {
+            resolvedOptions.alarmsEnabled = legacyAlarmsEnabled;
+        }
+        const now = (_a = resolvedOptions.now) !== null && _a !== void 0 ? _a : new Date();
+        const nowMs = now.getTime();
+        const alarmRangeDays = isNonNegativeFiniteNumber(resolvedOptions.alarmRangeDays) ? Math.trunc(resolvedOptions.alarmRangeDays) : yield (0, settings_1.getIcsImportAlarmRangeDays)(joplin);
+        const emptyTrashAfter = typeof resolvedOptions.emptyTrashAfter === 'boolean' ? resolvedOptions.emptyTrashAfter : yield (0, settings_1.getIcsImportEmptyTrashAfter)(joplin);
+        const alarmsEnabled = resolvedOptions.alarmsEnabled !== false; // Default true
+        const windowEnd = (0, dateTimeUtils_1.addDays)(now, alarmRangeDays);
+        let alarmsDeleted = 0;
+        let alarmsCreated = 0;
+        let alarmsUpdated = 0;
+        for (const ev of events) {
+            const uid = (ev.uid || '').trim();
+            if (!uid)
+                continue;
+            const rid = (ev.recurrence_id || '').trim();
+            const key = (0, joplinUtils_1.makeEventKey)(uid, rid);
+            const eventNote = importedEventNotes[key];
+            if (!eventNote)
+                continue;
+            const notebookId = targetFolderId || eventNote.parent_id;
+            if (!notebookId)
+                continue;
+            // If alarms are disabled, desiredAlarms is empty -> all existing will be deleted
+            const desiredAlarms = alarmsEnabled ? buildDesiredAlarmsForEvent(ev, now, windowEnd) : [];
+            const oldAlarms = existingAlarms[key] || [];
+            const matchedDesiredIndices = new Set();
+            for (const alarm of oldAlarms) {
+                if (alarm.todo_due < nowMs) {
+                    try {
+                        yield (0, joplinNoteService_1.deleteNote)(joplin, alarm.id);
+                        alarmsDeleted++;
+                    }
+                    catch (e) {
+                        yield say(`[alarmService] ERROR deleting outdated alarm: ${key} - ${String((e === null || e === void 0 ? void 0 : e.message) || e)}`);
+                    }
+                    continue;
+                }
+                let matchIndex = -1;
+                for (let i = 0; i < desiredAlarms.length; i++) {
+                    if (!matchedDesiredIndices.has(i)) {
+                        if (Math.abs(desiredAlarms[i].alarmTime - alarm.todo_due) < 1000) {
+                            matchIndex = i;
+                            break;
+                        }
+                    }
+                }
+                if (matchIndex !== -1) {
+                    matchedDesiredIndices.add(matchIndex);
+                    const { alarmTime, eventTime, trigger } = desiredAlarms[matchIndex];
+                    const eventTitle = ev.title || 'Event';
+                    const todoTitle = `${eventTitle} at ${(0, dateTimeUtils_1.formatAlarmTitleTime)(eventTime)}`;
+                    const newBody = buildAlarmNoteBody({
+                        eventTitle,
+                        eventTime,
+                        eventNoteId: eventNote.id,
+                        todoTitle,
+                        uid,
+                        rid,
+                        alarmTime,
+                        trigger
+                    });
+                    if (newBody !== alarm.body) {
+                        try {
+                            yield (0, joplinNoteService_1.updateNote)(joplin, alarm.id, { body: newBody });
+                            alarmsUpdated++;
+                        }
+                        catch (e) {
+                            yield say(`[alarmService] ERROR updating alarm body: ${key} - ${String((e === null || e === void 0 ? void 0 : e.message) || e)}`);
+                        }
+                    }
+                }
+                else {
+                    try {
+                        yield (0, joplinNoteService_1.deleteNote)(joplin, alarm.id);
+                        alarmsDeleted++;
+                    }
+                    catch (e) {
+                        yield say(`[alarmService] ERROR deleting invalid alarm: ${key} - ${String((e === null || e === void 0 ? void 0 : e.message) || e)}`);
+                    }
+                }
+            }
+            for (let i = 0; i < desiredAlarms.length; i++) {
+                if (matchedDesiredIndices.has(i))
+                    continue;
+                const { alarmTime, eventTime, trigger } = desiredAlarms[i];
+                const eventTitle = ev.title || 'Event';
+                const todoTitle = `${eventTitle} at ${(0, dateTimeUtils_1.formatAlarmTitleTime)(eventTime)}`;
+                const body = buildAlarmNoteBody({
+                    eventTitle,
+                    eventTime,
+                    eventNoteId: eventNote.id,
+                    todoTitle,
+                    uid,
+                    rid,
+                    alarmTime,
+                    trigger
+                });
+                try {
+                    const noteBody = {
+                        title: todoTitle,
+                        body,
+                        parent_id: notebookId,
+                        is_todo: 1,
+                        todo_due: alarmTime,
+                    };
+                    const created = yield (0, joplinNoteService_1.createNote)(joplin, noteBody);
+                    if (created === null || created === void 0 ? void 0 : created.id) {
+                        // NOTE: Keeping this as a safety measure in case Joplin doesn't persist todo_due on create reliably.
+                        yield (0, joplinNoteService_1.updateNote)(joplin, created.id, { todo_due: alarmTime });
+                    }
+                    alarmsCreated++;
+                }
+                catch (e) {
+                    yield say(`[alarmService] ERROR creating alarm: ${key} - ${String((e === null || e === void 0 ? void 0 : e.message) || e)}`);
+                }
+            }
+        }
+        if (alarmsDeleted > 0 && emptyTrashAfter) {
+            try {
+                yield joplin.commands.execute('emptyTrash');
+                yield say('Trash emptied.');
+            }
+            catch (e) {
+                yield say(`[alarmService] WARNING: Failed to empty trash: ${String((e === null || e === void 0 ? void 0 : e.message) || e)}`);
+            }
+        }
+        if (alarmsDeleted || alarmsCreated || alarmsUpdated) {
+            yield say(`Alarms sync summary: deleted ${alarmsDeleted}, created ${alarmsCreated}, updated ${alarmsUpdated} (next ${alarmRangeDays} days)`);
+        }
+        return { alarmsCreated, alarmsDeleted, alarmsUpdated };
+    });
+}
+
+
+/***/ },
+
+/***/ "./src/main/services/eventsCache.ts"
+/*!******************************************!*\
+  !*** ./src/main/services/eventsCache.ts ***!
+  \******************************************/
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+// src/main/services/eventsCache.ts
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.invalidateAllEventsCache = invalidateAllEventsCache;
+exports.invalidateNote = invalidateNote;
+exports.rebuildAllEventsCache = rebuildAllEventsCache;
+exports.ensureAllEventsCache = ensureAllEventsCache;
+const eventParser_1 = __webpack_require__(/*! ../parsers/eventParser */ "./src/main/parsers/eventParser.ts");
+const logger_1 = __webpack_require__(/*! ../utils/logger */ "./src/main/utils/logger.ts");
+const NOTE_FIELDS = ['id', 'title', 'body'];
+const PAGE_LIMIT = 100;
+const eventCacheByNote = new Map();
+let allEventsCache = null;
+// Guard against concurrent rebuilds
+let rebuildPromise = null;
+function invalidateAllEventsCache() {
+    allEventsCache = null;
+    eventCacheByNote.clear();
+}
+function invalidateNote(noteId) {
+    eventCacheByNote.delete(noteId);
+    allEventsCache = null;
+}
+function fetchAllNotes(joplin) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const items = [];
+        let page = 1;
+        while (true) {
+            const res = yield joplin.data.get(['notes'], {
+                fields: [...NOTE_FIELDS],
+                limit: PAGE_LIMIT,
+                page,
+            });
+            for (const n of res.items || [])
+                items.push(n);
+            if (!res.has_more)
+                break;
+            page++;
+        }
+        return items;
+    });
+}
+function extractEventsFromNote(n) {
+    const noteId = String((n === null || n === void 0 ? void 0 : n.id) || '');
+    const title = String((n === null || n === void 0 ? void 0 : n.title) || '');
+    const body = typeof (n === null || n === void 0 ? void 0 : n.body) === 'string' ? n.body : '';
+    if (!noteId || !body)
+        return null;
+    const evs = (0, eventParser_1.parseEventsFromBody)(noteId, title, body) || [];
+    if (!evs.length)
+        return null;
+    // Ensure noteId is present for UI
+    const withNoteId = evs.map((e) => (Object.assign(Object.assign({}, e), { noteId })));
+    return { noteId, events: withNoteId };
+}
+function rebuildAllEventsCache(joplin) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // If a rebuild is already running, just await it
+        if (rebuildPromise) {
+            yield rebuildPromise;
+            return;
+        }
+        rebuildPromise = (() => __awaiter(this, void 0, void 0, function* () {
+            try {
+                (0, logger_1.log)('eventsCache', 'Rebuilding all events cache...');
+                eventCacheByNote.clear();
+                const notes = yield fetchAllNotes(joplin);
+                const all = [];
+                for (const n of notes) {
+                    const extracted = extractEventsFromNote(n);
+                    if (!extracted)
+                        continue;
+                    eventCacheByNote.set(extracted.noteId, extracted.events);
+                    all.push(...extracted.events);
+                }
+                allEventsCache = all;
+                (0, logger_1.log)('eventsCache', 'Rebuild complete. Events found:', allEventsCache.length);
+            }
+            catch (error) {
+                (0, logger_1.err)('eventsCache', 'Error rebuilding events cache:', error);
+                // Keep cache usable + avoid "stuck" state
+                allEventsCache = allEventsCache || [];
+            }
+        }))();
+        try {
+            yield rebuildPromise;
+        }
+        finally {
+            rebuildPromise = null;
+        }
+    });
+}
+function ensureAllEventsCache(joplin) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!allEventsCache) {
+            yield rebuildAllEventsCache(joplin);
+        }
+        return allEventsCache || [];
+    });
+}
+
+
+/***/ },
+
+/***/ "./src/main/services/folderService.ts"
+/*!********************************************!*\
+  !*** ./src/main/services/folderService.ts ***!
+  \********************************************/
+(__unused_webpack_module, exports) {
+
+
+// src/main/services/folderService.ts
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.getAllFolders = getAllFolders;
+exports.flattenFolderTree = flattenFolderTree;
+const FOLDERS_PAGE_LIMIT = 100;
+function getAllFolders(joplin) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const out = [];
+        let page = 1;
+        while (true) {
+            const res = yield joplin.data.get(['folders'], {
+                page,
+                limit: FOLDERS_PAGE_LIMIT,
+                fields: ['id', 'title', 'parent_id'],
+            });
+            const items = ((_a = res === null || res === void 0 ? void 0 : res.items) !== null && _a !== void 0 ? _a : []);
+            if (items.length)
+                out.push(...items);
+            if (!(res === null || res === void 0 ? void 0 : res.has_more))
+                break;
+            page += 1;
+        }
+        return out;
+    });
+}
+/**
+ * Flattens a folder graph into a depth-annotated list.
+ *
+ * Notes:
+ * - Ordering is deterministic (case-insensitive alphabetical).
+ * - Orphans are treated as roots.
+ * - Cycles are handled: items involved in cycles are still included, and traversal stops on cycle edges.
+ */
+function flattenFolderTree(rows) {
+    var _a;
+    const byId = new Map();
+    // Build nodes; normalize parent_id to null to avoid undefined / null differences.
+    for (const r of rows) {
+        byId.set(r.id, { id: r.id, title: r.title, parent_id: (_a = r.parent_id) !== null && _a !== void 0 ? _a : null, children: [] });
+    }
+    const roots = [];
+    // Link children -> parents when possible, otherwise treat as root.
+    for (const node of byId.values()) {
+        const parentId = node.parent_id;
+        if (parentId && byId.has(parentId) && parentId !== node.id) {
+            byId.get(parentId).children.push(node);
+        }
+        else {
+            roots.push(node);
+        }
+    }
+    const sortFn = (a, b) => a.title.localeCompare(b.title, undefined, { sensitivity: 'base' });
+    roots.sort(sortFn);
+    const acc = [];
+    const visited = new Set();
+    const visiting = new Set();
+    const visit = (node, depth) => {
+        if (visited.has(node.id))
+            return;
+        // Cycle edge: stop descent (the node is already in the current path).
+        if (visiting.has(node.id))
+            return;
+        visiting.add(node.id);
+        acc.push({ id: node.id, title: node.title, parent_id: node.parent_id, depth });
+        node.children.sort(sortFn);
+        for (const ch of node.children)
+            visit(ch, depth + 1);
+        visiting.delete(node.id);
+        visited.add(node.id);
+    };
+    // Walk declared roots first.
+    for (const r of roots)
+        visit(r, 0);
+    // Include any remaining nodes (covers pure cycles and disconnected graphs with no roots).
+    if (visited.size !== byId.size) {
+        const remaining = Array.from(byId.values()).filter(n => !visited.has(n.id));
+        remaining.sort(sortFn);
+        for (const n of remaining)
+            visit(n, 0);
+    }
+    return acc;
+}
+
+
+/***/ },
+
+/***/ "./src/main/services/icsImportService.ts"
+/*!***********************************************!*\
+  !*** ./src/main/services/icsImportService.ts ***!
+  \***********************************************/
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+// src/main/services/icsImportService.ts
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.importIcsIntoNotes = importIcsIntoNotes;
+const icsParser_1 = __webpack_require__(/*! ../parsers/icsParser */ "./src/main/parsers/icsParser.ts");
+const joplinUtils_1 = __webpack_require__(/*! ../utils/joplinUtils */ "./src/main/utils/joplinUtils.ts");
+const alarmService_1 = __webpack_require__(/*! ./alarmService */ "./src/main/services/alarmService.ts");
+const noteBuilder_1 = __webpack_require__(/*! ./noteBuilder */ "./src/main/services/noteBuilder.ts");
+const joplinNoteService_1 = __webpack_require__(/*! ./joplinNoteService */ "./src/main/services/joplinNoteService.ts");
+const settings_1 = __webpack_require__(/*! ../settings/settings */ "./src/main/settings/settings.ts");
+function safeStatus(onStatus) {
+    return (t) => __awaiter(this, void 0, void 0, function* () {
+        try {
+            if (onStatus)
+                yield onStatus(t);
+        }
+        catch ( /* ignore */_a) { /* ignore */
+        }
+    });
+}
+function indexExistingNotes(allNotes) {
+    var _a, _b;
+    var _c;
+    const existingByKey = {};
+    const existingAlarms = {};
+    const noteIdToKeys = {};
+    for (const n of allNotes) {
+        if (typeof n.body !== 'string' || !n.body)
+            continue;
+        if (n.body.includes('```mycalendar-event')) {
+            const keys = (0, joplinUtils_1.extractAllEventKeysFromBody)(n.body);
+            if (keys.length) {
+                noteIdToKeys[n.id] = ((_a = noteIdToKeys[n.id]) !== null && _a !== void 0 ? _a : []).concat(keys);
+            }
+            for (const k of keys) {
+                existingByKey[k] = { id: n.id, title: n.title || '', body: n.body, parent_id: n.parent_id };
+            }
+        }
+        if (n.body.includes('```mycalendar-alarm')) {
+            const metas = (0, joplinUtils_1.extractAllAlarmKeysFromBody)(n.body);
+            for (const meta of metas) {
+                ((_b = existingAlarms[_c = meta.key]) !== null && _b !== void 0 ? _b : (existingAlarms[_c] = [])).push({ id: n.id, todo_due: n.todo_due || 0, body: n.body });
+            }
+        }
+    }
+    return { existingByKey, existingAlarms, noteIdToKeys };
+}
+function applyImportColors(ev, existing, preserveLocalColor, importDefaultColor) {
+    const uid = (ev.uid || '').trim();
+    const rid = (ev.recurrence_id || '').trim();
+    const key = (0, joplinUtils_1.makeEventKey)(uid, rid);
+    if (preserveLocalColor && existing[key] && !ev.color) {
+        const existingColor = (0, joplinUtils_1.extractEventColorFromBody)(existing[key].body, uid, rid);
+        if (existingColor)
+            ev.color = existingColor;
+    }
+    if (!ev.color && importDefaultColor)
+        ev.color = importDefaultColor;
+    return key;
+}
+function importIcsIntoNotes(joplin_1, ics_1, onStatus_1, targetFolderId_1) {
+    return __awaiter(this, arguments, void 0, function* (joplin, ics, onStatus, targetFolderId, preserveLocalColor = true, importDefaultColor, importAlarmRangeDays) {
+        var _a;
+        const say = safeStatus(onStatus);
+        const eventsRaw = (0, icsParser_1.parseImportText)(ics);
+        const events = eventsRaw.map(e => (Object.assign({}, e))); // avoid mutating parser output
+        yield say(`Parsed ${events.length} VEVENT(s)`);
+        // Request todo_due to optimize alarm syncing
+        const allNotes = yield (0, joplinNoteService_1.getAllNotesPaged)(joplin, ['id', 'title', 'body', 'parent_id', 'todo_due']);
+        const { existingByKey: existing, existingAlarms, noteIdToKeys } = indexExistingNotes(allNotes);
+        let added = 0, updated = 0, skipped = 0, errors = 0;
+        const importedEventNotes = {};
+        for (const ev of events) {
+            const uid = (ev.uid || '').trim();
+            if (!uid) {
+                skipped++;
+                continue;
+            }
+            const rid = (ev.recurrence_id || '').trim();
+            const key = applyImportColors(ev, existing, preserveLocalColor, importDefaultColor);
+            const block = (0, noteBuilder_1.buildMyCalBlock)(ev);
+            const desiredTitle = ev.title || 'Event';
+            if (existing[key]) {
+                try {
+                    const { id, title, parent_id } = existing[key];
+                    // CRITICAL: Always use the LATEST body from our local "existing" cache
+                    // because multiple sequential updates to the same note might have occurred
+                    const currentBody = existing[key].body;
+                    const newBody = (0, joplinUtils_1.replaceEventBlockByKey)(currentBody, uid, rid, block);
+                    const patch = {};
+                    let changedAtAll = false;
+                    if (newBody !== currentBody) {
+                        patch.body = newBody;
+                        // Update our cache immediately so the next event in the same note sees current state
+                        existing[key].body = newBody;
+                        changedAtAll = true;
+                    }
+                    if (desiredTitle !== title) {
+                        patch.title = desiredTitle;
+                        existing[key].title = desiredTitle;
+                        changedAtAll = true;
+                    }
+                    if (targetFolderId && parent_id !== targetFolderId) {
+                        patch.parent_id = targetFolderId;
+                        existing[key].parent_id = targetFolderId;
+                        changedAtAll = true;
+                    }
+                    if (changedAtAll) {
+                        yield (0, joplinNoteService_1.updateNote)(joplin, id, patch);
+                        updated++;
+                    }
+                    else {
+                        skipped++;
+                    }
+                    // IMPORTANT: update cache for all keys in the same note (O(keysInNote) instead of O(allKeys))
+                    const keysInSameNote = (_a = noteIdToKeys[id]) !== null && _a !== void 0 ? _a : [];
+                    for (const k of keysInSameNote) {
+                        if (existing[k])
+                            existing[k].body = existing[key].body;
+                    }
+                    importedEventNotes[key] = { id, parent_id: (targetFolderId || parent_id), title: desiredTitle };
+                }
+                catch (e) {
+                    errors++;
+                    yield say(`[icsImportService] ERROR updating note: ${key} - ${String((e === null || e === void 0 ? void 0 : e.message) || e)}`);
+                }
+            }
+            else {
+                try {
+                    const noteBody = { title: desiredTitle, body: block, parent_id: targetFolderId };
+                    const created = yield (0, joplinNoteService_1.createNote)(joplin, noteBody);
+                    added++;
+                    if (created === null || created === void 0 ? void 0 : created.id) {
+                        importedEventNotes[key] = { id: created.id, parent_id: targetFolderId, title: desiredTitle };
+                    }
+                }
+                catch (e) {
+                    errors++;
+                    yield say(`[icsImportService] ERROR creating note: ${key} - ${String((e === null || e === void 0 ? void 0 : e.message) || e)}`);
+                }
+            }
+        }
+        let alarmsEnabled = true;
+        try {
+            alarmsEnabled = yield (0, settings_1.getIcsImportAlarmsEnabled)(joplin);
+        }
+        catch (e) {
+            // Backward compatibility: if setting read fails (old Joplin API / corrupted profile),
+            // keep previous behavior (alarms enabled).
+            yield say(`[icsImportService] WARNING: Failed to read alarms setting; defaulting to enabled. ${String((e === null || e === void 0 ? void 0 : e.message) || e)}`);
+            alarmsEnabled = true;
+        }
+        const alarmRes = yield (0, alarmService_1.syncAlarmsForEvents)(joplin, events, importedEventNotes, existingAlarms, targetFolderId, onStatus, {
+            alarmRangeDays: importAlarmRangeDays,
+            alarmsEnabled
+        });
+        return Object.assign({ added, updated, skipped, errors }, alarmRes);
+    });
+}
+
+
+/***/ },
+
+/***/ "./src/main/services/joplinNoteService.ts"
+/*!************************************************!*\
+  !*** ./src/main/services/joplinNoteService.ts ***!
+  \************************************************/
+(__unused_webpack_module, exports) {
+
+
+// src/main/services/joplinNoteService.ts
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.getAllNotesPaged = getAllNotesPaged;
+exports.createNote = createNote;
+exports.updateNote = updateNote;
+exports.deleteNote = deleteNote;
+const DEFAULT_PAGE_LIMIT = 100;
+const DEFAULT_MAX_PAGES = 1000;
+function getAllNotesPaged(joplin_1) {
+    return __awaiter(this, arguments, void 0, function* (joplin, fields = ['id', 'title', 'body', 'parent_id'], options = {}) {
+        var _a, _b, _c;
+        const allNotes = [];
+        let page = 1;
+        const limit = (_a = options.limit) !== null && _a !== void 0 ? _a : DEFAULT_PAGE_LIMIT;
+        const maxPages = (_b = options.maxPages) !== null && _b !== void 0 ? _b : DEFAULT_MAX_PAGES;
+        while (true) {
+            if (page > maxPages) {
+                throw new Error(`getAllNotesPaged exceeded maxPages=${maxPages}`);
+            }
+            const res = (yield joplin.data.get(['notes'], { fields, limit, page }));
+            allNotes.push(...((_c = res.items) !== null && _c !== void 0 ? _c : []));
+            if (!res.has_more)
+                break;
+            page++;
+        }
+        return allNotes;
+    });
+}
+function createNote(joplin, note) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return joplin.data.post(['notes'], null, note);
+    });
+}
+function updateNote(joplin, id, patch) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield joplin.data.put(['notes', id], null, patch);
+    });
+}
+function deleteNote(joplin, id) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield joplin.data.delete(['notes', id]);
+    });
+}
+
+
+/***/ },
+
+/***/ "./src/main/services/noteBuilder.ts"
+/*!******************************************!*\
+  !*** ./src/main/services/noteBuilder.ts ***!
+  \******************************************/
+(__unused_webpack_module, exports) {
+
+
+// src/main/services/noteBuilder.ts
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.sanitizeForMarkdownBlock = sanitizeForMarkdownBlock;
+exports.isValidHexColor = isValidHexColor;
+exports.isValidJoplinNoteId = isValidJoplinNoteId;
+exports.buildMyCalBlock = buildMyCalBlock;
+exports.buildAlarmBody = buildAlarmBody;
+const MAX_TITLE_LEN = 500;
+const MAX_LOCATION_LEN = 1000;
+const MAX_DESCRIPTION_LEN = 10000;
+/**
+ * Ensures a value recorded in a ```mycalendar-event``` or ```mycalendar-alarm``` block
+ * cannot "break out" of the fence.
+ * - Removes backticks
+ * - Replaces newlines with spaces for single-line fields
+ */
+function sanitizeForMarkdownBlock(input, singleLine = true) {
+    let s = String(input !== null && input !== void 0 ? input : '').trim();
+    // Prevent breaking out of code block (```)
+    s = s.replace(/`/g, "'");
+    if (singleLine) {
+        // Enforce single line to prevent key: value injection
+        s = s.replace(/[\r\n]+/g, ' ');
+    }
+    return s;
+}
+function isValidHexColor(c) {
+    if (!c)
+        return false;
+    return /^#(?:[0-9a-fA-F]{3}){1,2}$/.test(c);
+}
+function isValidJoplinNoteId(id) {
+    if (!id)
+        return false;
+    return /^[0-9a-fA-F]{32}$/.test(id);
+}
+function normalizePositiveInt(value, defaultValue) {
+    const n = typeof value === 'number' ? value : Number(value);
+    if (!Number.isFinite(n))
+        return defaultValue;
+    return Math.max(1, Math.floor(n));
+}
+function pushKV(lines, key, value, opts = {}) {
+    var _a;
+    if (value === undefined || value === null || value === '')
+        return;
+    const singleLine = (_a = opts.singleLine) !== null && _a !== void 0 ? _a : true;
+    const maxLen = opts.maxLen;
+    let s = sanitizeForMarkdownBlock(value, singleLine);
+    if (typeof maxLen === 'number')
+        s = s.slice(0, maxLen);
+    lines.push(`${key}: ${s}`);
+}
+function valarmToJsonLine(a) {
+    // Stable key order for tests + diffs
+    const o = { trigger: a.trigger };
+    if (a.related)
+        o.related = a.related;
+    if (a.action)
+        o.action = a.action;
+    if (a.description)
+        o.description = a.description;
+    if (a.summary)
+        o.summary = a.summary;
+    if (typeof a.repeat === 'number')
+        o.repeat = a.repeat;
+    if (a.duration)
+        o.duration = a.duration;
+    return JSON.stringify(o);
+}
+/**
+ * Form the block ```mycalendar-event ... ```
+ */
+function buildMyCalBlock(ev) {
+    const lines = [];
+    lines.push('```mycalendar-event');
+    pushKV(lines, 'title', ev.title, { maxLen: MAX_TITLE_LEN });
+    pushKV(lines, 'start', ev.start);
+    pushKV(lines, 'end', ev.end);
+    pushKV(lines, 'tz', ev.tz);
+    if (isValidHexColor(ev.color)) {
+        lines.push(`color: ${ev.color}`);
+    }
+    pushKV(lines, 'location', ev.location, { maxLen: MAX_LOCATION_LEN });
+    if (ev.description) {
+        // Description can be multiline in ICS.
+        // We sanitize to prevent breaking ``` but keep newlines.
+        pushKV(lines, 'description', ev.description, { singleLine: false, maxLen: MAX_DESCRIPTION_LEN });
+    }
+    if (ev.valarms && ev.valarms.length) {
+        lines.push('');
+        for (const a of ev.valarms) {
+            // valarm is JSON.
+            const json = valarmToJsonLine(a);
+            pushKV(lines, 'valarm', json);
+        }
+    }
+    const repeat = ev.repeat && ev.repeat !== 'none' ? ev.repeat : undefined;
+    if (repeat) {
+        lines.push('');
+        // repeat is an enum in our model, but sanitize anyway to be safe.
+        pushKV(lines, 'repeat', repeat);
+        lines.push(`repeat_interval: ${normalizePositiveInt(ev.repeat_interval, 1)}`);
+        pushKV(lines, 'repeat_until', ev.repeat_until);
+        pushKV(lines, 'byweekday', ev.byweekday);
+        pushKV(lines, 'bymonthday', ev.bymonthday);
+    }
+    if (ev.all_day)
+        lines.push(`all_day: true`);
+    if (ev.uid) {
+        lines.push('');
+        pushKV(lines, 'uid', ev.uid);
+        if (ev.recurrence_id) {
+            pushKV(lines, 'recurrence_id', ev.recurrence_id);
+        }
+    }
+    lines.push('```');
+    return lines.join('\n');
+}
+function buildAlarmBody(eventTitle, eventTimeStr, eventNoteId, todoTitle, uid, rid, when, triggerDesc) {
+    const safeEventTitle = sanitizeForMarkdownBlock(eventTitle);
+    const safeEventTimeStr = sanitizeForMarkdownBlock(eventTimeStr);
+    const safeNoteId = isValidJoplinNoteId(eventNoteId) ? eventNoteId : sanitizeForMarkdownBlock(eventNoteId);
+    const safeWhen = sanitizeForMarkdownBlock(when);
+    const safeTriggerDesc = sanitizeForMarkdownBlock(triggerDesc);
+    return [
+        `[${safeEventTitle} at ${safeEventTimeStr}](:/${safeNoteId})`,
+        '',
+        '```mycalendar-alarm',
+        `title: ${sanitizeForMarkdownBlock(todoTitle).slice(0, MAX_TITLE_LEN)}`,
+        `trigger_desc: ${safeTriggerDesc}`,
+        `when: ${safeWhen}`,
+        `uid: ${sanitizeForMarkdownBlock(uid)}`,
+        `recurrence_id: ${sanitizeForMarkdownBlock(rid)}`,
+        '```',
+        '',
+    ].join('\n');
+}
+
+
+/***/ },
+
+/***/ "./src/main/services/occurrenceService.ts"
+/*!************************************************!*\
+  !*** ./src/main/services/occurrenceService.ts ***!
+  \************************************************/
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+// src/main/services/occurrenceService.ts
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.expandOccurrences = expandOccurrences;
+const dateTimeUtils_1 = __webpack_require__(/*! ../utils/dateTimeUtils */ "./src/main/utils/dateTimeUtils.ts");
+function expandOccurrences(ev, windowStart, windowEnd) {
+    var _a;
+    const start = (0, dateTimeUtils_1.parseMyCalDateToDate)(ev.start);
+    if (!start)
+        return [];
+    const end = (_a = (0, dateTimeUtils_1.parseMyCalDateToDate)(ev.end)) !== null && _a !== void 0 ? _a : new Date(start.getTime());
+    const durMs = end.getTime() - start.getTime();
+    // --- UTC helpers (avoid DST/local timezone shifts) ---
+    const addDaysUtc = (d, days) => {
+        const out = new Date(d.getTime());
+        out.setUTCDate(out.getUTCDate() + days);
+        return out;
+    };
+    const addMonthsUtc = (d, months) => {
+        const out = new Date(d.getTime());
+        out.setUTCMonth(out.getUTCMonth() + months);
+        return out;
+    };
+    // const addYearsUtc = (d: Date, years: number): Date => {
+    //     const out = new Date(d.getTime());
+    //     out.setUTCFullYear(out.getUTCFullYear() + years);
+    //     return out;
+    // };
+    const setTimeOfDayUtc = (d, base) => {
+        d.setUTCHours(base.getUTCHours(), base.getUTCMinutes(), base.getUTCSeconds(), 0);
+    };
+    const until = (0, dateTimeUtils_1.parseMyCalDateToDate)(ev.repeat_until);
+    const hardEnd = until && until.getTime() < windowEnd.getTime() ? until : windowEnd;
+    const interval = ev.repeat_interval && ev.repeat_interval >= 1 ? ev.repeat_interval : 1;
+    const occs = [];
+    const pushIfInRange = (s) => {
+        const e = new Date(s.getTime() + durMs);
+        if (s.getTime() > hardEnd.getTime())
+            return;
+        if (e.getTime() < windowStart.getTime())
+            return;
+        if (s.getTime() > windowEnd.getTime())
+            return;
+        occs.push({ start: s, end: e, recurrence_id: undefined });
+    };
+    if (!ev.repeat || ev.repeat === 'none') {
+        pushIfInRange(start);
+        return occs;
+    }
+    if (ev.repeat === 'daily') {
+        let cur = new Date(start.getTime());
+        while (cur.getTime() <= hardEnd.getTime()) {
+            pushIfInRange(cur);
+            cur = addDaysUtc(cur, interval);
+        }
+        return sortAndDedupe(occs);
+    }
+    if (ev.repeat === 'weekly') {
+        const days = (ev.byweekday ? ev.byweekday.split(',') : []).map(d => d.trim()).filter(Boolean);
+        const jsDays = (days.length ? days : [['SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA'][start.getUTCDay()]])
+            .map(dateTimeUtils_1.weekdayToJs)
+            .filter((n) => n !== null)
+            .sort((a, b) => a - b);
+        let weekAnchor = new Date(start.getTime());
+        while (weekAnchor.getTime() <= hardEnd.getTime()) {
+            for (const wd of jsDays) {
+                const s = new Date(weekAnchor.getTime());
+                const delta = wd - s.getUTCDay();
+                s.setUTCDate(s.getUTCDate() + delta);
+                setTimeOfDayUtc(s, start);
+                if (s.getTime() < weekAnchor.getTime())
+                    s.setUTCDate(s.getUTCDate() + 7);
+                if (s.getTime() < start.getTime())
+                    continue;
+                pushIfInRange(s);
+            }
+            weekAnchor = addDaysUtc(weekAnchor, 7 * interval);
+        }
+        return sortAndDedupe(occs);
+    }
+    if (ev.repeat === 'monthly') {
+        const day = ev.bymonthday ? parseInt(ev.bymonthday, 10) : start.getUTCDate();
+        // Anchor on the 1st of the month to avoid "rolling" when adding months
+        let anchor = new Date(start.getTime());
+        anchor.setUTCDate(1);
+        while (anchor.getTime() <= hardEnd.getTime()) {
+            const targetMonth = anchor.getUTCMonth();
+            const s = new Date(anchor.getTime());
+            s.setUTCDate(day);
+            setTimeOfDayUtc(s, start);
+            // If day does not exist in this month, JS will "roll" the date to another month.
+            // According to the expected behavior of the RRULE, such instances should be skipped.
+            if (s.getUTCMonth() === targetMonth) {
+                if (s.getTime() >= start.getTime())
+                    pushIfInRange(s);
+            }
+            anchor = addMonthsUtc(anchor, interval);
+            anchor.setUTCDate(1);
+        }
+        return sortAndDedupe(occs);
+    }
+    if (ev.repeat === 'yearly') {
+        const baseMonth = start.getUTCMonth();
+        const baseDay = start.getUTCDate();
+        const h = start.getUTCHours();
+        const m = start.getUTCMinutes();
+        const sec = start.getUTCSeconds();
+        let year = start.getFullYear();
+        while (true) {
+            const s = new Date(start.getTime());
+            s.setFullYear(year);
+            s.setUTCHours(h, m, sec, 0);
+            // February 29 will "roll over" in a non-leap year - we skip such instances
+            if (s.getUTCMonth() === baseMonth && s.getUTCDate() === baseDay) {
+                if (s.getTime() > hardEnd.getTime())
+                    break;
+                pushIfInRange(s);
+            }
+            else {
+                // even if the date is invalid, a hardEnd stop is still required
+                // we make a conservative check: if we have already "jumped" far ahead
+                if (s.getTime() > hardEnd.getTime() && year !== start.getFullYear())
+                    break;
+            }
+            year += interval;
+        }
+        return sortAndDedupe(occs);
+    }
+    return sortAndDedupe(occs);
+}
+function sortAndDedupe(list) {
+    const sorted = [...list].sort((a, b) => a.start.getTime() - b.start.getTime());
+    const out = [];
+    let prev = null;
+    for (const o of sorted) {
+        const t = o.start.getTime();
+        if (prev === t)
+            continue;
+        out.push(o);
+        prev = t;
+    }
+    return out;
+}
+
+
+/***/ },
+
+/***/ "./src/main/settings/settings.ts"
+/*!***************************************!*\
+  !*** ./src/main/settings/settings.ts ***!
+  \***************************************/
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+// src/main/settings/settings.ts
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.SETTING_ICS_EXPORT_LINK4_URL = exports.SETTING_ICS_EXPORT_LINK4_TITLE = exports.SETTING_ICS_EXPORT_LINK3_URL = exports.SETTING_ICS_EXPORT_LINK3_TITLE = exports.SETTING_ICS_EXPORT_LINK2_URL = exports.SETTING_ICS_EXPORT_LINK2_TITLE = exports.SETTING_ICS_EXPORT_LINK1_URL = exports.SETTING_ICS_EXPORT_LINK1_TITLE = exports.SETTING_ICS_IMPORT_EMPTY_TRASH_AFTER = exports.SETTING_ICS_IMPORT_ALARM_RANGE_DAYS = exports.SETTING_ICS_IMPORT_ALARMS_ENABLED = exports.SETTING_DAY_EVENTS_REFRESH_MINUTES = exports.SETTING_SHOW_EVENT_TIMELINE = exports.SETTING_WEEK_START = exports.SETTING_DEBUG = void 0;
+exports.sanitizeExternalUrl = sanitizeExternalUrl;
+exports.sanitizeTitle = sanitizeTitle;
+exports.registerSettings = registerSettings;
+exports.getDebugEnabled = getDebugEnabled;
+exports.getWeekStart = getWeekStart;
+exports.getShowEventTimeline = getShowEventTimeline;
+exports.getDayEventsRefreshMinutes = getDayEventsRefreshMinutes;
+exports.getIcsImportAlarmsEnabled = getIcsImportAlarmsEnabled;
+exports.getIcsImportAlarmRangeDays = getIcsImportAlarmRangeDays;
+exports.getIcsImportEmptyTrashAfter = getIcsImportEmptyTrashAfter;
+exports.getIcsExportLinks = getIcsExportLinks;
+const logger_1 = __webpack_require__(/*! ../utils/logger */ "./src/main/utils/logger.ts");
+// Common
+exports.SETTING_DEBUG = 'mycalendar.debug';
+// Calendar
+exports.SETTING_WEEK_START = 'mycalendar.weekStart';
+// Day events
+exports.SETTING_SHOW_EVENT_TIMELINE = 'mycalendar.showEventTimeline';
+exports.SETTING_DAY_EVENTS_REFRESH_MINUTES = 'mycalendar.dayEventsRefreshMinutes';
+// ICS Import
+exports.SETTING_ICS_IMPORT_ALARMS_ENABLED = 'mycalendar.icsImportAlarmsEnabled';
+exports.SETTING_ICS_IMPORT_ALARM_RANGE_DAYS = 'mycalendar.icsImportAlarmRangeDays';
+exports.SETTING_ICS_IMPORT_EMPTY_TRASH_AFTER = 'mycalendar.icsImportEmptyTrashAfter';
+// Export links
+// New multi-link settings (up to 4). Titles are optional.
+exports.SETTING_ICS_EXPORT_LINK1_TITLE = 'mycalendar.icsExportLink1Title';
+exports.SETTING_ICS_EXPORT_LINK1_URL = 'mycalendar.icsExportLink1Url';
+exports.SETTING_ICS_EXPORT_LINK2_TITLE = 'mycalendar.icsExportLink2Title';
+exports.SETTING_ICS_EXPORT_LINK2_URL = 'mycalendar.icsExportLink2Url';
+exports.SETTING_ICS_EXPORT_LINK3_TITLE = 'mycalendar.icsExportLink3Title';
+exports.SETTING_ICS_EXPORT_LINK3_URL = 'mycalendar.icsExportLink3Url';
+exports.SETTING_ICS_EXPORT_LINK4_TITLE = 'mycalendar.icsExportLink4Title';
+exports.SETTING_ICS_EXPORT_LINK4_URL = 'mycalendar.icsExportLink4Url';
+const TITLE_MAX_LEN = 60;
+// Avoid magic numbers for setting item types (Joplin: int=1, string=2, bool=3)
+const SETTING_TYPE_INT = 1;
+const SETTING_TYPE_STRING = 2;
+const SETTING_TYPE_BOOL = 3;
+const ICS_EXPORT_LINK_PAIRS = [
+    { titleKey: exports.SETTING_ICS_EXPORT_LINK1_TITLE, urlKey: exports.SETTING_ICS_EXPORT_LINK1_URL },
+    { titleKey: exports.SETTING_ICS_EXPORT_LINK2_TITLE, urlKey: exports.SETTING_ICS_EXPORT_LINK2_URL },
+    { titleKey: exports.SETTING_ICS_EXPORT_LINK3_TITLE, urlKey: exports.SETTING_ICS_EXPORT_LINK3_URL },
+    { titleKey: exports.SETTING_ICS_EXPORT_LINK4_TITLE, urlKey: exports.SETTING_ICS_EXPORT_LINK4_URL },
+];
+const ICS_EXPORT_URL_KEYS = ICS_EXPORT_LINK_PAIRS.map(p => p.urlKey);
+const ICS_EXPORT_TITLE_KEYS = ICS_EXPORT_LINK_PAIRS.map(p => p.titleKey);
+function sanitizeExternalUrl(input) {
+    const s = String(input !== null && input !== void 0 ? input : '').trim();
+    if (!s)
+        return '';
+    try {
+        const u = new URL(s);
+        // Allow only http(s) links to avoid `javascript:`, `file:`, etc.
+        if (u.protocol !== 'https:' && u.protocol !== 'http:')
+            return '';
+        return u.toString();
+    }
+    catch (_a) {
+        return '';
+    }
+}
+function sanitizeTitle(input) {
+    const s = String(input !== null && input !== void 0 ? input : '').trim();
+    // Keep it short to avoid breaking the layout.
+    if (!s)
+        return '';
+    return s.length > TITLE_MAX_LEN ? s.slice(0, TITLE_MAX_LEN) : s;
+}
+function isMobile(joplin) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const v = yield joplin.versionInfo();
+            return (v === null || v === void 0 ? void 0 : v.platform) === 'mobile';
+        }
+        catch (_a) {
+            return false; // if the API is old/not available - consider desktop
+        }
+    });
+}
+function registerSettings(joplin) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d;
+        if (!((_a = joplin === null || joplin === void 0 ? void 0 : joplin.settings) === null || _a === void 0 ? void 0 : _a.registerSection) || !((_b = joplin === null || joplin === void 0 ? void 0 : joplin.settings) === null || _b === void 0 ? void 0 : _b.registerSettings))
+            return;
+        // ---- Calendar ----------------------------------------------------------
+        yield joplin.settings.registerSection('mycalendar', {
+            label: 'My Calendar',
+            iconName: 'fas fa-calendar',
+        });
+        const mobile = yield isMobile(joplin);
+        yield joplin.settings.registerSettings({
+            // 1) Calendar
+            // 2) Week starts on
+            [exports.SETTING_WEEK_START]: {
+                value: 'monday',
+                type: SETTING_TYPE_STRING, // string
+                section: 'mycalendar',
+                public: true,
+                label: 'Week starts on',
+                description: 'Calendar section: First day of week in calendar grid. Monday or Sunday. Monday as default.',
+                isEnum: true,
+                options: {
+                    monday: 'Monday',
+                    sunday: 'Sunday',
+                },
+            },
+            // 4) Day events
+            [exports.SETTING_SHOW_EVENT_TIMELINE]: {
+                value: true,
+                type: SETTING_TYPE_BOOL, // bool
+                section: 'mycalendar',
+                public: true,
+                label: 'Show event timeline',
+                description: 'Day events section: Show a visual timeline bar under each event in the day list. Disabling this also stops related UI update timers (now dot / past status refresh).',
+            },
+            // 5) Day events auto-refresh (minutes)
+            [exports.SETTING_DAY_EVENTS_REFRESH_MINUTES]: {
+                value: 1,
+                type: SETTING_TYPE_INT, // int
+                section: 'mycalendar',
+                public: true,
+                label: 'Day events auto-refresh (minutes)',
+                description: 'Day events section: How often the list refreshes.',
+            },
+            // 7) ICS Import
+            [exports.SETTING_ICS_IMPORT_ALARMS_ENABLED]: {
+                value: false,
+                type: SETTING_TYPE_BOOL, // bool
+                section: 'mycalendar',
+                public: !mobile,
+                label: 'Enable ICS import alarms',
+                description: 'ICS import section: If enabled, alarms from ICS files will be imported as Todo notes. If disabled, existing alarms will be deleted on re-import.',
+            },
+            [exports.SETTING_ICS_IMPORT_ALARM_RANGE_DAYS]: {
+                value: 30,
+                type: SETTING_TYPE_INT, // int
+                section: 'mycalendar',
+                public: !mobile,
+                label: 'ICS import alarm range (days)',
+                description: 'ICS import section: Import events alarms from now up to N days ahead. Default 30. During reimport all alarms will regenerated.',
+            },
+            [exports.SETTING_ICS_IMPORT_EMPTY_TRASH_AFTER]: {
+                value: false,
+                type: SETTING_TYPE_BOOL, // bool
+                section: 'mycalendar',
+                public: !mobile,
+                label: 'Empty trash after alarm cleanup',
+                description: 'ICS import section: If enabled, the plugin will empty the trash after deleting old alarms. WARNING: This deletes ALL items in the trash.',
+            },
+            // 8) ICS export links (up to 4)
+            [exports.SETTING_ICS_EXPORT_LINK1_TITLE]: {
+                value: '',
+                type: SETTING_TYPE_STRING, // string
+                section: 'mycalendar',
+                public: !mobile,
+                label: 'ICS export link 1 title',
+                description: 'ICS import section: Optional title for export link #1 (shown on button).',
+            },
+            [exports.SETTING_ICS_EXPORT_LINK1_URL]: {
+                value: '',
+                type: SETTING_TYPE_STRING, // string
+                section: 'mycalendar',
+                public: !mobile,
+                label: 'ICS export link 1 URL',
+                description: 'ICS import section: Optional URL for export link #1 (http/https only).',
+            },
+            [exports.SETTING_ICS_EXPORT_LINK2_TITLE]: {
+                value: '',
+                type: SETTING_TYPE_STRING,
+                section: 'mycalendar',
+                public: !mobile,
+                label: 'ICS export link 2 title',
+                description: 'ICS import section: Optional title for export link #2 (shown on button).',
+            },
+            [exports.SETTING_ICS_EXPORT_LINK2_URL]: {
+                value: '',
+                type: SETTING_TYPE_STRING,
+                section: 'mycalendar',
+                public: !mobile,
+                label: 'ICS export link 2 URL',
+                description: 'ICS import section: Optional URL for export link #2 (http/https only).',
+            },
+            [exports.SETTING_ICS_EXPORT_LINK3_TITLE]: {
+                value: '',
+                type: SETTING_TYPE_STRING,
+                section: 'mycalendar',
+                public: !mobile,
+                label: 'ICS export link 3 title',
+                description: 'ICS import section: Optional title for export link #3 (shown on button).',
+            },
+            [exports.SETTING_ICS_EXPORT_LINK3_URL]: {
+                value: '',
+                type: SETTING_TYPE_STRING,
+                section: 'mycalendar',
+                public: !mobile,
+                label: 'ICS export link 3 URL',
+                description: 'ICS import section: Optional URL for export link #3 (http/https only).',
+            },
+            [exports.SETTING_ICS_EXPORT_LINK4_TITLE]: {
+                value: '',
+                type: SETTING_TYPE_STRING,
+                section: 'mycalendar',
+                public: !mobile,
+                label: 'ICS export link 4 title',
+                description: 'ICS import section: Optional title for export link #4 (shown on button).',
+            },
+            [exports.SETTING_ICS_EXPORT_LINK4_URL]: {
+                value: '',
+                type: SETTING_TYPE_STRING,
+                section: 'mycalendar',
+                public: !mobile,
+                label: 'ICS export link 4 URL',
+                description: 'ICS import section: Optional URL for export link #4 (http/https only).',
+            },
+            // 10) Developer
+            // 11) Enable debug logging
+            [exports.SETTING_DEBUG]: {
+                value: false,
+                type: SETTING_TYPE_BOOL, // bool
+                section: 'mycalendar',
+                public: true,
+                label: 'Enable debug logging',
+                description: 'Enable visible in the interface extra logging to help debugging.',
+            },
+        });
+        // Keep stored URLs safe even if user pastes `javascript:` etc.
+        if (typeof ((_c = joplin === null || joplin === void 0 ? void 0 : joplin.settings) === null || _c === void 0 ? void 0 : _c.onChange) === 'function' && typeof ((_d = joplin === null || joplin === void 0 ? void 0 : joplin.settings) === null || _d === void 0 ? void 0 : _d.setValue) === 'function') {
+            yield joplin.settings.onChange((event) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const keys = (event === null || event === void 0 ? void 0 : event.keys) || [];
+                    const maybeFixUrl = (key) => __awaiter(this, void 0, void 0, function* () {
+                        const raw = yield joplin.settings.value(key);
+                        const safe = sanitizeExternalUrl(raw);
+                        if (raw !== safe)
+                            yield joplin.settings.setValue(key, safe);
+                    });
+                    const maybeFixTitle = (key) => __awaiter(this, void 0, void 0, function* () {
+                        const raw = yield joplin.settings.value(key);
+                        const safe = sanitizeTitle(raw);
+                        if (raw !== safe)
+                            yield joplin.settings.setValue(key, safe);
+                    });
+                    const touchedUrl = ICS_EXPORT_URL_KEYS.some((k) => keys.includes(k));
+                    const touchedTitle = ICS_EXPORT_TITLE_KEYS.some((k) => keys.includes(k));
+                    const touchedDebug = keys.includes(exports.SETTING_DEBUG);
+                    if (!touchedUrl && !touchedTitle && !touchedDebug)
+                        return;
+                    for (const k of ICS_EXPORT_URL_KEYS) {
+                        if (keys.includes(k))
+                            yield maybeFixUrl(k);
+                    }
+                    for (const k of ICS_EXPORT_TITLE_KEYS) {
+                        if (keys.includes(k))
+                            yield maybeFixTitle(k);
+                    }
+                    if (touchedDebug) {
+                        const v = yield joplin.settings.value(exports.SETTING_DEBUG);
+                        (0, logger_1.setDebugEnabled)(!!v);
+                    }
+                }
+                catch (_a) {
+                    // ignore
+                }
+            }));
+        }
+        const v = yield joplin.settings.value(exports.SETTING_DEBUG);
+        (0, logger_1.setDebugEnabled)(!!v);
+    });
+}
+// Common
+function getDebugEnabled(joplin) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return !!(yield joplin.settings.value(exports.SETTING_DEBUG));
+    });
+}
+// Calendar
+function getWeekStart(joplin) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const raw = yield joplin.settings.value(exports.SETTING_WEEK_START);
+        const v = String(raw !== null && raw !== void 0 ? raw : '').toLowerCase().trim();
+        return (v === 'sunday' || v === 'monday') ? v : 'monday';
+    });
+}
+// Day events
+function getShowEventTimeline(joplin) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const raw = yield joplin.settings.value(exports.SETTING_SHOW_EVENT_TIMELINE);
+        // Default should be true even if the setting is missing/undefined (older installs / migrations)
+        if (raw === null || raw === undefined)
+            return true;
+        return Boolean(raw);
+    });
+}
+function getDayEventsRefreshMinutes(joplin) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const raw = yield joplin.settings.value(exports.SETTING_DAY_EVENTS_REFRESH_MINUTES);
+        const n = Number(raw);
+        if (!Number.isFinite(n))
+            return 1;
+        return Math.min(60, Math.max(1, Math.round(n)));
+    });
+}
+// ICS import
+function getIcsImportAlarmsEnabled(joplin) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return !!(yield joplin.settings.value(exports.SETTING_ICS_IMPORT_ALARMS_ENABLED));
+    });
+}
+function getIcsImportAlarmRangeDays(joplin) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const raw = yield joplin.settings.value(exports.SETTING_ICS_IMPORT_ALARM_RANGE_DAYS);
+        if (raw === null || raw === undefined) {
+            return 30;
+        }
+        const n = Number(raw);
+        if (!Number.isFinite(n)) {
+            return 30;
+        }
+        // Guardrails: keep the import range reasonable.
+        // If user entered 0, we clamp to 1.
+        return Math.min(365, Math.max(1, Math.round(n)));
+    });
+}
+function getIcsImportEmptyTrashAfter(joplin) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return !!(yield joplin.settings.value(exports.SETTING_ICS_IMPORT_EMPTY_TRASH_AFTER));
+    });
+}
+function getIcsExportLinks(joplin) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const out = [];
+        for (const p of ICS_EXPORT_LINK_PAIRS) {
+            const rawTitle = yield joplin.settings.value(p.titleKey);
+            const rawUrl = yield joplin.settings.value(p.urlKey);
+            const title = sanitizeTitle(rawTitle);
+            const url = sanitizeExternalUrl(rawUrl);
+            if (!url)
+                continue;
+            out.push({ title, url });
+        }
+        return out;
+    });
+}
+
+
+/***/ },
+
+/***/ "./src/main/uiBridge/panelController.ts"
+/*!**********************************************!*\
+  !*** ./src/main/uiBridge/panelController.ts ***!
+  \**********************************************/
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+// src/main/uiBridge/panelController.ts
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.registerCalendarPanelController = registerCalendarPanelController;
+const eventsCache_1 = __webpack_require__(/*! ../services/eventsCache */ "./src/main/services/eventsCache.ts");
+const icsImportService_1 = __webpack_require__(/*! ../services/icsImportService */ "./src/main/services/icsImportService.ts");
+const toast_1 = __webpack_require__(/*! ../utils/toast */ "./src/main/utils/toast.ts");
+const uiSettings_1 = __webpack_require__(/*! ./uiSettings */ "./src/main/uiBridge/uiSettings.ts");
+const logger_1 = __webpack_require__(/*! ../utils/logger */ "./src/main/utils/logger.ts");
+const settings_1 = __webpack_require__(/*! ../settings/settings */ "./src/main/settings/settings.ts");
+const folderService_1 = __webpack_require__(/*! ../services/folderService */ "./src/main/services/folderService.ts");
+function isoDate(utc) {
+    return new Date(utc).toISOString().slice(0, 10);
+}
+function isNumber(v) {
+    return typeof v === 'number' && Number.isFinite(v);
+}
+function isString(v) {
+    return typeof v === 'string';
+}
+function isRecord(v) {
+    return typeof v === 'object' && v !== null;
+}
+const KNOWN_MSG_NAMES = [
+    'uiReady',
+    'requestRangeEvents',
+    'dateClick',
+    'openNote',
+    'exportRangeIcs',
+    'icsImport',
+    'requestFolders',
+];
+function isKnownMsgName(v) {
+    return isString(v) && KNOWN_MSG_NAMES.includes(v);
+}
+function buildRangeIcsFilename(fromUtc, toUtc) {
+    return `mycalendar_${isoDate(fromUtc)}_${isoDate(toUtc)}.ics`;
+}
+function registerCalendarPanelController(joplin, panel, helpers) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const post = (message) => joplin.views.panels.postMessage(panel, message);
+        yield joplin.views.panels.onMessage(panel, (rawMsg) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!isRecord(rawMsg) || !isKnownMsgName(rawMsg.name))
+                    return;
+                const msg = rawMsg;
+                switch (msg.name) {
+                    case 'uiReady': {
+                        yield (0, uiSettings_1.pushUiSettings)(joplin, panel);
+                        yield post({ name: 'redrawMonth' });
+                        return;
+                    }
+                    case 'requestRangeEvents': {
+                        if (!isNumber(msg.fromUtc) || !isNumber(msg.toUtc))
+                            return;
+                        const all = yield (0, eventsCache_1.ensureAllEventsCache)(joplin);
+                        const list = helpers.expandAllInRange(all, msg.fromUtc, msg.toUtc);
+                        yield post({ name: 'rangeEvents', events: list });
+                        return;
+                    }
+                    case 'dateClick': {
+                        if (!isNumber(msg.dateUtc))
+                            return;
+                        const dayStart = msg.dateUtc;
+                        const dayEnd = dayStart + 24 * 60 * 60 * 1000 - 1;
+                        const all = yield (0, eventsCache_1.ensureAllEventsCache)(joplin);
+                        const list = helpers
+                            .expandAllInRange(all, dayStart, dayEnd)
+                            .filter((e) => isNumber(e === null || e === void 0 ? void 0 : e.startUtc) && e.startUtc >= dayStart && e.startUtc <= dayEnd);
+                        yield post({
+                            name: 'showEvents',
+                            dateUtc: msg.dateUtc,
+                            events: list,
+                        });
+                        return;
+                    }
+                    case 'openNote': {
+                        if (msg.id) {
+                            yield joplin.commands.execute('openNote', msg.id);
+                        }
+                        return;
+                    }
+                    case 'exportRangeIcs': {
+                        if (!isNumber(msg.fromUtc) || !isNumber(msg.toUtc))
+                            return;
+                        const all = yield (0, eventsCache_1.ensureAllEventsCache)(joplin);
+                        const list = helpers.expandAllInRange(all, msg.fromUtc, msg.toUtc);
+                        const ics = helpers.buildICS(list);
+                        yield post({
+                            name: 'rangeIcs',
+                            ics,
+                            filename: buildRangeIcsFilename(msg.fromUtc, msg.toUtc),
+                        });
+                        return;
+                    }
+                    case 'icsImport': {
+                        const sendStatus = (text) => __awaiter(this, void 0, void 0, function* () {
+                            yield post({ name: 'importStatus', text });
+                            yield (0, toast_1.showToast)('info', text, 5000);
+                        });
+                        try {
+                            if (!isString(msg.ics) || msg.ics.length === 0) {
+                                const errText = 'Missing ICS content';
+                                yield post({ name: 'importError', error: errText });
+                                yield (0, toast_1.showToast)('error', `ICS import failed: ${errText}`, 5000);
+                                return;
+                            }
+                            const targetFolderId = isString(msg.targetFolderId) ? msg.targetFolderId : undefined;
+                            const preserveLocalColor = msg.preserveLocalColor !== false;
+                            const importDefaultColor = isString(msg.importDefaultColor) && /^#[0-9a-fA-F]{6}$/.test(msg.importDefaultColor)
+                                ? msg.importDefaultColor
+                                : undefined;
+                            const importAlarmRangeDays = yield (0, settings_1.getIcsImportAlarmRangeDays)(joplin);
+                            const res = yield (0, icsImportService_1.importIcsIntoNotes)(joplin, msg.ics, sendStatus, targetFolderId, preserveLocalColor, importDefaultColor, importAlarmRangeDays);
+                            (0, eventsCache_1.invalidateAllEventsCache)();
+                            yield post(Object.assign({ name: 'importDone' }, res));
+                            const doneText = `ICS import finished: added=${res.added}, updated=${res.updated}, skipped=${res.skipped}, errors=${res.errors}, alarmsCreated=${res.alarmsCreated}, alarmsDeleted=${res.alarmsDeleted}`;
+                            yield (0, toast_1.showToast)(res.errors > 0 ? 'warning' : 'success', doneText, 5000);
+                        }
+                        catch (e) {
+                            const errText = String((e === null || e === void 0 ? void 0 : e.message) || e);
+                            yield post({ name: 'importError', error: errText });
+                            yield (0, toast_1.showToast)('error', `ICS import failed: ${errText}`, 5000);
+                        }
+                        return;
+                    }
+                    case 'requestFolders': {
+                        const rows = yield (0, folderService_1.getAllFolders)(joplin);
+                        const folders = (0, folderService_1.flattenFolderTree)(rows);
+                        yield post({ name: 'folders', folders });
+                        return;
+                    }
+                    default:
+                        return;
+                }
+            }
+            catch (e) {
+                (0, logger_1.err)('panelController', 'onMessage error:', e);
+            }
+        }));
+    });
+}
+
+
+/***/ },
+
+/***/ "./src/main/uiBridge/uiSettings.ts"
+/*!*****************************************!*\
+  !*** ./src/main/uiBridge/uiSettings.ts ***!
+  \*****************************************/
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+// src/main/uiBridge/uiSettings.ts
+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;
+    };
+})();
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.UI_SETTINGS_MESSAGE_NAME = void 0;
+exports.buildUiSettingsMessage = buildUiSettingsMessage;
+exports.pushUiSettings = pushUiSettings;
+const settings = __importStar(__webpack_require__(/*! ../settings/settings */ "./src/main/settings/settings.ts"));
+const logger_1 = __webpack_require__(/*! ../utils/logger */ "./src/main/utils/logger.ts");
+exports.UI_SETTINGS_MESSAGE_NAME = 'uiSettings';
+function getIcsExportLinksCompat(joplin) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const s = settings;
+        return typeof s.getIcsExportLinks === 'function' ? yield s.getIcsExportLinks(joplin) : [];
+    });
+}
+/**
+ * Reads UI-relevant settings from the main process.
+ * Separated for easier unit testing and future reuse.
+ */
+function buildUiSettingsMessage(joplin) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [weekStart, debugRaw, icsExportLinks, dayEventsRefreshMinutes, showEventTimeline] = yield Promise.all([
+            settings.getWeekStart(joplin),
+            settings.getDebugEnabled(joplin),
+            getIcsExportLinksCompat(joplin),
+            settings.getDayEventsRefreshMinutes(joplin),
+            settings.getShowEventTimeline(joplin),
+        ]);
+        const debugEnabled = Boolean(debugRaw);
+        // Main-side logger should follow the same setting
+        (0, logger_1.setDebugEnabled)(debugEnabled);
+        return {
+            name: exports.UI_SETTINGS_MESSAGE_NAME,
+            weekStart,
+            debug: debugEnabled,
+            icsExportLinks,
+            dayEventsRefreshMinutes,
+            showEventTimeline,
+        };
+    });
+}
+function pushUiSettings(joplin, panel) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const message = yield buildUiSettingsMessage(joplin);
+        const pm = (_b = (_a = joplin === null || joplin === void 0 ? void 0 : joplin.views) === null || _a === void 0 ? void 0 : _a.panels) === null || _b === void 0 ? void 0 : _b.postMessage;
+        if (typeof pm !== 'function')
+            return;
+        yield pm(panel, message);
+    });
+}
+
+
+/***/ },
+
+/***/ "./src/main/utils/dateTimeUtils.ts"
+/*!*****************************************!*\
+  !*** ./src/main/utils/dateTimeUtils.ts ***!
+  \*****************************************/
+(__unused_webpack_module, exports) {
+
+
+// src/main/utils/dateTimeUtils.ts
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.parseIsoDurationToMs = parseIsoDurationToMs;
+exports.parseMyCalDateToDate = parseMyCalDateToDate;
+exports.formatAlarmTitleTime = formatAlarmTitleTime;
+exports.addDays = addDays;
+exports.addMonths = addMonths;
+exports.addYears = addYears;
+exports.weekdayToJs = weekdayToJs;
+exports.formatDateForAlarm = formatDateForAlarm;
+exports.icsDateToMyCalText = icsDateToMyCalText;
+exports.computeAlarmWhen = computeAlarmWhen;
+exports.formatTriggerDescription = formatTriggerDescription;
+const MS_PER_SECOND = 1000;
+const MS_PER_MINUTE = 60 * MS_PER_SECOND;
+const MS_PER_HOUR = 60 * MS_PER_MINUTE;
+const MS_PER_DAY = 24 * MS_PER_HOUR;
+const WEEKDAY_TO_JS = {
+    SU: 0,
+    MO: 1,
+    TU: 2,
+    WE: 3,
+    TH: 4,
+    FR: 5,
+    SA: 6,
+};
+const pad2 = (n) => String(n).padStart(2, '0');
+function parseIsoDurationToMs(s) {
+    const t = s.trim().toUpperCase();
+    if (!t)
+        return null;
+    const sign = t.startsWith('-') ? -1 : 1;
+    const core = t.startsWith('-') || t.startsWith('+') ? t.slice(1) : t;
+    // Supported subset: PnWnDTnHnMnS (no months/years)
+    const m = core.match(/^P(?:(\d+)W)?(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?)?$/);
+    if (!m)
+        return null;
+    const parts = m.slice(1);
+    // Reject bare "P" / "PT" (no components)
+    if (parts.every(v => v == null))
+        return null;
+    const w = m[1] ? Number(m[1]) : 0;
+    const d = m[2] ? Number(m[2]) : 0;
+    const h = m[3] ? Number(m[3]) : 0;
+    const mi = m[4] ? Number(m[4]) : 0;
+    const se = m[5] ? Number(m[5]) : 0;
+    if (![w, d, h, mi, se].every(n => Number.isFinite(n)))
+        return null;
+    const ms = (w * 7 + d) * MS_PER_DAY +
+        h * MS_PER_HOUR +
+        mi * MS_PER_MINUTE +
+        se * MS_PER_SECOND;
+    return sign * ms;
+}
+function parseMyCalDateToDate(s) {
+    if (!s)
+        return null;
+    const t = s.trim();
+    if (!t)
+        return null;
+    // Accept either "YYYY-MM-DD HH:mm:ss(+00:00)" or ISO-like forms.
+    const iso = t.replace(' ', 'T');
+    const d = new Date(iso);
+    return Number.isNaN(d.getTime()) ? null : d;
+}
+function formatAlarmTitleTime(d) {
+    // Intentionally local time (UI/notification title)
+    return `${d.getFullYear()}-${pad2(d.getMonth() + 1)}-${pad2(d.getDate())} ${pad2(d.getHours())}:${pad2(d.getMinutes())}`;
+}
+function addDays(d, days) {
+    const out = new Date(d.getTime());
+    // Use UTC variants to avoid DST/timezone shifts when input is a UTC instant.
+    out.setUTCDate(out.getUTCDate() + days);
+    return out;
+}
+function addMonths(d, months) {
+    const out = new Date(d.getTime());
+    out.setUTCMonth(out.getUTCMonth() + months);
+    return out;
+}
+function addYears(d, years) {
+    const out = new Date(d.getTime());
+    out.setUTCFullYear(out.getUTCFullYear() + years);
+    return out;
+}
+function weekdayToJs(day) {
+    const d = day.trim().toUpperCase();
+    return Object.prototype.hasOwnProperty.call(WEEKDAY_TO_JS, d) ? WEEKDAY_TO_JS[d] : null;
+}
+function formatDateForAlarm(d) {
+    return `${d.getUTCFullYear()}-${pad2(d.getUTCMonth() + 1)}-${pad2(d.getUTCDate())} ${pad2(d.getUTCHours())}:${pad2(d.getUTCMinutes())}:${pad2(d.getUTCSeconds())}+00:00`;
+}
+function icsDateToMyCalText(icsValue) {
+    if (!icsValue)
+        return undefined;
+    const raw = icsValue.trim();
+    if (!raw)
+        return undefined;
+    // normalize trailing "z" -> "Z"
+    const v = raw.endsWith('z') ? `${raw.slice(0, -1)}Z` : raw;
+    // YYYYMMDDTHHMMSSZ
+    let m = v.match(/^(\d{4})(\d{2})(\d{2})T(\d{2})(\d{2})(\d{2})Z$/);
+    if (m)
+        return `${m[1]}-${m[2]}-${m[3]} ${m[4]}:${m[5]}:${m[6]}+00:00`;
+    // YYYYMMDDTHHMMSS
+    m = v.match(/^(\d{4})(\d{2})(\d{2})T(\d{2})(\d{2})(\d{2})$/);
+    if (m)
+        return `${m[1]}-${m[2]}-${m[3]} ${m[4]}:${m[5]}:${m[6]}`;
+    // YYYYMMDD (all-day)
+    m = v.match(/^(\d{4})(\d{2})(\d{2})$/);
+    if (m)
+        return `${m[1]}-${m[2]}-${m[3]} 00:00:00`;
+    // Already ISO-like -> normalize "T" to space
+    if (/^\d{4}-\d{2}-\d{2}/.test(v))
+        return v.replace('T', ' ');
+    return undefined;
+}
+function computeAlarmWhen(alarm, occ) {
+    const trig = alarm.trigger.trim();
+    if (!trig)
+        return null;
+    const abs = icsDateToMyCalText(trig);
+    if (abs)
+        return parseMyCalDateToDate(abs);
+    const delta = parseIsoDurationToMs(trig);
+    if (delta === null)
+        return null;
+    const base = alarm.related === 'END' ? occ.end : occ.start;
+    return new Date(base.getTime() + delta);
+}
+function formatTriggerDescription(trigger) {
+    const t = trigger.trim().toUpperCase();
+    if (t.startsWith('P') || t.startsWith('-P') || t.startsWith('+P')) {
+        const ms = parseIsoDurationToMs(t);
+        if (ms === null)
+            return t;
+        const isBefore = ms < 0;
+        const absMs = Math.abs(ms);
+        if (ms === 0)
+            return 'at time of event';
+        const mins = Math.floor(absMs / MS_PER_MINUTE);
+        const hours = Math.floor(mins / 60);
+        const days = Math.floor(hours / 24);
+        let timeStr = '';
+        if (days > 0) {
+            timeStr = `${days} day${days > 1 ? 's' : ''}`;
+        }
+        else if (hours > 0) {
+            timeStr = `${hours} hour${hours > 1 ? 's' : ''}`;
+        }
+        else {
+            timeStr = `${mins} minute${mins !== 1 ? 's' : ''}`;
+        }
+        return isBefore ? `${timeStr} before` : `${timeStr} after`;
+    }
+    return 'at specific time';
+}
+
+
+/***/ },
+
+/***/ "./src/main/utils/dateUtils.ts"
+/*!*************************************!*\
+  !*** ./src/main/utils/dateUtils.ts ***!
+  \*************************************/
+(__unused_webpack_module, exports) {
+
+
+// src/main/utils/dateUtils.ts
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.DAY_MS = void 0;
+exports.parseYmdHmsLocal = parseYmdHmsLocal;
+exports.addDaysYMD = addDaysYMD;
+exports.weekdayMon0 = weekdayMon0;
+exports.getPartsInTz = getPartsInTz;
+exports.zonedTimeToUtcMs = zonedTimeToUtcMs;
+exports.DAY_MS = 24 * 60 * 60 * 1000;
+const YMD_HMS_RE = /^\s*(\d{4})-(\d{1,2})-(\d{1,2})(?:[ T]+(\d{1,2})(?::(\d{1,2}))?(?::(\d{1,2}))?)?\s*$/;
+function assertIntInRange(name, v, min, max) {
+    if (!Number.isInteger(v) || v < min || v > max) {
+        throw new Error(`${name} out of range: ${v}`);
+    }
+}
+function isValidUtcDate(Y, M, D) {
+    const dt = new Date(Date.UTC(Y, M - 1, D));
+    return dt.getUTCFullYear() === Y && dt.getUTCMonth() + 1 === M && dt.getUTCDate() === D;
+}
+function parseYmdHmsLocal(s) {
+    // Accepts:
+    //  - "2025-09-01"
+    //  - "2025-09-01 15:30"
+    //  - "2025-09-01 15:30:00"
+    //  - "2025-09-01T15:30:00"
+    const m = s.match(YMD_HMS_RE);
+    if (!m)
+        throw new Error(`Invalid datetime format: "${s}"`);
+    const Y = Number(m[1]);
+    const M = Number(m[2]);
+    const D = Number(m[3]);
+    const h = m[4] != null ? Number(m[4]) : 0;
+    const min = m[5] != null ? Number(m[5]) : 0;
+    const sec = m[6] != null ? Number(m[6]) : 0;
+    assertIntInRange('year', Y, 1, 9999);
+    assertIntInRange('month', M, 1, 12);
+    assertIntInRange('day', D, 1, 31);
+    assertIntInRange('hour', h, 0, 23);
+    assertIntInRange('minute', min, 0, 59);
+    assertIntInRange('second', sec, 0, 59);
+    if (!isValidUtcDate(Y, M, D)) {
+        throw new Error(`Invalid date: ${Y}-${String(M).padStart(2, '0')}-${String(D).padStart(2, '0')}`);
+    }
+    return { Y, M, D, h, m: min, sec };
+}
+function addDaysYMD(Y, M, D, deltaDays) {
+    const dt = new Date(Date.UTC(Y, M - 1, D) + deltaDays * exports.DAY_MS);
+    return { Y: dt.getUTCFullYear(), M: dt.getUTCMonth() + 1, D: dt.getUTCDate() };
+}
+function weekdayMon0(Y, M, D) {
+    // Monday=0..Sunday=6
+    const dowSun0 = new Date(Date.UTC(Y, M - 1, D)).getUTCDay(); // Sun=0
+    return (dowSun0 + 6) % 7;
+}
+function getPartsInTz(msUtc, tz) {
+    const mp = formatToNumberParts(getFmtYmd(tz), msUtc);
+    return { Y: mp.year, M: mp.month, D: mp.day };
+}
+const fmtYmdByTz = new Map();
+const fmtYmdHmsByTz = new Map();
+function getFmtYmd(tz) {
+    const cached = fmtYmdByTz.get(tz);
+    if (cached)
+        return cached;
+    const fmt = new Intl.DateTimeFormat('en-CA', {
+        timeZone: tz,
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour12: false,
+    });
+    fmtYmdByTz.set(tz, fmt);
+    return fmt;
+}
+function getFmtYmdHms(tz) {
+    const cached = fmtYmdHmsByTz.get(tz);
+    if (cached)
+        return cached;
+    const fmt = new Intl.DateTimeFormat('en-CA', {
+        timeZone: tz,
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        second: '2-digit',
+        hour12: false,
+    });
+    fmtYmdHmsByTz.set(tz, fmt);
+    return fmt;
+}
+function formatToNumberParts(fmt, msUtc) {
+    const parts = fmt.formatToParts(new Date(msUtc));
+    const mp = {};
+    for (const p of parts) {
+        if (p.type !== 'literal')
+            mp[p.type] = Number(p.value);
+    }
+    return mp;
+}
+/**
+ * Convert "local datetime in tz" -> UTC ms.
+ *
+ * Notes:
+ * - If the local time does not exist (DST "spring forward" gap), this function throws.
+ * - If the local time is ambiguous (DST "fall back"), it picks the 'earlier' instant by default.
+ */
+function zonedTimeToUtcMs(localY, localM, localD, localH, localMin, localSec, tz, opts = {}) {
+    var _a;
+    const prefer = (_a = opts.prefer) !== null && _a !== void 0 ? _a : 'earlier';
+    const wantAsUtc = Date.UTC(localY, localM - 1, localD, localH, localMin, localSec);
+    const getAsUtcMsAtZoned = (utcMs) => {
+        const mp = formatToNumberParts(getFmtYmdHms(tz), utcMs);
+        return Date.UTC(mp.year, mp.month - 1, mp.day, mp.hour, mp.minute, mp.second);
+    };
+    const getOffsetMsAtUtc = (utcMs) => getAsUtcMsAtZoned(utcMs) - utcMs;
+    const buildCandidate = (offsetMs) => wantAsUtc - offsetMs;
+    // Two-pass (usually enough).
+    const off1 = getOffsetMsAtUtc(wantAsUtc);
+    const utc1 = buildCandidate(off1);
+    const off2 = getOffsetMsAtUtc(utc1);
+    const utc2 = buildCandidate(off2);
+    const mp2 = formatToNumberParts(getFmtYmdHms(tz), utc2);
+    const matches = mp2.year === localY &&
+        mp2.month === localM &&
+        mp2.day === localD &&
+        mp2.hour === localH &&
+        mp2.minute === localMin &&
+        mp2.second === localSec;
+    if (matches) {
+        // Handle potential DST "fall back" ambiguity:
+        // if there are multiple UTC instants that map to the same local wall-clock time,
+        // pick earlier/later based on preference.
+        const matchesLocal = (utcMs) => {
+            const mp = formatToNumberParts(getFmtYmdHms(tz), utcMs);
+            return (mp.year === localY &&
+                mp.month === localM &&
+                mp.day === localD &&
+                mp.hour === localH &&
+                mp.minute === localMin &&
+                mp.second === localSec);
+        };
+        const HOUR_MS = 60 * 60 * 1000;
+        const candidates = new Set([utc2]);
+        // ±1h is sufficient for most DST overlaps; ±2h is a small safety net for rare zones.
+        for (const d of [-2 * HOUR_MS, -HOUR_MS, HOUR_MS, 2 * HOUR_MS]) {
+            const u = utc2 + d;
+            if (matchesLocal(u))
+                candidates.add(u);
+        }
+        if (candidates.size === 1)
+            return utc2;
+        const arr = Array.from(candidates).sort((a, b) => a - b);
+        return prefer === 'earlier' ? arr[0] : arr[arr.length - 1];
+    }
+    throw new Error(`Non-existent local time in ${tz}: ${localY}-${String(localM).padStart(2, '0')}-${String(localD).padStart(2, '0')} ${String(localH).padStart(2, '0')}:${String(localMin).padStart(2, '0')}:${String(localSec).padStart(2, '0')}`);
+}
+
+
+/***/ },
+
+/***/ "./src/main/utils/joplinUtils.ts"
+/*!***************************************!*\
+  !*** ./src/main/utils/joplinUtils.ts ***!
+  \***************************************/
+(__unused_webpack_module, exports) {
+
+
+// src/main/utils/joplinUtils.ts
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.normalizeRecurrenceIdForKey = normalizeRecurrenceIdForKey;
+exports.makeEventKey = makeEventKey;
+exports.parseUidAndRecurrence = parseUidAndRecurrence;
+exports.extractAllAlarmKeysFromBody = extractAllAlarmKeysFromBody;
+exports.extractAllEventKeysFromBody = extractAllEventKeysFromBody;
+exports.replaceEventBlockByKey = replaceEventBlockByKey;
+exports.extractEventColorFromBody = extractEventColorFromBody;
+function normalizeRecurrenceIdForKey(recurrenceId) {
+    const v = (recurrenceId || '').trim();
+    if (!v)
+        return '';
+    // Keep DATE:yyyyMMdd as-is (date-only recurrence instances)
+    if (/^DATE:\d{8}$/i.test(v))
+        return v;
+    // Backward compatible normalization
+    const tzMatch = v.match(/^[^:]+:(\d{8}T\d{6}Z?)$/);
+    if (tzMatch)
+        return tzMatch[1];
+    return v;
+}
+function makeEventKey(uid, recurrenceId) {
+    const u = (uid || '').trim();
+    const rid = normalizeRecurrenceIdForKey(recurrenceId);
+    return `${u}|${rid}`;
+}
+function parseUidAndRecurrence(inner) {
+    var _a, _b;
+    const uidM = inner.match(/^[ \t]*uid[ \t]*:[ \t]*(.*?)[ \t]*$/im);
+    const ridM = inner.match(/^[ \t]*recurrence_id[ \t]*:[ \t]*(.*?)[ \t]*$/im);
+    return {
+        uid: ((_a = uidM === null || uidM === void 0 ? void 0 : uidM[1]) === null || _a === void 0 ? void 0 : _a.trim()) || undefined,
+        recurrence_id: ((_b = ridM === null || ridM === void 0 ? void 0 : ridM[1]) !== null && _b !== void 0 ? _b : '').trim(),
+    };
+}
+function extractAllAlarmKeysFromBody(body) {
+    var _a;
+    const re = /(^|\r?\n)[ \t]*```mycalendar-alarm[ \t]*\r?\n([\s\S]*?)\r?\n[ \t]*```(?=\r?\n|$)/g;
+    const out = [];
+    let m;
+    while ((m = re.exec(body)) !== null) {
+        const inner = m[2] || '';
+        const meta = parseUidAndRecurrence(inner);
+        if (!meta.uid)
+            continue;
+        const rid = ((_a = meta.recurrence_id) !== null && _a !== void 0 ? _a : '').trim();
+        out.push({ key: makeEventKey(meta.uid, rid), uid: meta.uid, recurrence_id: rid });
+    }
+    return out;
+}
+function extractAllEventKeysFromBody(body) {
+    const re = /(^|\r?\n)[ \t]*```mycalendar-event[ \t]*\r?\n([\s\S]*?)\r?\n[ \t]*```(?=\r?\n|$)/g;
+    const keys = [];
+    let m;
+    while ((m = re.exec(body)) !== null) {
+        const inner = m[2] || '';
+        const meta = parseUidAndRecurrence(inner);
+        if (!meta.uid)
+            continue;
+        keys.push(makeEventKey(meta.uid, meta.recurrence_id));
+    }
+    return keys;
+}
+function replaceEventBlockByKey(body, uid, recurrenceId, newBlock) {
+    const targetUid = (uid || '').trim();
+    const targetRid = normalizeRecurrenceIdForKey(recurrenceId);
+    const re = /(^|\r?\n)([ \t]*```mycalendar-event[ \t]*\r?\n[\s\S]*?\r?\n[ \t]*```)(?=\r?\n|$)/g;
+    let changed = false;
+    const out = body.replace(re, (fullMatch, prefixNL, wholeBlock) => {
+        var _a;
+        const innerM = wholeBlock.match(/^[ \t]*```mycalendar-event[ \t]*\r?\n([\s\S]*?)\r?\n[ \t]*```$/);
+        const inner = (_a = innerM === null || innerM === void 0 ? void 0 : innerM[1]) !== null && _a !== void 0 ? _a : '';
+        const meta = parseUidAndRecurrence(inner);
+        const u = (meta.uid || '').trim();
+        const r = normalizeRecurrenceIdForKey(meta.recurrence_id);
+        if (u !== targetUid)
+            return fullMatch;
+        if (!targetRid) {
+            if (!r) {
+                changed = true;
+                return `${prefixNL}${newBlock}`;
+            }
+            return fullMatch;
+        }
+        if (r === targetRid) {
+            changed = true;
+            return `${prefixNL}${newBlock}`;
+        }
+        return fullMatch;
+    });
+    if (changed)
+        return out;
+    const trimmed = (body || '').replace(/\s+$/, '');
+    return (trimmed ? trimmed + '\n\n' : '') + newBlock + '\n';
+}
+function parseColor(inner) {
+    var _a;
+    const m = inner.match(/^\s*color\s*:\s*(.+?)\s*$/im);
+    return (_a = m === null || m === void 0 ? void 0 : m[1]) === null || _a === void 0 ? void 0 : _a.trim();
+}
+function extractEventColorFromBody(body, uid, recurrenceId) {
+    const targetUid = (uid || '').trim();
+    const targetRid = normalizeRecurrenceIdForKey(recurrenceId);
+    const re = /(^|\r?\n)[ \t]*```mycalendar-event[ \t]*\r?\n([\s\S]*?)\r?\n[ \t]*```(?=\r?\n|$)/g;
+    let m;
+    while ((m = re.exec(body)) !== null) {
+        const inner = m[2] || '';
+        const meta = parseUidAndRecurrence(inner);
+        const u = (meta.uid || '').trim();
+        const r = normalizeRecurrenceIdForKey(meta.recurrence_id);
+        if (u !== targetUid)
+            continue;
+        if (!targetRid) {
+            if (!r)
+                return parseColor(inner);
+            continue;
+        }
+        if (r === targetRid)
+            return parseColor(inner);
+    }
+    return undefined;
+}
+
+
+/***/ },
+
+/***/ "./src/main/utils/logger.ts"
+/*!**********************************!*\
+  !*** ./src/main/utils/logger.ts ***!
+  \**********************************/
+(__unused_webpack_module, exports) {
+
+
+// src/main/utils/logger.ts
+/**
+ * Minimal console logger with a fixed prefix.
+ *
+ * Design goals:
+ * - Keep current runtime behavior (string-first vs non-string-first arguments).
+ * - Keep public API stable for existing imports/tests.
+ * - Avoid `any` in public surface; prefer `unknown`.
+ */
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.setDebugEnabled = setDebugEnabled;
+exports.log = log;
+exports.info = info;
+exports.warn = warn;
+exports.err = err;
+exports.dbg = dbg;
+const PREFIX = '[MyCalendar]';
+let debugEnabled = false;
+function setDebugEnabled(v) {
+    debugEnabled = Boolean(v);
+}
+function buildArgs(source, args) {
+    const sourcePrefix = source ? `[${source}]` : '';
+    if (args.length > 0 && typeof args[0] === 'string') {
+        const [msg, ...rest] = args;
+        return [`${PREFIX}${sourcePrefix} ${msg}`, ...rest];
+    }
+    return [PREFIX + sourcePrefix, ...args];
+}
+function write(consoleFn, source, args) {
+    consoleFn(...buildArgs(source, args));
+}
+function log(source, ...args) {
+    write(console.log, source, args);
+}
+function info(source, ...args) {
+    write(console.info, source, args);
+}
+function warn(source, ...args) {
+    write(console.warn, source, args);
+}
+/** Prefer `err` for backward-compatibility with existing code. */
+function err(source, ...args) {
+    write(console.error, source, args);
+}
+/** Debug log (enabled via `setDebugEnabled(true)`). */
+function dbg(source, ...args) {
+    if (!debugEnabled)
+        return;
+    write(console.log, source, args);
+}
+
+
+/***/ },
+
+/***/ "./src/main/utils/toast.ts"
+/*!*********************************!*\
+  !*** ./src/main/utils/toast.ts ***!
+  \*********************************/
+(__unused_webpack_module, exports) {
+
+
+// src/main/utils/toast.ts
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.DEFAULT_TOAST_DURATION_MS = void 0;
+exports.showToast = showToast;
+exports.DEFAULT_TOAST_DURATION_MS = 3000;
+function getDialogs() {
+    // Joplin typings can lag, so we're doing a narrow cast here, in one place.
+    return joplin.views.dialogs;
+}
+function showToast(type_1, message_1) {
+    return __awaiter(this, arguments, void 0, function* (type, message, duration = exports.DEFAULT_TOAST_DURATION_MS) {
+        const dialogs = getDialogs();
+        // Easy normalization (does not change test logic and current behavior).
+        const safeDuration = Number.isFinite(duration) ? Math.trunc(duration) : exports.DEFAULT_TOAST_DURATION_MS;
+        yield dialogs.showToast({
+            type,
+            message,
+            duration: safeDuration,
+            // timestamp helps if Joplin doesn't show a duplicate of the same toast.
+            timestamp: Date.now(),
+        });
+    });
+}
+
+
+/***/ },
+
+/***/ "./src/main/views/calendarView.ts"
+/*!****************************************!*\
+  !*** ./src/main/views/calendarView.ts ***!
+  \****************************************/
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+// src/main/views/calendarView.ts
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.CALENDAR_PANEL_SCRIPTS = exports.CALENDAR_PANEL_HTML = exports.CALENDAR_PANEL_ID = void 0;
+exports.createCalendarPanel = createCalendarPanel;
+const logger_1 = __webpack_require__(/*! ../utils/logger */ "./src/main/utils/logger.ts");
+exports.CALENDAR_PANEL_ID = 'mycalendarPanel';
+exports.CALENDAR_PANEL_HTML = `
+<div id="cal-root">
+  <div id="mc-toolbar"></div>
+  <!-- CALENDAR -->
+  <div id="mc-grid"></div>
+  <!-- EVENTS OF THE DAY -->
+  <div id="mc-events">
+    <div class="mc-events-header">
+      <span>Day events</span>
+      <span id="mc-events-day-label"></span>
+     </div>
+    <ul id="mc-events-list"></ul>
+  </div>
+  <!-- IMPORT (SEPARATE BLOCK BELOW) -->
+  <div id="mc-import">
+    <div class="mc-import-header">ICS import</div>
+    <div id="mc-import-body">
+      <div id="ics-root"></div>
+    </div>
+  </div>
+  <!-- LOG -->
+  <div id="mc-log"></div>
+</div>
+`;
+exports.CALENDAR_PANEL_SCRIPTS = [
+    './ui/mycalendar.css',
+    './ui/calendar.js',
+    './ui/icsImport.js',
+];
+function createCalendarPanel(joplin) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { panels } = joplin.views;
+        const panel = yield panels.create(exports.CALENDAR_PANEL_ID);
+        yield panels.setHtml(panel, exports.CALENDAR_PANEL_HTML);
+        for (const script of exports.CALENDAR_PANEL_SCRIPTS) {
+            yield panels.addScript(panel, script);
+        }
+        yield panels.show(panel);
+        (0, logger_1.log)('calendarView', 'Panel created');
+        return panel;
+    });
+}
+
+
+/***/ }
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Check if module exists (development only)
+/******/ 		if (__webpack_modules__[moduleId] === undefined) {
+/******/ 			var e = new Error("Cannot find module '" + moduleId + "'");
+/******/ 			e.code = 'MODULE_NOT_FOUND';
+/******/ 			throw e;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	
+/******/ 	// startup
+/******/ 	// Load entry module and return exports
+/******/ 	// This entry module is referenced by other modules so it can't be inlined
+/******/ 	var __webpack_exports__ = __webpack_require__("./src/index.ts");
+/******/ 	module.exports = __webpack_exports__;
+/******/ 	
+/******/ })()
+;
+//# sourceMappingURL=index.js.map