collabmd 0.1.18 → 0.1.19

package/src/domain/comment-threads.js

@@ -3,6 +3,7 @@ import * as Y from 'yjs';
 export const COMMENT_BODY_MAX_LENGTH = 2000;
 export const COMMENT_EXCERPT_MAX_LENGTH = 160;
 export const COMMENT_ANCHOR_QUOTE_MAX_LENGTH = 280;
+export const COMMENT_REACTION_EMOJI_MAX_LENGTH = 16;
 
 const COMMENT_ANCHOR_KINDS = new Set(['line', 'text']);
 
@@ -22,6 +23,14 @@ function asString(value) {
   return typeof value === 'string' ? value : '';
 }
 
+function asArray(value) {
+  if (value instanceof Y.Array) {
+    return value.toArray();
+  }
+
+  return Array.isArray(value) ? value : [];
+}
+
 function readThreadValue(thread, key) {
   if (thread instanceof Y.Map) {
     return thread.get(key);
@@ -34,6 +43,14 @@ function isResolvedThread(thread) {
   return asFiniteNumber(readThreadValue(thread, 'resolvedAt')) !== null;
 }
 
+function readRecordValue(record, key) {
+  if (record instanceof Y.Map) {
+    return record.get(key);
+  }
+
+  return record?.[key];
+}
+
 function normalizeAnchorKind(value) {
   return COMMENT_ANCHOR_KINDS.has(value) ? value : null;
 }
@@ -76,30 +93,95 @@ export function summarizeCommentExcerpt(value, maxLength = COMMENT_EXCERPT_MAX_L
   return `${normalized.slice(0, Math.max(maxLength - 1, 1)).trimEnd()}…`;
 }
 
+function normalizeReactionEmoji(value) {
+  return Array.from(String(value ?? '').trim())
+    .slice(0, COMMENT_REACTION_EMOJI_MAX_LENGTH)
+    .join('');
+}
+
+function createReactionUserRecord(user) {
+  const userId = asString(readRecordValue(user, 'userId')).trim();
+  if (!userId) {
+    return null;
+  }
+
+  return {
+    reactedAt: asFiniteNumber(readRecordValue(user, 'reactedAt')) ?? Date.now(),
+    userColor: asString(readRecordValue(user, 'userColor')),
+    userId,
+    userName: asString(readRecordValue(user, 'userName')) || 'Anonymous',
+  };
+}
+
+function createReactionGroupRecord(group) {
+  const emoji = normalizeReactionEmoji(readRecordValue(group, 'emoji'));
+  if (!emoji) {
+    return null;
+  }
+
+  const usersById = new Map();
+  asArray(readRecordValue(group, 'users')).forEach((user) => {
+    const normalizedUser = createReactionUserRecord(user);
+    if (normalizedUser) {
+      usersById.set(normalizedUser.userId, normalizedUser);
+    }
+  });
+
+  if (usersById.size === 0) {
+    return null;
+  }
+
+  return {
+    emoji,
+    users: Array.from(usersById.values()),
+  };
+}
+
+function serializeCommentReactions(reactions) {
+  const groupsByEmoji = new Map();
+
+  asArray(reactions).forEach((group) => {
+    const normalizedGroup = createReactionGroupRecord(group);
+    if (!normalizedGroup) {
+      return;
+    }
+
+    const existing = groupsByEmoji.get(normalizedGroup.emoji);
+    if (!existing) {
+      groupsByEmoji.set(normalizedGroup.emoji, normalizedGroup);
+      return;
+    }
+
+    const mergedUsers = new Map(existing.users.map((user) => [user.userId, user]));
+    normalizedGroup.users.forEach((user) => mergedUsers.set(user.userId, user));
+    groupsByEmoji.set(normalizedGroup.emoji, {
+      emoji: normalizedGroup.emoji,
+      users: Array.from(mergedUsers.values()),
+    });
+  });
+
+  return Array.from(groupsByEmoji.values());
+}
+
 function createMessageRecord(message) {
-  const body = normalizeCommentBody(message?.body);
+  const body = normalizeCommentBody(readRecordValue(message, 'body'));
   if (!body) {
     return null;
   }
 
   return {
     body,
-    createdAt: asFiniteNumber(message?.createdAt) ?? Date.now(),
-    id: asString(message?.id) || createCommentId('comment'),
-    peerId: asString(message?.peerId),
-    userColor: asString(message?.userColor),
-    userName: asString(message?.userName) || 'Anonymous',
+    createdAt: asFiniteNumber(readRecordValue(message, 'createdAt')) ?? Date.now(),
+    id: asString(readRecordValue(message, 'id')) || createCommentId('comment'),
+    peerId: asString(readRecordValue(message, 'peerId')),
+    reactions: serializeCommentReactions(readRecordValue(message, 'reactions')),
+    userColor: asString(readRecordValue(message, 'userColor')),
+    userName: asString(readRecordValue(message, 'userName')) || 'Anonymous',
   };
 }
 
 function serializeMessages(messages) {
-  const source = messages instanceof Y.Array
-    ? messages.toArray()
-    : Array.isArray(messages)
-      ? messages
-      : [];
-
-  return source
+  return asArray(messages)
     .map((message) => createMessageRecord(message))
     .filter(Boolean);
 }

package/src/domain/file-kind.js

@@ -2,6 +2,7 @@ const MARKDOWN_FILE_EXTENSIONS = Object.freeze(['.md', '.markdown', '.mdx']);
 const EXCALIDRAW_FILE_EXTENSION = '.excalidraw';
 const MERMAID_FILE_EXTENSIONS = Object.freeze(['.mmd', '.mermaid']);
 const PLANTUML_FILE_EXTENSIONS = Object.freeze(['.puml', '.plantuml']);
+const IMAGE_ATTACHMENT_EXTENSIONS = Object.freeze(['.png', '.jpg', '.jpeg', '.webp', '.gif', '.svg']);
 const DIAGRAM_FILE_EXTENSIONS = Object.freeze([
   EXCALIDRAW_FILE_EXTENSION,
   ...MERMAID_FILE_EXTENSIONS,
@@ -10,8 +11,9 @@ const DIAGRAM_FILE_EXTENSIONS = Object.freeze([
 const VAULT_FILE_EXTENSIONS = Object.freeze([
   ...MARKDOWN_FILE_EXTENSIONS,
   ...DIAGRAM_FILE_EXTENSIONS,
+  ...IMAGE_ATTACHMENT_EXTENSIONS,
 ]);
-const STRIP_VAULT_EXTENSION_PATTERN = /\.(?:md|markdown|mdx|excalidraw|mmd|mermaid|puml|plantuml)$/i;
+const STRIP_VAULT_EXTENSION_PATTERN = /\.(?:md|markdown|mdx|excalidraw|mmd|mermaid|puml|plantuml|png|jpe?g|webp|gif|svg)$/i;
 
 function normalizeFilePath(filePath) {
   return String(filePath ?? '').trim().toLowerCase();
@@ -25,6 +27,7 @@ function hasFileExtension(filePath, extensions) {
 export {
   DIAGRAM_FILE_EXTENSIONS,
   EXCALIDRAW_FILE_EXTENSION,
+  IMAGE_ATTACHMENT_EXTENSIONS,
   MARKDOWN_FILE_EXTENSIONS,
   MERMAID_FILE_EXTENSIONS,
   PLANTUML_FILE_EXTENSIONS,
@@ -48,6 +51,10 @@ export function getVaultFileKind(filePath) {
     return 'plantuml';
   }
 
+  if (hasFileExtension(filePath, IMAGE_ATTACHMENT_EXTENSIONS)) {
+    return 'image';
+  }
+
   return null;
 }
 
@@ -57,6 +64,10 @@ export function getVaultTreeNodeType(filePath) {
     return null;
   }
 
+  if (kind === 'image') {
+    return 'image';
+  }
+
   return kind === 'markdown' ? 'file' : kind;
 }
 
@@ -81,6 +92,10 @@ export function isPlantUmlFilePath(filePath) {
   return getVaultFileKind(filePath) === 'plantuml';
 }
 
+export function isImageAttachmentFilePath(filePath) {
+  return getVaultFileKind(filePath) === 'image';
+}
+
 export function isDiagramFilePath(filePath) {
   const kind = getVaultFileKind(filePath);
   return kind === 'excalidraw' || kind === 'mermaid' || kind === 'plantuml';

package/src/server/infrastructure/http/create-vault-api-command-handler.js

@@ -3,9 +3,22 @@ import {
   isMermaidFilePath,
   isPlantUmlFilePath,
 } from '../../../domain/file-kind.js';
-import { getRequestErrorStatusCode } from './http-errors.js';
+import { createRequestError, getRequestErrorStatusCode } from './http-errors.js';
 import { jsonResponse } from './http-response.js';
-import { parseJsonBody } from './request-body.js';
+import { parseJsonBody, readBinaryRequestBody } from './request-body.js';
+
+function decodeHeaderMetadata(value) {
+  const normalized = String(value ?? '').trim();
+  if (!normalized) {
+    return '';
+  }
+
+  try {
+    return decodeURIComponent(normalized);
+  } catch {
+    throw createRequestError(400, 'Invalid attachment metadata header encoding');
+  }
+}
 
 function selectWriteOperation(vaultFileStore, filePath, content) {
   if (isExcalidrawFilePath(filePath)) {
@@ -62,6 +75,39 @@ export function createVaultApiCommandHandler({
       return true;
     }
 
+    if (requestUrl.pathname === '/api/attachments' && req.method === 'POST') {
+      try {
+        const sourceDocumentPath = decodeHeaderMetadata(req.headers['x-collabmd-source-path']);
+        const originalFileName = decodeHeaderMetadata(req.headers['x-collabmd-file-name']);
+        const mimeType = String(req.headers['content-type'] || '').trim();
+
+        if (!sourceDocumentPath) {
+          jsonResponse(req, res, 400, { error: 'Missing source document path' });
+          return true;
+        }
+
+        const content = await readBinaryRequestBody(req);
+        const result = await vaultFileStore.writeImageAttachmentForDocument(sourceDocumentPath, {
+          content,
+          mimeType,
+          originalFileName,
+        });
+        if (!result.ok) {
+          jsonResponse(req, res, 400, { error: result.error });
+          return true;
+        }
+
+        jsonResponse(req, res, 201, {
+          markdown: result.markdownSnippet,
+          ok: true,
+          path: result.path,
+        });
+      } catch (error) {
+        handleVaultError(req, res, error, '[api] Failed to upload attachment:', 'Failed to upload attachment');
+      }
+      return true;
+    }
+
     if (requestUrl.pathname === '/api/file' && req.method === 'POST') {
       try {
         const body = await parseJsonBody(req);

package/src/server/infrastructure/http/create-vault-api-query-handler.js

@@ -1,9 +1,44 @@
+import { basename } from 'node:path';
+
 import {
   isExcalidrawFilePath,
+  isImageAttachmentFilePath,
   isMermaidFilePath,
   isPlantUmlFilePath,
 } from '../../../domain/file-kind.js';
-import { jsonResponse } from './http-response.js';
+import { jsonResponse, sendResponse } from './http-response.js';
+
+const SVG_MIME_TYPE = 'image/svg+xml';
+const SVG_ATTACHMENT_CSP = "default-src 'none'; img-src 'self' data: blob:; style-src 'unsafe-inline'; sandbox";
+
+function encodeContentDispositionFilename(fileName) {
+  return encodeURIComponent(String(fileName ?? ''))
+    .replace(/['()*]/g, (character) => `%${character.charCodeAt(0).toString(16).toUpperCase()}`);
+}
+
+function createSafeAsciiFilename(fileName) {
+  const fallback = String(fileName ?? '')
+    .replace(/[^\x20-\x7E]+/g, '_')
+    .replace(/["\\]/g, '_')
+    .trim();
+  return fallback || 'attachment';
+}
+
+function createAttachmentHeaders(attachment) {
+  const fileName = basename(String(attachment?.path ?? 'attachment'));
+  const headers = {
+    'Cache-Control': 'private, max-age=300, stale-while-revalidate=3600',
+    'Content-Disposition': `inline; filename="${createSafeAsciiFilename(fileName)}"; filename*=UTF-8''${encodeContentDispositionFilename(fileName)}`,
+    'Content-Type': attachment.mimeType,
+    'X-Content-Type-Options': 'nosniff',
+  };
+
+  if (attachment?.mimeType === SVG_MIME_TYPE) {
+    headers['Content-Security-Policy'] = SVG_ATTACHMENT_CSP;
+  }
+
+  return headers;
+}
 
 function selectReadOperation(vaultFileStore, filePath) {
   if (isExcalidrawFilePath(filePath)) {
@@ -58,6 +93,37 @@ export function createVaultApiQueryHandler({
       return true;
     }
 
+    if (requestUrl.pathname === '/api/attachment' && req.method === 'GET') {
+      const filePath = requestUrl.searchParams.get('path');
+      if (!filePath) {
+        jsonResponse(req, res, 400, { error: 'Missing path parameter' });
+        return true;
+      }
+
+      if (!isImageAttachmentFilePath(filePath)) {
+        jsonResponse(req, res, 400, { error: 'Unsupported attachment path' });
+        return true;
+      }
+
+      try {
+        const attachment = await vaultFileStore.readImageAttachmentFile(filePath);
+        if (!attachment) {
+          jsonResponse(req, res, 404, { error: 'Attachment not found' });
+          return true;
+        }
+
+        sendResponse(req, res, {
+          body: attachment.content,
+          headers: createAttachmentHeaders(attachment),
+          statusCode: 200,
+        });
+      } catch (error) {
+        console.error('[api] Failed to read attachment:', error.message);
+        jsonResponse(req, res, 500, { error: 'Failed to read attachment' });
+      }
+      return true;
+    }
+
     if (requestUrl.pathname === '/api/backlinks' && req.method === 'GET') {
       const filePath = requestUrl.searchParams.get('file');
       if (!filePath) {

package/src/server/infrastructure/http/request-body.js

@@ -2,7 +2,7 @@ import { createRequestError } from './http-errors.js';
 
 export const REQUEST_BODY_LIMIT_BYTES = 8_388_608;
 
-export async function readRequestBody(req, maxBytes = REQUEST_BODY_LIMIT_BYTES) {
+async function readRequestBuffer(req, maxBytes = REQUEST_BODY_LIMIT_BYTES) {
   return new Promise((resolve, reject) => {
     const chunks = [];
     let size = 0;
@@ -32,7 +32,7 @@ export async function readRequestBody(req, maxBytes = REQUEST_BODY_LIMIT_BYTES)
     };
 
     const onEnd = () => {
-      finish(resolve, Buffer.concat(chunks).toString('utf-8'));
+      finish(resolve, Buffer.concat(chunks));
     };
 
     const onError = (error) => {
@@ -45,6 +45,15 @@ export async function readRequestBody(req, maxBytes = REQUEST_BODY_LIMIT_BYTES)
   });
 }
 
+export async function readRequestBody(req, maxBytes = REQUEST_BODY_LIMIT_BYTES) {
+  const bodyBuffer = await readRequestBuffer(req, maxBytes);
+  return bodyBuffer.toString('utf-8');
+}
+
+export async function readBinaryRequestBody(req, maxBytes = REQUEST_BODY_LIMIT_BYTES) {
+  return readRequestBuffer(req, maxBytes);
+}
+
 export async function parseJsonBody(req) {
   const rawBody = await readRequestBody(req);
 

package/src/server/infrastructure/persistence/path-utils.js

@@ -3,7 +3,7 @@ import { isAbsolute, normalize, relative, resolve } from 'path';
 import { isVaultFilePath } from '../../../domain/file-kind.js';
 
 export const IGNORED_DIRECTORIES = new Set(['.git', '.obsidian', '.trash', 'node_modules', '.DS_Store']);
-export const VAULT_FILE_PATH_REQUIREMENT = '.md, .excalidraw, .mmd, .mermaid, .puml, or .plantuml';
+export const VAULT_FILE_PATH_REQUIREMENT = '.md, .excalidraw, .mmd, .mermaid, .puml, .plantuml, .png, .jpg, .jpeg, .webp, .gif, or .svg';
 export const INVALID_VAULT_FILE_PATH_ERROR = `Invalid file path — must end in ${VAULT_FILE_PATH_REQUIREMENT}`;
 export const INVALID_DIRECTORY_PATH_ERROR = 'Invalid directory path';
 

package/src/server/infrastructure/persistence/vault-file-store.js

@@ -1,7 +1,12 @@
 import { mkdir, readFile, readdir, rename, rm, stat, writeFile } from 'fs/promises';
-import { dirname, join, resolve } from 'path';
+import { basename, dirname, extname, join, relative, resolve } from 'path';
 
-import { getVaultTreeNodeType, isVaultFilePath } from '../../../domain/file-kind.js';
+import {
+  getVaultTreeNodeType,
+  isImageAttachmentFilePath,
+  isMarkdownFilePath,
+  isVaultFilePath,
+} from '../../../domain/file-kind.js';
 import { getVaultContentAdapter } from './vault-content-adapter.js';
 import {
   INVALID_VAULT_FILE_PATH_ERROR,
@@ -14,6 +19,23 @@ import {
 } from './path-utils.js';
 import { SidecarStore } from './sidecar-store.js';
 
+const IMAGE_EXTENSION_TO_MIME_TYPE = Object.freeze({
+  '.gif': 'image/gif',
+  '.jpeg': 'image/jpeg',
+  '.jpg': 'image/jpeg',
+  '.png': 'image/png',
+  '.svg': 'image/svg+xml',
+  '.webp': 'image/webp',
+});
+
+const MIME_TYPE_TO_IMAGE_EXTENSION = Object.freeze({
+  'image/gif': '.gif',
+  'image/jpeg': '.jpg',
+  'image/png': '.png',
+  'image/svg+xml': '.svg',
+  'image/webp': '.webp',
+});
+
 function createTransactionalPath(targetPath, label) {
   return `${targetPath}.collabmd-${label}-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2, 10)}`;
 }
@@ -42,6 +64,88 @@ async function cleanupPaths(paths = []) {
   await Promise.allSettled(paths.filter(Boolean).map((pathValue) => rm(pathValue, { force: true })));
 }
 
+function normalizeAttachmentMimeType(value) {
+  return String(value ?? '').split(';')[0].trim().toLowerCase();
+}
+
+function sanitizeAttachmentStem(value, fallback = 'image') {
+  const normalized = String(value ?? '')
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+  return normalized || fallback;
+}
+
+function padAttachmentTimestamp(value) {
+  return String(value).padStart(2, '0');
+}
+
+function createAttachmentTimestamp(date = new Date()) {
+  return [
+    date.getFullYear(),
+    padAttachmentTimestamp(date.getMonth() + 1),
+    padAttachmentTimestamp(date.getDate()),
+  ].join('')
+    + '-'
+    + [
+      padAttachmentTimestamp(date.getHours()),
+      padAttachmentTimestamp(date.getMinutes()),
+      padAttachmentTimestamp(date.getSeconds()),
+    ].join('');
+}
+
+function createDocumentAttachmentDirectoryPath(documentPath) {
+  const normalizedPath = String(documentPath ?? '').replace(/\\/g, '/');
+  const documentDir = dirname(normalizedPath).replace(/\\/g, '/');
+  const documentStem = basename(normalizedPath, extname(normalizedPath));
+  return documentDir === '.'
+    ? `${documentStem}.assets`
+    : `${documentDir}/${documentStem}.assets`;
+}
+
+function createAttachmentAltText(originalFileName = '') {
+  const stem = basename(String(originalFileName ?? ''), extname(String(originalFileName ?? '')))
+    .replace(/[_-]+/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+  return stem || 'Image';
+}
+
+function escapeMarkdownText(value = '') {
+  return String(value)
+    .replace(/\\/g, '\\\\')
+    .replace(/\[/g, '\\[')
+    .replace(/\]/g, '\\]')
+    .replace(/\r?\n/g, ' ');
+}
+
+function encodeMarkdownPath(pathValue = '') {
+  return String(pathValue)
+    .split('/')
+    .map((segment) => encodeURIComponent(segment))
+    .join('/');
+}
+
+function resolveAttachmentExtension({ mimeType, originalFileName }) {
+  const normalizedMimeType = normalizeAttachmentMimeType(mimeType);
+  const extensionFromName = extname(String(originalFileName ?? '')).toLowerCase();
+  if (extensionFromName && IMAGE_EXTENSION_TO_MIME_TYPE[extensionFromName]) {
+    const expectedMimeType = IMAGE_EXTENSION_TO_MIME_TYPE[extensionFromName];
+    if (!normalizedMimeType || expectedMimeType === normalizedMimeType) {
+      return extensionFromName;
+    }
+  }
+
+  return MIME_TYPE_TO_IMAGE_EXTENSION[normalizedMimeType] ?? '';
+}
+
+function createAttachmentMarkdownSnippet({ altText, documentPath, storedPath }) {
+  const relativePath = relative(dirname(documentPath), storedPath).replace(/\\/g, '/');
+  const encodedRelativePath = encodeMarkdownPath(relativePath || basename(storedPath));
+  return `![${escapeMarkdownText(altText)}](${encodedRelativePath})`;
+}
+
 export class VaultFileStore {
   constructor({ vaultDir }) {
     this.vaultDir = resolve(vaultDir);
@@ -174,6 +278,28 @@ export class VaultFileStore {
     return this.readContentFile(filePath, 'plantuml');
   }
 
+  async readImageAttachmentFile(filePath) {
+    const absolute = this.resolveContentPath(filePath, { requireVaultFile: false });
+    if (!absolute || !isImageAttachmentFilePath(filePath)) {
+      return null;
+    }
+
+    try {
+      const content = await readFile(absolute);
+      return {
+        content,
+        mimeType: IMAGE_EXTENSION_TO_MIME_TYPE[extname(filePath).toLowerCase()] || 'application/octet-stream',
+        path: filePath,
+      };
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        return null;
+      }
+
+      throw error;
+    }
+  }
+
   async writeMarkdownFile(filePath, content, options = {}) {
     return this.writeContentFile(filePath, content, 'markdown', options);
   }
@@ -190,6 +316,65 @@ export class VaultFileStore {
     return this.writeContentFile(filePath, content, 'plantuml', options);
   }
 
+  async writeImageAttachmentForDocument(sourceDocumentPath, {
+    content,
+    mimeType,
+    originalFileName = '',
+    now = new Date(),
+  } = {}) {
+    if (!Buffer.isBuffer(content) || content.byteLength === 0) {
+      return { ok: false, error: 'Missing attachment content' };
+    }
+
+    if (!isMarkdownFilePath(sourceDocumentPath)) {
+      return { ok: false, error: 'Source document must be a markdown file' };
+    }
+
+    const extension = resolveAttachmentExtension({ mimeType, originalFileName });
+    if (!extension) {
+      return { ok: false, error: 'Unsupported image type' };
+    }
+
+    const stemSource = basename(String(originalFileName ?? ''), extname(String(originalFileName ?? '')));
+    const attachmentStem = sanitizeAttachmentStem(stemSource, 'image');
+    const attachmentDirPath = createDocumentAttachmentDirectoryPath(sourceDocumentPath);
+    const timestamp = createAttachmentTimestamp(now);
+    const baseFileName = `${attachmentStem}-${timestamp}`;
+    let collisionIndex = 0;
+    let storedPath = '';
+    let absolutePath = '';
+
+    do {
+      const suffix = collisionIndex > 0 ? `-${collisionIndex + 1}` : '';
+      storedPath = `${attachmentDirPath}/${baseFileName}${suffix}${extension}`;
+      absolutePath = this.resolveContentPath(storedPath, { requireVaultFile: false });
+      collisionIndex += 1;
+    } while (absolutePath && await pathExists(absolutePath));
+
+    if (!absolutePath || !isImageAttachmentFilePath(storedPath)) {
+      return { ok: false, error: INVALID_VAULT_FILE_PATH_ERROR };
+    }
+
+    try {
+      await mkdir(dirname(absolutePath), { recursive: true });
+      await writeFile(absolutePath, content);
+    } catch (error) {
+      return { ok: false, error: error.message };
+    }
+
+    const altText = createAttachmentAltText(originalFileName);
+    return {
+      ok: true,
+      altText,
+      markdownSnippet: createAttachmentMarkdownSnippet({
+        altText,
+        documentPath: sourceDocumentPath,
+        storedPath,
+      }),
+      path: storedPath,
+    };
+  }
+
   async persistCollaborationState(filePath, {
     commentThreads = [],
     content = '',

package/public/assets/js/chunks/chunk-BBHPYU2R.js

@@ -1 +0,0 @@
-function o(e){let t=String(e??"").trim();return t?t.endsWith(".md")?t:`${t}.md`:null}function i(e,t){let r=o(e);if(!r||!Array.isArray(t)||t.length===0)return null;let a=String(e??"").trim();return t.find(n=>n===r||n.endsWith(`/${r}`)||n.replace(/\.md$/i,"")===a)??null}function u(e){return String(e).replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&quot;").replace(/'/g,"&#39;")}function l(e,t){return i(e,t)??void 0}function f(e,t,r){return Math.min(Math.max(e,t),r)}export{u as a,l as b,f as c};