@real1ty-obsidian-plugins/utils 1.0.0

package/dist/date-utils.js

@@ -0,0 +1,105 @@
+import { DateTime } from "luxon";
+export const formatDateTimeForInput = (dateString) => {
+    if (!dateString)
+        return "";
+    try {
+        const date = new Date(dateString);
+        // Format for datetime-local input (YYYY-MM-DDTHH:mm)
+        const year = date.getFullYear();
+        const month = String(date.getMonth() + 1).padStart(2, "0");
+        const day = String(date.getDate()).padStart(2, "0");
+        const hours = String(date.getHours()).padStart(2, "0");
+        const minutes = String(date.getMinutes()).padStart(2, "0");
+        return `${year}-${month}-${day}T${hours}:${minutes}`;
+    }
+    catch (_a) {
+        return "";
+    }
+};
+export const formatDateForInput = (dateString) => {
+    if (!dateString)
+        return "";
+    try {
+        const date = new Date(dateString);
+        const year = date.getFullYear();
+        const month = String(date.getMonth() + 1).padStart(2, "0");
+        const day = String(date.getDate()).padStart(2, "0");
+        return `${year}-${month}-${day}`;
+    }
+    catch (_a) {
+        return "";
+    }
+};
+/**
+ * Converts input value to ISO string, handling edge cases where
+ * browser datetime-local inputs behave differently across platforms.
+ * Returns null for invalid dates to prevent silent failures.
+ */
+export const inputValueToISOString = (inputValue) => {
+    try {
+        return new Date(inputValue).toISOString();
+    }
+    catch (_a) {
+        return null;
+    }
+};
+export const formatDuration = (minutes) => {
+    const hours = Math.floor(minutes / 60);
+    const mins = minutes % 60;
+    return `${String(hours).padStart(2, "0")}:${String(mins).padStart(2, "0")}:00`;
+};
+/**
+ * Parse time string from datetime value - extracts HH:mm format
+ * Rejects plain HH:mm format, requires full datetime
+ */
+export const parseTimeString = (value) => {
+    if (value === null)
+        return undefined;
+    const v = value.trim();
+    // Reject plain HH:mm format - require full datetime
+    if (/^\d{2}:\d{2}$/.test(v)) {
+        return undefined; // Reject plain time format
+    }
+    // Try ISO format first (most common) - EXACT same logic as recurring events
+    let dt = DateTime.fromISO(v, { setZone: true }); // ISO: with/without seconds, Z/offset, T
+    if (!dt.isValid)
+        dt = DateTime.fromSQL(v, { setZone: true }); // "YYYY-MM-DD HH:mm[:ss]" etc.
+    if (!dt.isValid)
+        dt = DateTime.fromFormat(v, "yyyy-MM-dd HH:mm", { setZone: true });
+    return dt.isValid ? dt.toFormat("HH:mm") : undefined;
+};
+/**
+ * Parse and validate datetime strings for event parsing
+ * Supports multiple formats including date-only and datetime formats
+ */
+export const parseDateTimeString = (value) => {
+    if (value === null)
+        return undefined;
+    const v = value.trim();
+    if (!v)
+        return undefined;
+    // Try multiple datetime formats in order of preference
+    let dt;
+    // 1. Try ISO format first (most common)
+    dt = DateTime.fromISO(v, { setZone: true });
+    if (dt.isValid)
+        return dt.toISO({ suppressMilliseconds: true }) || undefined;
+    // 2. Try SQL format (YYYY-MM-DD HH:mm:ss)
+    dt = DateTime.fromSQL(v, { setZone: true });
+    if (dt.isValid)
+        return dt.toISO({ suppressMilliseconds: true }) || undefined;
+    // 3. Try common format with space (YYYY-MM-DD HH:mm)
+    dt = DateTime.fromFormat(v, "yyyy-MM-dd HH:mm", { setZone: true });
+    if (dt.isValid)
+        return dt.toISO({ suppressMilliseconds: true }) || undefined;
+    // 4. Try date-only format (YYYY-MM-DD) - treat as start of day
+    dt = DateTime.fromFormat(v, "yyyy-MM-dd", { setZone: true });
+    if (dt.isValid)
+        return dt.toISO({ suppressMilliseconds: true }) || undefined;
+    // 5. Try ISO date format (YYYY-MM-DD)
+    dt = DateTime.fromISO(v, { setZone: true });
+    if (dt.isValid)
+        return dt.toISO({ suppressMilliseconds: true }) || undefined;
+    return undefined;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-utils.js","sourceRoot":"","sources":["../src/date-utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { DateTime } from \"luxon\";\n\nexport const formatDateTimeForInput = (dateString: string): string => {\n\tif (!dateString) return \"\";\n\n\ttry {\n\t\tconst date = new Date(dateString);\n\t\t// Format for datetime-local input (YYYY-MM-DDTHH:mm)\n\t\tconst year = date.getFullYear();\n\t\tconst month = String(date.getMonth() + 1).padStart(2, \"0\");\n\t\tconst day = String(date.getDate()).padStart(2, \"0\");\n\t\tconst hours = String(date.getHours()).padStart(2, \"0\");\n\t\tconst minutes = String(date.getMinutes()).padStart(2, \"0\");\n\n\t\treturn `${year}-${month}-${day}T${hours}:${minutes}`;\n\t} catch {\n\t\treturn \"\";\n\t}\n};\n\nexport const formatDateForInput = (dateString: string): string => {\n\tif (!dateString) return \"\";\n\n\ttry {\n\t\tconst date = new Date(dateString);\n\t\tconst year = date.getFullYear();\n\t\tconst month = String(date.getMonth() + 1).padStart(2, \"0\");\n\t\tconst day = String(date.getDate()).padStart(2, \"0\");\n\n\t\treturn `${year}-${month}-${day}`;\n\t} catch {\n\t\treturn \"\";\n\t}\n};\n\n/**\n * Converts input value to ISO string, handling edge cases where\n * browser datetime-local inputs behave differently across platforms.\n * Returns null for invalid dates to prevent silent failures.\n */\nexport const inputValueToISOString = (inputValue: string): string | null => {\n\ttry {\n\t\treturn new Date(inputValue).toISOString();\n\t} catch {\n\t\treturn null;\n\t}\n};\n\nexport const formatDuration = (minutes: number): string => {\n\tconst hours = Math.floor(minutes / 60);\n\tconst mins = minutes % 60;\n\treturn `${String(hours).padStart(2, \"0\")}:${String(mins).padStart(2, \"0\")}:00`;\n};\n\n/**\n * Parse time string from datetime value - extracts HH:mm format\n * Rejects plain HH:mm format, requires full datetime\n */\nexport const parseTimeString = (value: string | null): string | undefined => {\n\tif (value === null) return undefined;\n\n\tconst v = value.trim();\n\n\t// Reject plain HH:mm format - require full datetime\n\tif (/^\\d{2}:\\d{2}$/.test(v)) {\n\t\treturn undefined; // Reject plain time format\n\t}\n\n\t// Try ISO format first (most common) - EXACT same logic as recurring events\n\tlet dt = DateTime.fromISO(v, { setZone: true }); // ISO: with/without seconds, Z/offset, T\n\tif (!dt.isValid) dt = DateTime.fromSQL(v, { setZone: true }); // \"YYYY-MM-DD HH:mm[:ss]\" etc.\n\tif (!dt.isValid) dt = DateTime.fromFormat(v, \"yyyy-MM-dd HH:mm\", { setZone: true });\n\n\treturn dt.isValid ? dt.toFormat(\"HH:mm\") : undefined;\n};\n\n/**\n * Parse and validate datetime strings for event parsing\n * Supports multiple formats including date-only and datetime formats\n */\nexport const parseDateTimeString = (value: string | null): string | undefined => {\n\tif (value === null) return undefined;\n\n\tconst v = value.trim();\n\tif (!v) return undefined;\n\n\t// Try multiple datetime formats in order of preference\n\tlet dt: DateTime;\n\n\t// 1. Try ISO format first (most common)\n\tdt = DateTime.fromISO(v, { setZone: true });\n\tif (dt.isValid) return dt.toISO({ suppressMilliseconds: true }) || undefined;\n\n\t// 2. Try SQL format (YYYY-MM-DD HH:mm:ss)\n\tdt = DateTime.fromSQL(v, { setZone: true });\n\tif (dt.isValid) return dt.toISO({ suppressMilliseconds: true }) || undefined;\n\n\t// 3. Try common format with space (YYYY-MM-DD HH:mm)\n\tdt = DateTime.fromFormat(v, \"yyyy-MM-dd HH:mm\", { setZone: true });\n\tif (dt.isValid) return dt.toISO({ suppressMilliseconds: true }) || undefined;\n\n\t// 4. Try date-only format (YYYY-MM-DD) - treat as start of day\n\tdt = DateTime.fromFormat(v, \"yyyy-MM-dd\", { setZone: true });\n\tif (dt.isValid) return dt.toISO({ suppressMilliseconds: true }) || undefined;\n\n\t// 5. Try ISO date format (YYYY-MM-DD)\n\tdt = DateTime.fromISO(v, { setZone: true });\n\tif (dt.isValid) return dt.toISO({ suppressMilliseconds: true }) || undefined;\n\n\treturn undefined;\n};\n"]}

package/dist/evaluator-base.d.ts

@@ -0,0 +1,52 @@
+import type { BehaviorSubject } from "rxjs";
+export interface BaseRule {
+    id: string;
+    expression: string;
+    enabled: boolean;
+}
+/**
+ * Generic base class for evaluating JavaScript expressions against frontmatter objects.
+ * Provides reactive compilation of rules via RxJS subscription and safe evaluation.
+ */
+export declare abstract class BaseEvaluator<TRule extends BaseRule, TSettings> {
+    protected compiledRules: Array<TRule & {
+        fn: (frontmatter: Record<string, unknown>) => boolean;
+    }>;
+    private settingsSubscription;
+    constructor(settingsStore: BehaviorSubject<TSettings>);
+    /**
+     * Extract rules from settings object. Must be implemented by subclasses.
+     */
+    protected abstract extractRules(settings: TSettings): TRule[];
+    /**
+     * Compile rules into executable functions with error handling.
+     */
+    private compileRules;
+    /**
+     * Evaluate a single rule against frontmatter. Returns the result or undefined if error.
+     */
+    protected evaluateRule(rule: TRule & {
+        fn: (frontmatter: Record<string, unknown>) => boolean;
+    }, frontmatter: Record<string, unknown>): boolean | undefined;
+    /**
+     * Convert evaluation result to boolean - only explicit true is considered truthy.
+     */
+    protected isTruthy(result: boolean | undefined): boolean;
+    /**
+     * Clean up subscriptions and compiled rules.
+     */
+    destroy(): void;
+    /**
+     * Get the number of active (compiled) rules.
+     */
+    getActiveRuleCount(): number;
+    /**
+     * Get information about all rules including their validity.
+     */
+    getRuleInfo(): Array<{
+        expression: string;
+        isValid: boolean;
+        enabled: boolean;
+    }>;
+}
+//# sourceMappingURL=evaluator-base.d.ts.map

package/dist/evaluator-base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluator-base.d.ts","sourceRoot":"","sources":["../src/evaluator-base.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAgB,MAAM,MAAM,CAAC;AAE1D,MAAM,WAAW,QAAQ;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;CACjB;AAED;;;GAGG;AACH,8BAAsB,aAAa,CAAC,KAAK,SAAS,QAAQ,EAAE,SAAS;IACpE,SAAS,CAAC,aAAa,EAAE,KAAK,CAC7B,KAAK,GAAG;QAAE,EAAE,EAAE,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAA;KAAE,CACjE,CAAM;IACP,OAAO,CAAC,oBAAoB,CAA6B;gBAE7C,aAAa,EAAE,eAAe,CAAC,SAAS,CAAC;IAUrD;;OAEG;IACH,SAAS,CAAC,QAAQ,CAAC,YAAY,CAAC,QAAQ,EAAE,SAAS,GAAG,KAAK,EAAE;IAE7D;;OAEG;IACH,OAAO,CAAC,YAAY;IA6BpB;;OAEG;IACH,SAAS,CAAC,YAAY,CACrB,IAAI,EAAE,KAAK,GAAG;QAAE,EAAE,EAAE,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAA;KAAE,EACvE,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAClC,OAAO,GAAG,SAAS;IAStB;;OAEG;IACH,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,OAAO,GAAG,SAAS,GAAG,OAAO;IAIxD;;OAEG;IACH,OAAO,IAAI,IAAI;IAQf;;OAEG;IACH,kBAAkB,IAAI,MAAM;IAI5B;;OAEG;IACH,WAAW,IAAI,KAAK,CAAC;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;CAShF"}

package/dist/evaluator-base.js

@@ -0,0 +1,84 @@
+/**
+ * Generic base class for evaluating JavaScript expressions against frontmatter objects.
+ * Provides reactive compilation of rules via RxJS subscription and safe evaluation.
+ */
+export class BaseEvaluator {
+    constructor(settingsStore) {
+        this.compiledRules = [];
+        this.settingsSubscription = null;
+        const initialRules = this.extractRules(settingsStore.value);
+        this.compileRules(initialRules);
+        this.settingsSubscription = settingsStore.subscribe((settings) => {
+            const newRules = this.extractRules(settings);
+            this.compileRules(newRules);
+        });
+    }
+    /**
+     * Compile rules into executable functions with error handling.
+     */
+    compileRules(rules) {
+        this.compiledRules = [];
+        for (const rule of rules) {
+            if (!rule.enabled || !rule.expression.trim())
+                continue;
+            try {
+                const cleanExpression = rule.expression.trim();
+                // Create a function that takes 'fm' (frontmatter) as parameter
+                // and evaluates the expression in that context
+                const fn = new Function("fm", `return (${cleanExpression});`);
+                // Test the function with a dummy object to catch syntax errors early
+                fn({});
+                this.compiledRules.push(Object.assign(Object.assign({}, rule), { expression: cleanExpression, fn }));
+            }
+            catch (error) {
+                console.warn(`Invalid rule expression "${rule.expression}":`, error);
+            }
+        }
+    }
+    /**
+     * Evaluate a single rule against frontmatter. Returns the result or undefined if error.
+     */
+    evaluateRule(rule, frontmatter) {
+        try {
+            return rule.fn(frontmatter);
+        }
+        catch (error) {
+            console.warn(`Error evaluating rule "${rule.expression}":`, error);
+            return undefined;
+        }
+    }
+    /**
+     * Convert evaluation result to boolean - only explicit true is considered truthy.
+     */
+    isTruthy(result) {
+        return result === true;
+    }
+    /**
+     * Clean up subscriptions and compiled rules.
+     */
+    destroy() {
+        if (this.settingsSubscription) {
+            this.settingsSubscription.unsubscribe();
+            this.settingsSubscription = null;
+        }
+        this.compiledRules = [];
+    }
+    /**
+     * Get the number of active (compiled) rules.
+     */
+    getActiveRuleCount() {
+        return this.compiledRules.length;
+    }
+    /**
+     * Get information about all rules including their validity.
+     */
+    getRuleInfo() {
+        const validExpressions = new Set(this.compiledRules.map((r) => r.expression));
+        return this.compiledRules.map((rule) => ({
+            expression: rule.expression,
+            isValid: validExpressions.has(rule.expression),
+            enabled: rule.enabled,
+        }));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/file-operations.d.ts

@@ -0,0 +1,31 @@
+import { type App, TFile } from "obsidian";
+export declare const fromRoot: (relativePath: string) => string;
+export declare const getActiveFileOrThrow: (app: App) => TFile;
+export declare const getTemplateContent: (app: App, templatePath: string) => Promise<string>;
+export declare const ensureFolderExists: (app: App, folderPath: string) => Promise<void>;
+export declare const openFileInNewLeaf: (app: App, file: TFile) => Promise<void>;
+export declare const getNoteFilesFromDir: (directoryPath: string) => Promise<string[]>;
+export declare const getTargetFileFromLink: (app: App, relationshipLink: string) => TFile | null;
+export declare const createFileLink: (file: TFile) => string;
+export declare const normalizeArray: (value: string | string[] | undefined) => string[];
+export declare const arraysEqual: (a: string[], b: string[]) => boolean;
+/**
+ * Normalizes frontmatter content by converting quoted numeric _ZettelIDs to numbers.
+ * This handles edge cases where YAML parsers treat numeric strings inconsistently.
+ */
+export declare const normalizeContent: (content: string) => string;
+/**
+ * Safely performs a file operation with error handling and file validation.
+ * Reduces boilerplate for common file operations.
+ */
+export declare const withFileOperation: <T>(app: App, event: any, operation: (file: TFile) => Promise<T>, errorMessage?: string) => Promise<T | null>;
+/**
+ * Safely performs a file operation by file path with error handling and file validation.
+ */
+export declare const withFile: <T>(app: App, filePath: string, operation: (file: TFile) => Promise<T>, errorMessage?: string) => Promise<T | null>;
+/**
+ * Duplicates a file with a new ZettelID, preserving the original content
+ * but updating the ZettelID in frontmatter if configured.
+ */
+export declare const duplicateFileWithNewZettelId: (app: App, file: TFile, zettelIdProp?: string) => Promise<TFile>;
+//# sourceMappingURL=file-operations.d.ts.map

package/dist/file-operations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-operations.d.ts","sourceRoot":"","sources":["../src/file-operations.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,GAAG,EAAU,KAAK,EAAE,MAAM,UAAU,CAAC;AAGnD,eAAO,MAAM,QAAQ,GAAI,cAAc,MAAM,KAAG,MAE/C,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAAI,KAAK,GAAG,KAAG,KAO/C,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAU,KAAK,GAAG,EAAE,cAAc,MAAM,KAAG,OAAO,CAAC,MAAM,CAQvF,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAU,KAAK,GAAG,EAAE,YAAY,MAAM,KAAG,OAAO,CAAC,IAAI,CAInF,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAU,KAAK,GAAG,EAAE,MAAM,KAAK,KAAG,OAAO,CAAC,IAAI,CAE3E,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAU,eAAe,MAAM,KAAG,OAAO,CAAC,MAAM,EAAE,CAejF,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAAI,KAAK,GAAG,EAAE,kBAAkB,MAAM,KAAG,KAAK,GAAG,IAclF,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,MAAM,KAAK,KAAG,MAG5C,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,OAAO,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,KAAG,MAAM,EAW3E,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,GAAG,MAAM,EAAE,EAAE,GAAG,MAAM,EAAE,KAAG,OAEtD,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,gBAAgB,GAAI,SAAS,MAAM,KAAG,MAelD,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,iBAAiB,GAAU,CAAC,EACxC,KAAK,GAAG,EACR,OAAO,GAAG,EACV,WAAW,CAAC,IAAI,EAAE,KAAK,KAAK,OAAO,CAAC,CAAC,CAAC,EACtC,eAAc,MAA2B,KACvC,OAAO,CAAC,CAAC,GAAG,IAAI,CAgBlB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,QAAQ,GAAU,CAAC,EAC/B,KAAK,GAAG,EACR,UAAU,MAAM,EAChB,WAAW,CAAC,IAAI,EAAE,KAAK,KAAK,OAAO,CAAC,CAAC,CAAC,EACtC,eAAc,MAA2B,KACvC,OAAO,CAAC,CAAC,GAAG,IAAI,CAelB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,4BAA4B,GACxC,KAAK,GAAG,EACR,MAAM,KAAK,EACX,eAAe,MAAM,KACnB,OAAO,CAAC,KAAK,CAsBf,CAAC"}

package/dist/file-operations.js

@@ -0,0 +1,160 @@
+import { __awaiter } from "tslib";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { Notice, TFile } from "obsidian";
+import { extractFilePathFromLink } from "./link-parser";
+export const fromRoot = (relativePath) => {
+    return path.resolve(__dirname, `../../../${relativePath}`);
+};
+export const getActiveFileOrThrow = (app) => {
+    const activeFile = app.workspace.getActiveFile();
+    if (!activeFile) {
+        new Notice(`⚠️  Open a note first.`);
+        throw new Error(`Open a note first.`);
+    }
+    return activeFile;
+};
+export const getTemplateContent = (app, templatePath) => __awaiter(void 0, void 0, void 0, function* () {
+    const templateFile = app.vault.getAbstractFileByPath(templatePath);
+    if (!templateFile) {
+        new Notice(`❌  Template not found: ${templatePath}`);
+        throw new Error(`Template not found: ${templatePath}`);
+    }
+    return yield app.vault.read(templateFile);
+});
+export const ensureFolderExists = (app, folderPath) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!app.vault.getAbstractFileByPath(folderPath)) {
+        yield app.vault.createFolder(folderPath).catch(() => { });
+    }
+});
+export const openFileInNewLeaf = (app, file) => __awaiter(void 0, void 0, void 0, function* () {
+    yield app.workspace.getLeaf(true).openFile(file);
+});
+export const getNoteFilesFromDir = (directoryPath) => __awaiter(void 0, void 0, void 0, function* () {
+    const files = yield fs.readdir(directoryPath);
+    const directoryName = path.basename(directoryPath);
+    return files.filter((file) => {
+        if (!file.endsWith(".md"))
+            return false;
+        const fileNameWithoutExt = path.parse(file).name;
+        if (fileNameWithoutExt === directoryName) {
+            console.log(`⏭️ Skipping directory-level file: ${file}`);
+            return false;
+        }
+        return true;
+    });
+});
+export const getTargetFileFromLink = (app, relationshipLink) => {
+    const targetFilePath = extractFilePathFromLink(relationshipLink);
+    if (!targetFilePath) {
+        console.warn(`Failed to extract file path from link: ${relationshipLink}`);
+        return null;
+    }
+    const targetFile = app.vault.getAbstractFileByPath(targetFilePath);
+    if (!targetFile) {
+        console.warn(`Target file not found for link: ${relationshipLink}`);
+        return null;
+    }
+    return targetFile;
+};
+export const createFileLink = (file) => {
+    var _a;
+    const folder = ((_a = file.parent) === null || _a === void 0 ? void 0 : _a.path) && file.parent.path !== "/" ? file.parent.path : "";
+    return folder ? `[[${folder}/${file.basename}|${file.basename}]]` : `[[${file.basename}]]`;
+};
+export const normalizeArray = (value) => {
+    if (!value) {
+        return [];
+    }
+    if (typeof value === "string") {
+        return [value];
+    }
+    if (Array.isArray(value)) {
+        return value;
+    }
+    return [];
+};
+export const arraysEqual = (a, b) => {
+    return a.length === b.length && a.every((val, index) => val === b[index]);
+};
+/**
+ * Normalizes frontmatter content by converting quoted numeric _ZettelIDs to numbers.
+ * This handles edge cases where YAML parsers treat numeric strings inconsistently.
+ */
+export const normalizeContent = (content) => {
+    let normalized = content;
+    let hasChanges = false;
+    // Normalize _ZettelID: "string" → number (remove quotes)
+    const zettelIdMatch = normalized.match(/^_ZettelID:\s*"(\d+)"/m);
+    if (zettelIdMatch) {
+        const [fullMatch, numericId] = zettelIdMatch;
+        const replacement = `_ZettelID: ${numericId}`;
+        normalized = normalized.replace(fullMatch, replacement);
+        hasChanges = true;
+        console.log(`  ✅ _ZettelID: "${numericId}" → ${numericId}`);
+    }
+    return hasChanges ? normalized : content;
+};
+/**
+ * Safely performs a file operation with error handling and file validation.
+ * Reduces boilerplate for common file operations.
+ */
+export const withFileOperation = (app_1, event_1, operation_1, ...args_1) => __awaiter(void 0, [app_1, event_1, operation_1, ...args_1], void 0, function* (app, event, operation, errorMessage = "Operation failed") {
+    try {
+        const filePath = event.extendedProps.filePath;
+        const file = app.vault.getAbstractFileByPath(filePath);
+        if (!(file instanceof TFile)) {
+            new Notice("Could not find the file");
+            return null;
+        }
+        return yield operation(file);
+    }
+    catch (error) {
+        console.error(`Error in file operation:`, error);
+        new Notice(errorMessage);
+        return null;
+    }
+});
+/**
+ * Safely performs a file operation by file path with error handling and file validation.
+ */
+export const withFile = (app_1, filePath_1, operation_1, ...args_1) => __awaiter(void 0, [app_1, filePath_1, operation_1, ...args_1], void 0, function* (app, filePath, operation, errorMessage = "Operation failed") {
+    try {
+        const file = app.vault.getAbstractFileByPath(filePath);
+        if (!(file instanceof TFile)) {
+            new Notice("Could not find the file");
+            return null;
+        }
+        return yield operation(file);
+    }
+    catch (error) {
+        console.error(`Error in file operation:`, error);
+        new Notice(errorMessage);
+        return null;
+    }
+});
+/**
+ * Duplicates a file with a new ZettelID, preserving the original content
+ * but updating the ZettelID in frontmatter if configured.
+ */
+export const duplicateFileWithNewZettelId = (app, file, zettelIdProp) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const content = yield app.vault.read(file);
+    const { generateZettelId } = yield import("./generate");
+    const { generateUniqueFilePath } = yield import("./file-utils");
+    const parentPath = ((_a = file.parent) === null || _a === void 0 ? void 0 : _a.path) || "";
+    const baseNameWithoutZettel = file.basename.replace(/-\d{14}$/, "");
+    const zettelId = generateZettelId();
+    const newBasename = `${baseNameWithoutZettel}-${zettelId}`;
+    const newFilePath = generateUniqueFilePath(app, parentPath, newBasename);
+    // Create the new file with original content
+    const newFile = yield app.vault.create(newFilePath, content);
+    // Update the ZettelID in frontmatter if configured
+    if (zettelIdProp) {
+        yield app.fileManager.processFrontMatter(newFile, (fm) => {
+            fm[zettelIdProp] = zettelId;
+        });
+    }
+    return newFile;
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"file-operations.js","sourceRoot":"","sources":["../src/file-operations.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from \"node:fs/promises\";\nimport * as path from \"node:path\";\nimport { type App, Notice, TFile } from \"obsidian\";\nimport { extractFilePathFromLink } from \"./link-parser\";\n\nexport const fromRoot = (relativePath: string): string => {\n\treturn path.resolve(__dirname, `../../../${relativePath}`);\n};\n\nexport const getActiveFileOrThrow = (app: App): TFile => {\n\tconst activeFile: TFile | null = app.workspace.getActiveFile();\n\tif (!activeFile) {\n\t\tnew Notice(`⚠️  Open a note first.`);\n\t\tthrow new Error(`Open a note first.`);\n\t}\n\treturn activeFile;\n};\n\nexport const getTemplateContent = async (app: App, templatePath: string): Promise<string> => {\n\tconst templateFile = app.vault.getAbstractFileByPath(templatePath);\n\tif (!templateFile) {\n\t\tnew Notice(`❌  Template not found: ${templatePath}`);\n\t\tthrow new Error(`Template not found: ${templatePath}`);\n\t}\n\n\treturn await app.vault.read(templateFile as TFile);\n};\n\nexport const ensureFolderExists = async (app: App, folderPath: string): Promise<void> => {\n\tif (!app.vault.getAbstractFileByPath(folderPath)) {\n\t\tawait app.vault.createFolder(folderPath).catch(() => {});\n\t}\n};\n\nexport const openFileInNewLeaf = async (app: App, file: TFile): Promise<void> => {\n\tawait app.workspace.getLeaf(true).openFile(file);\n};\n\nexport const getNoteFilesFromDir = async (directoryPath: string): Promise<string[]> => {\n\tconst files = await fs.readdir(directoryPath);\n\tconst directoryName = path.basename(directoryPath);\n\n\treturn files.filter((file) => {\n\t\tif (!file.endsWith(\".md\")) return false;\n\n\t\tconst fileNameWithoutExt = path.parse(file).name;\n\t\tif (fileNameWithoutExt === directoryName) {\n\t\t\tconsole.log(`⏭️ Skipping directory-level file: ${file}`);\n\t\t\treturn false;\n\t\t}\n\n\t\treturn true;\n\t});\n};\n\nexport const getTargetFileFromLink = (app: App, relationshipLink: string): TFile | null => {\n\tconst targetFilePath = extractFilePathFromLink(relationshipLink);\n\tif (!targetFilePath) {\n\t\tconsole.warn(`Failed to extract file path from link: ${relationshipLink}`);\n\t\treturn null;\n\t}\n\n\tconst targetFile = app.vault.getAbstractFileByPath(targetFilePath) as TFile;\n\tif (!targetFile) {\n\t\tconsole.warn(`Target file not found for link: ${relationshipLink}`);\n\t\treturn null;\n\t}\n\n\treturn targetFile;\n};\n\nexport const createFileLink = (file: TFile): string => {\n\tconst folder = file.parent?.path && file.parent.path !== \"/\" ? file.parent.path : \"\";\n\treturn folder ? `[[${folder}/${file.basename}|${file.basename}]]` : `[[${file.basename}]]`;\n};\n\nexport const normalizeArray = (value: string | string[] | undefined): string[] => {\n\tif (!value) {\n\t\treturn [];\n\t}\n\tif (typeof value === \"string\") {\n\t\treturn [value];\n\t}\n\tif (Array.isArray(value)) {\n\t\treturn value;\n\t}\n\treturn [];\n};\n\nexport const arraysEqual = (a: string[], b: string[]): boolean => {\n\treturn a.length === b.length && a.every((val, index) => val === b[index]);\n};\n\n/**\n * Normalizes frontmatter content by converting quoted numeric _ZettelIDs to numbers.\n * This handles edge cases where YAML parsers treat numeric strings inconsistently.\n */\nexport const normalizeContent = (content: string): string => {\n\tlet normalized = content;\n\tlet hasChanges = false;\n\n\t// Normalize _ZettelID: \"string\" → number (remove quotes)\n\tconst zettelIdMatch = normalized.match(/^_ZettelID:\\s*\"(\\d+)\"/m);\n\tif (zettelIdMatch) {\n\t\tconst [fullMatch, numericId] = zettelIdMatch;\n\t\tconst replacement = `_ZettelID: ${numericId}`;\n\t\tnormalized = normalized.replace(fullMatch, replacement);\n\t\thasChanges = true;\n\t\tconsole.log(`  ✅ _ZettelID: \"${numericId}\" → ${numericId}`);\n\t}\n\n\treturn hasChanges ? normalized : content;\n};\n\n/**\n * Safely performs a file operation with error handling and file validation.\n * Reduces boilerplate for common file operations.\n */\nexport const withFileOperation = async <T>(\n\tapp: App,\n\tevent: any,\n\toperation: (file: TFile) => Promise<T>,\n\terrorMessage: string = \"Operation failed\"\n): Promise<T | null> => {\n\ttry {\n\t\tconst filePath = event.extendedProps.filePath;\n\t\tconst file = app.vault.getAbstractFileByPath(filePath);\n\n\t\tif (!(file instanceof TFile)) {\n\t\t\tnew Notice(\"Could not find the file\");\n\t\t\treturn null;\n\t\t}\n\n\t\treturn await operation(file);\n\t} catch (error) {\n\t\tconsole.error(`Error in file operation:`, error);\n\t\tnew Notice(errorMessage);\n\t\treturn null;\n\t}\n};\n\n/**\n * Safely performs a file operation by file path with error handling and file validation.\n */\nexport const withFile = async <T>(\n\tapp: App,\n\tfilePath: string,\n\toperation: (file: TFile) => Promise<T>,\n\terrorMessage: string = \"Operation failed\"\n): Promise<T | null> => {\n\ttry {\n\t\tconst file = app.vault.getAbstractFileByPath(filePath);\n\n\t\tif (!(file instanceof TFile)) {\n\t\t\tnew Notice(\"Could not find the file\");\n\t\t\treturn null;\n\t\t}\n\n\t\treturn await operation(file);\n\t} catch (error) {\n\t\tconsole.error(`Error in file operation:`, error);\n\t\tnew Notice(errorMessage);\n\t\treturn null;\n\t}\n};\n\n/**\n * Duplicates a file with a new ZettelID, preserving the original content\n * but updating the ZettelID in frontmatter if configured.\n */\nexport const duplicateFileWithNewZettelId = async (\n\tapp: App,\n\tfile: TFile,\n\tzettelIdProp?: string\n): Promise<TFile> => {\n\tconst content = await app.vault.read(file);\n\tconst { generateZettelId } = await import(\"./generate\");\n\tconst { generateUniqueFilePath } = await import(\"./file-utils\");\n\n\tconst parentPath = file.parent?.path || \"\";\n\tconst baseNameWithoutZettel = file.basename.replace(/-\\d{14}$/, \"\");\n\tconst zettelId = generateZettelId();\n\tconst newBasename = `${baseNameWithoutZettel}-${zettelId}`;\n\tconst newFilePath = generateUniqueFilePath(app, parentPath, newBasename);\n\n\t// Create the new file with original content\n\tconst newFile = await app.vault.create(newFilePath, content);\n\n\t// Update the ZettelID in frontmatter if configured\n\tif (zettelIdProp) {\n\t\tawait app.fileManager.processFrontMatter(newFile, (fm) => {\n\t\t\tfm[zettelIdProp] = zettelId;\n\t\t});\n\t}\n\n\treturn newFile;\n};\n"]}

package/dist/file-utils.d.ts

@@ -0,0 +1,6 @@
+import type { App } from "obsidian";
+export declare const generateUniqueFilePath: (app: App, folder: string, baseName: string, extension?: string) => string;
+export declare const sanitizeForFilename: (input: string) => string;
+export declare const getFilenameFromPath: (filePath: string) => string;
+export declare const isFileInConfiguredDirectory: (filePath: string, directory: string) => boolean;
+//# sourceMappingURL=file-utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"file-utils.d.ts","sourceRoot":"","sources":["../src/file-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAEpC,eAAO,MAAM,sBAAsB,GAClC,KAAK,GAAG,EACR,QAAQ,MAAM,EACd,UAAU,MAAM,EAChB,YAAW,MAAa,KACtB,MAUF,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAI,OAAO,MAAM,KAAG,MAOnD,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAI,UAAU,MAAM,KAAG,MAEtD,CAAC;AAEF,eAAO,MAAM,2BAA2B,GAAI,UAAU,MAAM,EAAE,WAAW,MAAM,KAAG,OAGjF,CAAC"}

package/dist/file-utils.js

@@ -0,0 +1,25 @@
+export const generateUniqueFilePath = (app, folder, baseName, extension = "md") => {
+    const folderPath = folder ? `${folder}/` : "";
+    let filePath = `${folderPath}${baseName}.${extension}`;
+    let counter = 1;
+    while (app.vault.getAbstractFileByPath(filePath)) {
+        filePath = `${folderPath}${baseName} ${counter++}.${extension}`;
+    }
+    return filePath;
+};
+export const sanitizeForFilename = (input) => {
+    return input
+        .replace(/[<>:"/\\|?*]/g, "") // Remove invalid filename characters
+        .replace(/\s+/g, "-") // Replace spaces with hyphens
+        .replace(/-+/g, "-") // Replace multiple hyphens with single
+        .replace(/^-|-$/g, "") // Remove leading/trailing hyphens
+        .toLowerCase();
+};
+export const getFilenameFromPath = (filePath) => {
+    return filePath.split("/").pop() || "Unknown";
+};
+export const isFileInConfiguredDirectory = (filePath, directory) => {
+    const normalizedDir = directory.endsWith("/") ? directory.slice(0, -1) : directory;
+    return filePath.startsWith(`${normalizedDir}/`) || filePath === normalizedDir;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/generate.d.ts

@@ -0,0 +1,7 @@
+export interface TimestampData {
+    startDate: string;
+    zettelId: number;
+}
+export declare const generateZettelId: () => number;
+export declare const generateTimestamps: () => TimestampData;
+//# sourceMappingURL=generate.d.ts.map

package/dist/generate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../src/generate.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,aAAa;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;CACjB;AAED,eAAO,MAAM,gBAAgB,QAAO,MAMnC,CAAC;AAEF,eAAO,MAAM,kBAAkB,QAAO,aAQrC,CAAC"}

package/dist/generate.js

@@ -0,0 +1,13 @@
+export const generateZettelId = () => {
+    const currentTimestamp = new Date();
+    const padWithZero = (number) => String(number).padStart(2, "0");
+    return Number(`${currentTimestamp.getFullYear()}${padWithZero(currentTimestamp.getMonth() + 1)}${padWithZero(currentTimestamp.getDate())}${padWithZero(currentTimestamp.getHours())}${padWithZero(currentTimestamp.getMinutes())}${padWithZero(currentTimestamp.getSeconds())}`);
+};
+export const generateTimestamps = () => {
+    const padWithZero = (number) => String(number).padStart(2, "0");
+    const currentDate = new Date();
+    const formattedStartDate = `${currentDate.getFullYear()}-${padWithZero(currentDate.getMonth() + 1)}-${padWithZero(currentDate.getDate())}`;
+    const uniqueZettelId = generateZettelId();
+    return { startDate: formattedStartDate, zettelId: uniqueZettelId };
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2VuZXJhdGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvZ2VuZXJhdGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBS0EsTUFBTSxDQUFDLE1BQU0sZ0JBQWdCLEdBQUcsR0FBVyxFQUFFO0lBQzVDLE1BQU0sZ0JBQWdCLEdBQUcsSUFBSSxJQUFJLEVBQUUsQ0FBQztJQUNwQyxNQUFNLFdBQVcsR0FBRyxDQUFDLE1BQWMsRUFBRSxFQUFFLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFDLFFBQVEsQ0FBQyxDQUFDLEVBQUUsR0FBRyxDQUFDLENBQUM7SUFDeEUsT0FBTyxNQUFNLENBQ1osR0FBRyxnQkFBZ0IsQ0FBQyxXQUFXLEVBQUUsR0FBRyxXQUFXLENBQUMsZ0JBQWdCLENBQUMsUUFBUSxFQUFFLEdBQUcsQ0FBQyxDQUFDLEdBQUcsV0FBVyxDQUFDLGdCQUFnQixDQUFDLE9BQU8sRUFBRSxDQUFDLEdBQUcsV0FBVyxDQUFDLGdCQUFnQixDQUFDLFFBQVEsRUFBRSxDQUFDLEdBQUcsV0FBVyxDQUFDLGdCQUFnQixDQUFDLFVBQVUsRUFBRSxDQUFDLEdBQUcsV0FBVyxDQUFDLGdCQUFnQixDQUFDLFVBQVUsRUFBRSxDQUFDLEVBQUUsQ0FDalEsQ0FBQztBQUNILENBQUMsQ0FBQztBQUVGLE1BQU0sQ0FBQyxNQUFNLGtCQUFrQixHQUFHLEdBQWtCLEVBQUU7SUFDckQsTUFBTSxXQUFXLEdBQUcsQ0FBQyxNQUFjLEVBQVUsRUFBRSxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsQ0FBQyxRQUFRLENBQUMsQ0FBQyxFQUFFLEdBQUcsQ0FBQyxDQUFDO0lBQ2hGLE1BQU0sV0FBVyxHQUFHLElBQUksSUFBSSxFQUFFLENBQUM7SUFFL0IsTUFBTSxrQkFBa0IsR0FBVyxHQUFHLFdBQVcsQ0FBQyxXQUFXLEVBQUUsSUFBSSxXQUFXLENBQUMsV0FBVyxDQUFDLFFBQVEsRUFBRSxHQUFHLENBQUMsQ0FBQyxJQUFJLFdBQVcsQ0FBQyxXQUFXLENBQUMsT0FBTyxFQUFFLENBQUMsRUFBRSxDQUFDO0lBQ25KLE1BQU0sY0FBYyxHQUFXLGdCQUFnQixFQUFFLENBQUM7SUFFbEQsT0FBTyxFQUFFLFNBQVMsRUFBRSxrQkFBa0IsRUFBRSxRQUFRLEVBQUUsY0FBYyxFQUFFLENBQUM7QUFDcEUsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGludGVyZmFjZSBUaW1lc3RhbXBEYXRhIHtcblx0c3RhcnREYXRlOiBzdHJpbmc7XG5cdHpldHRlbElkOiBudW1iZXI7XG59XG5cbmV4cG9ydCBjb25zdCBnZW5lcmF0ZVpldHRlbElkID0gKCk6IG51bWJlciA9PiB7XG5cdGNvbnN0IGN1cnJlbnRUaW1lc3RhbXAgPSBuZXcgRGF0ZSgpO1xuXHRjb25zdCBwYWRXaXRoWmVybyA9IChudW1iZXI6IG51bWJlcikgPT4gU3RyaW5nKG51bWJlcikucGFkU3RhcnQoMiwgXCIwXCIpO1xuXHRyZXR1cm4gTnVtYmVyKFxuXHRcdGAke2N1cnJlbnRUaW1lc3RhbXAuZ2V0RnVsbFllYXIoKX0ke3BhZFdpdGhaZXJvKGN1cnJlbnRUaW1lc3RhbXAuZ2V0TW9udGgoKSArIDEpfSR7cGFkV2l0aFplcm8oY3VycmVudFRpbWVzdGFtcC5nZXREYXRlKCkpfSR7cGFkV2l0aFplcm8oY3VycmVudFRpbWVzdGFtcC5nZXRIb3VycygpKX0ke3BhZFdpdGhaZXJvKGN1cnJlbnRUaW1lc3RhbXAuZ2V0TWludXRlcygpKX0ke3BhZFdpdGhaZXJvKGN1cnJlbnRUaW1lc3RhbXAuZ2V0U2Vjb25kcygpKX1gXG5cdCk7XG59O1xuXG5leHBvcnQgY29uc3QgZ2VuZXJhdGVUaW1lc3RhbXBzID0gKCk6IFRpbWVzdGFtcERhdGEgPT4ge1xuXHRjb25zdCBwYWRXaXRoWmVybyA9IChudW1iZXI6IG51bWJlcik6IHN0cmluZyA9PiBTdHJpbmcobnVtYmVyKS5wYWRTdGFydCgyLCBcIjBcIik7XG5cdGNvbnN0IGN1cnJlbnREYXRlID0gbmV3IERhdGUoKTtcblxuXHRjb25zdCBmb3JtYXR0ZWRTdGFydERhdGU6IHN0cmluZyA9IGAke2N1cnJlbnREYXRlLmdldEZ1bGxZZWFyKCl9LSR7cGFkV2l0aFplcm8oY3VycmVudERhdGUuZ2V0TW9udGgoKSArIDEpfS0ke3BhZFdpdGhaZXJvKGN1cnJlbnREYXRlLmdldERhdGUoKSl9YDtcblx0Y29uc3QgdW5pcXVlWmV0dGVsSWQ6IG51bWJlciA9IGdlbmVyYXRlWmV0dGVsSWQoKTtcblxuXHRyZXR1cm4geyBzdGFydERhdGU6IGZvcm1hdHRlZFN0YXJ0RGF0ZSwgemV0dGVsSWQ6IHVuaXF1ZVpldHRlbElkIH07XG59O1xuIl19

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export * from "./async-utils";
+export * from "./batch-operations";
+export * from "./child-reference-utils";
+export * from "./date-recurrence-utils";
+export * from "./date-utils";
+export * from "./evaluator-base";
+export * from "./file-operations";
+export * from "./file-utils";
+export * from "./generate";
+export * from "./link-parser";
+export * from "./settings-store";
+export * from "./string-utils";
+export * from "./templater-utils";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC;AACnC,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC;AACjC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC"}

package/dist/index.js

@@ -0,0 +1,14 @@
+export * from "./async-utils";
+export * from "./batch-operations";
+export * from "./child-reference-utils";
+export * from "./date-recurrence-utils";
+export * from "./date-utils";
+export * from "./evaluator-base";
+export * from "./file-operations";
+export * from "./file-utils";
+export * from "./generate";
+export * from "./link-parser";
+export * from "./settings-store";
+export * from "./string-utils";
+export * from "./templater-utils";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsWUFBWSxDQUFDO0FBQzNCLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLG1CQUFtQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vYXN5bmMtdXRpbHNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2JhdGNoLW9wZXJhdGlvbnNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2NoaWxkLXJlZmVyZW5jZS11dGlsc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vZGF0ZS1yZWN1cnJlbmNlLXV0aWxzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kYXRlLXV0aWxzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9ldmFsdWF0b3ItYmFzZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vZmlsZS1vcGVyYXRpb25zXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9maWxlLXV0aWxzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9nZW5lcmF0ZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vbGluay1wYXJzZXJcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3NldHRpbmdzLXN0b3JlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9zdHJpbmctdXRpbHNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3RlbXBsYXRlci11dGlsc1wiO1xuIl19

package/dist/link-parser.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Handles different link formats and edge cases:
+ * [[FileName]] -> FileName.md
+ * [[Folder/FileName]] -> Folder/FileName.md
+ * [[Folder/FileName|DisplayName]] -> Folder/FileName.md
+ * Normalizes paths and handles malformed links gracefully.
+ */
+export declare const extractFilePathFromLink: (link: string) => string | null;
+//# sourceMappingURL=link-parser.d.ts.map

package/dist/link-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"link-parser.d.ts","sourceRoot":"","sources":["../src/link-parser.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,GAAI,MAAM,MAAM,KAAG,MAAM,GAAG,IAU/D,CAAC"}