@meistrari/chat-nuxt 1.0.0

package/dist/runtime/utils/export-conversation.js

@@ -0,0 +1,43 @@
+export function exportConversationToMarkdown(conversation) {
+  const formatDate = (date) => {
+    const d = new Date(date);
+    return d.toLocaleDateString("pt-BR", {
+      day: "2-digit",
+      month: "2-digit",
+      year: "numeric",
+      hour: "2-digit",
+      minute: "2-digit"
+    });
+  };
+  const lines = [
+    `# ${conversation.title}`,
+    "",
+    `**Criada por:** ${conversation.createdBy ?? "Desconhecido"}`,
+    `**Criada em:** ${formatDate(conversation.createdAt)}`,
+    "",
+    "---",
+    ""
+  ];
+  for (const msg of conversation.messages) {
+    const role = msg.role === "user" ? msg.createdBy ?? "Usu\xE1rio" : "Assistente";
+    const time = formatDate(msg.createdAt);
+    const ttft = msg.ttft ? ` | TTFT: ${msg.ttft}ms` : "";
+    lines.push(`**${role}** | ${time}${ttft}`);
+    lines.push("");
+    lines.push(msg.content);
+    lines.push("");
+    lines.push("---");
+    lines.push("");
+  }
+  const content = lines.join("\n");
+  const sanitizedTitle = conversation.title.replace(/[<>:"/\\|?*]/g, "_");
+  const blob = new Blob([content], { type: "text/markdown;charset=utf-8" });
+  const url = URL.createObjectURL(blob);
+  const link = document.createElement("a");
+  link.href = url;
+  link.download = `${sanitizedTitle}.md`;
+  document.body.appendChild(link);
+  link.click();
+  document.body.removeChild(link);
+  URL.revokeObjectURL(url);
+}

package/dist/runtime/utils/file.d.ts

@@ -0,0 +1,46 @@
+type VaultHashParams = {
+    filename?: string;
+    pageNumber?: number;
+};
+type DetectedFile = {
+    type: 'vault' | 'url';
+    reference: string;
+    name: string;
+    mimeType: string;
+    hashParams?: VaultHashParams;
+};
+type ContentSegment = {
+    type: 'text';
+    content: string;
+} | {
+    type: 'file';
+    file: DetectedFile;
+};
+declare const VAULT_PATTERN: RegExp;
+declare const VAULT_PERMALINK_PATTERN: RegExp;
+declare const MIME_TO_EXTENSION: Record<string, string>;
+declare const FILE_ICONS: Record<string, string>;
+declare function normalizeMimeType(mimeType: string): string;
+declare function getFileIcon(mimeType: string): string;
+declare function getFileTypeLabel(mimeType: string): string;
+declare function formatUploadDate(date?: Date): string;
+export declare function formatFileSize(bytes?: number): string;
+export declare function generateFileId(url: string): string;
+declare function stripTrailingPunctuation(url: string): string;
+declare function getMimeTypeFromExtension(ext: string): string;
+declare function normalizeVaultPermalinkUrl(url: string): string;
+declare function isVaultPermalink(url: string): boolean;
+declare function parseVaultHashParams(url: string): VaultHashParams | undefined;
+declare function detectFilesInText(text: string): DetectedFile[];
+declare function parseContentWithFiles(text: string): ContentSegment[];
+declare function detectFileFromUrl(url: string): DetectedFile | null;
+export declare function mergeFileUrls(contextFiles: {
+    vaultReference?: string | null;
+    url: string;
+}[] | null | undefined, messageFiles: {
+    vaultReference?: string | null;
+    url: string;
+}[] | null | undefined): string[] | undefined;
+declare function getMimeIcon(mimeType?: string): string;
+declare function getMimeLabel(mimeType?: string): string;
+export { type ContentSegment, type DetectedFile, detectFileFromUrl, detectFilesInText, FILE_ICONS, formatUploadDate, getFileIcon, getFileTypeLabel, getMimeIcon, getMimeLabel, getMimeTypeFromExtension, isVaultPermalink, MIME_TO_EXTENSION, normalizeMimeType, normalizeVaultPermalinkUrl, parseContentWithFiles, parseVaultHashParams, stripTrailingPunctuation, VAULT_PATTERN, VAULT_PERMALINK_PATTERN, type VaultHashParams, };

package/dist/runtime/utils/file.js

@@ -0,0 +1,500 @@
+const URL_CHAR_CLASS = "[^\\s\"'<>`\\[\\]()*_~]+";
+const VAULT_REGEX = /(?<!\]\()vault:\/\/[^\s"'<>`\[\]()*_~]+/gi;
+const URL_REGEX = /https?:\/\/[^\s"'<>`\[\]()*_~]+/gi;
+const VAULT_PATTERN = new RegExp(`vault://${URL_CHAR_CLASS}`, "gi");
+const VAULT_PERMALINK_PATTERN = new RegExp(`https://(?:[a-z0-9-]+\\.)*(?:vault|api)\\.tela(?:staging)?\\.com/(?:[a-z0-9_-]+/)*permalinks/${URL_CHAR_CLASS}`, "gi");
+const FILE_EXTENSIONS = {
+  pdf: "application/pdf",
+  doc: "application/msword",
+  docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  xls: "application/vnd.ms-excel",
+  xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ppt: "application/vnd.ms-powerpoint",
+  pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  svg: "image/svg+xml",
+  csv: "text/csv",
+  txt: "text/plain",
+  md: "text/markdown",
+  json: "application/json",
+  xml: "application/xml",
+  zip: "application/zip",
+  rar: "application/x-rar-compressed",
+  tar: "application/x-tar",
+  gz: "application/gzip",
+  tgz: "application/gzip",
+  mp4: "video/mp4",
+  webm: "video/webm",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  ogg: "audio/ogg",
+  py: "text/x-python",
+  js: "text/javascript",
+  ts: "text/typescript",
+  jsx: "text/javascript",
+  tsx: "text/typescript",
+  html: "text/html",
+  css: "text/css",
+  sql: "text/sql",
+  yaml: "text/yaml",
+  yml: "text/yaml",
+  go: "text/x-go",
+  rs: "text/x-rust",
+  rb: "text/x-ruby",
+  java: "text/x-java",
+  sh: "text/x-shellscript",
+  bash: "text/x-shellscript",
+  zsh: "text/x-shellscript",
+  c: "text/x-c",
+  h: "text/x-c",
+  cpp: "text/x-cpp",
+  cc: "text/x-cpp",
+  cxx: "text/x-cpp",
+  hpp: "text/x-cpp"
+};
+const MIME_TO_EXTENSION = (() => {
+  const map = {};
+  for (const [ext, mime] of Object.entries(FILE_EXTENSIONS)) {
+    if (!(mime in map))
+      map[mime] = ext;
+  }
+  return map;
+})();
+const FILE_ICONS = {
+  "application/pdf": "/files/pdf.svg",
+  "application/msword": "/files/doc.svg",
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document": "/files/doc.svg",
+  "application/vnd.ms-excel": "/files/sheet.svg",
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": "/files/sheet.svg",
+  "application/vnd.ms-powerpoint": "/files/presentation.svg",
+  "application/vnd.openxmlformats-officedocument.presentationml.presentation": "/files/presentation.svg",
+  "text/csv": "/files/sheet.svg",
+  "text/plain": "/files/generic.svg",
+  "text/markdown": "/files/markdown.svg",
+  "application/json": "/files/json.svg",
+  "application/xml": "/files/generic.svg",
+  "application/zip": "/files/archive.svg",
+  "application/x-rar-compressed": "/files/archive.svg",
+  "application/x-tar": "/files/archive.svg",
+  "application/gzip": "/files/archive.svg",
+  "image/jpeg": "/files/image.svg",
+  "image/png": "/files/image.svg",
+  "image/gif": "/files/image.svg",
+  "image/webp": "/files/image.svg",
+  "image/svg+xml": "/files/image.svg",
+  "video/mp4": "/files/video.svg",
+  "video/webm": "/files/video.svg",
+  "audio/mpeg": "/files/audio.svg",
+  "audio/wav": "/files/audio.svg",
+  "audio/ogg": "/files/audio.svg",
+  "text/x-python": "/files/python.svg",
+  "text/javascript": "/files/javascript.svg",
+  "text/typescript": "/files/typescript.svg",
+  "text/html": "/files/html.svg",
+  "text/css": "/files/css.svg",
+  "text/sql": "/files/sql.svg",
+  "text/yaml": "/files/yaml.svg",
+  "text/x-go": "/files/go.svg",
+  "text/x-rust": "/files/rust.svg",
+  "text/x-ruby": "/files/ruby.svg",
+  "text/x-java": "/files/java.svg",
+  "text/x-shellscript": "/files/shell.svg",
+  "text/x-c": "/files/c.svg",
+  "text/x-cpp": "/files/cpp.svg",
+  "unknown": "/files/generic.svg"
+};
+function normalizeMimeType(mimeType) {
+  return mimeType.split(";")[0]?.trim() ?? mimeType;
+}
+function getFileIcon(mimeType) {
+  return FILE_ICONS[mimeType] ?? "/files/generic.svg";
+}
+function getFileTypeLabel(mimeType) {
+  if (mimeType.includes("pdf"))
+    return "PDF";
+  if (mimeType.includes("word") || mimeType.includes("document"))
+    return "DOC";
+  if (mimeType.includes("excel") || mimeType.includes("spreadsheet") || mimeType.includes("csv"))
+    return "Planilha";
+  if (mimeType.includes("powerpoint") || mimeType.includes("presentation"))
+    return "Apresenta\xE7\xE3o";
+  if (mimeType.startsWith("image/"))
+    return "Imagem";
+  if (mimeType.startsWith("video/"))
+    return "V\xEDdeo";
+  if (mimeType.startsWith("audio/"))
+    return "\xC1udio";
+  if (mimeType.includes("json"))
+    return "JSON";
+  if (mimeType.includes("text"))
+    return "Texto";
+  return "Arquivo";
+}
+function formatUploadDate(date) {
+  if (!date)
+    return "-";
+  const now = /* @__PURE__ */ new Date();
+  const d = new Date(date);
+  const isToday = d.toDateString() === now.toDateString();
+  if (isToday) {
+    return `Hoje \xE0s ${d.toLocaleTimeString("pt-BR", { hour: "2-digit", minute: "2-digit" })}`;
+  }
+  const yesterday = new Date(now);
+  yesterday.setDate(yesterday.getDate() - 1);
+  if (d.toDateString() === yesterday.toDateString()) {
+    return `Ontem \xE0s ${d.toLocaleTimeString("pt-BR", { hour: "2-digit", minute: "2-digit" })}`;
+  }
+  return d.toLocaleDateString("pt-BR", { day: "2-digit", month: "short", year: "numeric" });
+}
+export function formatFileSize(bytes) {
+  if (bytes == null)
+    return "-";
+  if (bytes === 0)
+    return "0 B";
+  const units = ["B", "KB", "MB", "GB"];
+  const base = 1024;
+  const unitIndex = Math.min(Math.floor(Math.log(bytes) / Math.log(base)), units.length - 1);
+  const value = bytes / base ** unitIndex;
+  return `${value.toFixed(unitIndex === 0 ? 0 : 1)} ${units[unitIndex]}`;
+}
+export function generateFileId(url) {
+  let hash = 0;
+  for (let i = 0; i < url.length; i++) {
+    const char = url.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash).toString(36);
+}
+function stripTrailingPunctuation(url) {
+  return url.replace(/[.,:;!?]+$/, "");
+}
+function sanitizeFilename(filename) {
+  return filename.replace(/\.\./g, "").replace(/[/\\]/g, "-").replace(/^\.+/, "").replace(/[\x00-\x1F<>:"|?*]/g, "").replace(/^-+/, "").replace(/-+/g, "-").trim();
+}
+function getExtensionFromUrl(url) {
+  const cleanUrl = url.split("?")[0]?.split("#")[0];
+  if (!cleanUrl)
+    return void 0;
+  const match = cleanUrl.match(/\.([a-zA-Z0-9]+)$/);
+  return match?.[1]?.toLowerCase();
+}
+function getMimeTypeFromExtension(ext) {
+  return FILE_EXTENSIONS[ext] ?? "unknown";
+}
+function getNameFromUrl(url) {
+  const cleanUrl = url.split("?")[0]?.split("#")[0];
+  if (!cleanUrl)
+    return url;
+  const parts = cleanUrl.split("/");
+  return parts[parts.length - 1] ?? url;
+}
+function getNameFromVaultReference(reference) {
+  const parts = reference.replace("vault://", "").split("/");
+  return parts[parts.length - 1] || "Arquivo";
+}
+function isFileUrl(url) {
+  const ext = getExtensionFromUrl(url);
+  return ext !== void 0 && ext in FILE_EXTENSIONS;
+}
+function isVaultS3Url(url) {
+  return url.includes("vault-staging-permanentstorage.s3") || url.includes("vault-prod-permanentstorage.s3");
+}
+function normalizeVaultPermalinkUrl(url) {
+  return url.replace(
+    /^(https:\/\/(?:[a-z0-9-]+\.)*api\.tela(?:staging)?\.com)\/(permalinks\/)/,
+    "$1/_services/vault/$2"
+  );
+}
+function isVaultPermalink(url) {
+  try {
+    const parsed = new URL(url);
+    const host = parsed.host;
+    const isTelaHost = host === "vault.tela.com" || host.endsWith(".vault.tela.com") || host === "api.tela.com" || host.endsWith(".api.tela.com") || host === "api.telastaging.com" || host.endsWith(".api.telastaging.com");
+    return isTelaHost && /(?:^|\/)permalinks\//.test(parsed.pathname);
+  } catch {
+    return /^https:\/\/(?:[a-z0-9-]+\.)*(?:vault|api)\.tela(?:staging)?\.com\/(?:[a-z0-9_-]+\/)*permalinks\//.test(url);
+  }
+}
+function getFileInfoFromVaultS3Url(url) {
+  const filenameMatch = url.match(/filename%3D%22([^%]+)%22/);
+  if (filenameMatch?.[1]) {
+    const name = decodeURIComponent(filenameMatch[1]);
+    const ext = name.split(".").pop()?.toLowerCase();
+    return {
+      name,
+      mimeType: ext ? getMimeTypeFromExtension(ext) : "unknown"
+    };
+  }
+  return { name: "Arquivo", mimeType: "unknown" };
+}
+function parseVaultHashParams(url) {
+  const hashIndex = url.indexOf("#");
+  if (hashIndex === -1)
+    return void 0;
+  const hashPart = url.slice(hashIndex + 1);
+  const params = new URLSearchParams(hashPart);
+  const result = {};
+  const filename = params.get("filename");
+  if (filename) {
+    const sanitized = sanitizeFilename(filename);
+    if (sanitized)
+      result.filename = sanitized;
+  }
+  const pageNumber = params.get("page_number");
+  if (pageNumber) {
+    const parsed = Number.parseInt(pageNumber, 10);
+    if (!Number.isNaN(parsed) && parsed > 0)
+      result.pageNumber = parsed;
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function getPermalinkId(url) {
+  const match = url.match(/permalinks\/([a-f0-9-]+)/);
+  return match?.[1] ?? "Arquivo";
+}
+function detectFilesInText(text) {
+  const files = [];
+  const seen = /* @__PURE__ */ new Set();
+  const vaultMatches = text.match(VAULT_REGEX) ?? [];
+  for (const rawMatch of vaultMatches) {
+    const match = stripTrailingPunctuation(rawMatch);
+    if (seen.has(match))
+      continue;
+    seen.add(match);
+    const hashParams = parseVaultHashParams(match);
+    const filenameExt = hashParams?.filename?.split(".").pop()?.toLowerCase();
+    const urlExt = getExtensionFromUrl(match);
+    const ext = filenameExt ?? urlExt;
+    files.push({
+      type: "vault",
+      reference: match,
+      name: hashParams?.filename ?? getNameFromVaultReference(match),
+      mimeType: ext ? getMimeTypeFromExtension(ext) : "unknown",
+      hashParams
+    });
+  }
+  const urlMatches = text.match(URL_REGEX) ?? [];
+  for (const rawMatch of urlMatches) {
+    const match = stripTrailingPunctuation(rawMatch);
+    if (seen.has(match))
+      continue;
+    if (isVaultS3Url(match)) {
+      seen.add(match);
+      const { name, mimeType } = getFileInfoFromVaultS3Url(match);
+      files.push({
+        type: "url",
+        reference: match,
+        name,
+        mimeType
+      });
+      continue;
+    }
+    if (isVaultPermalink(match)) {
+      const normalized = normalizeVaultPermalinkUrl(match);
+      seen.add(match);
+      files.push({
+        type: "url",
+        reference: normalized,
+        name: "Arquivo",
+        mimeType: "unknown"
+      });
+      continue;
+    }
+    if (!isFileUrl(match))
+      continue;
+    seen.add(match);
+    const ext = getExtensionFromUrl(match);
+    files.push({
+      type: "url",
+      reference: match,
+      name: getNameFromUrl(match),
+      mimeType: ext ? getMimeTypeFromExtension(ext) : "unknown"
+    });
+  }
+  return files;
+}
+function parseContentWithFiles(text) {
+  const segments = [];
+  const fileMatches = [];
+  for (const match of text.matchAll(VAULT_REGEX)) {
+    const rawUrl = match[0];
+    const url = stripTrailingPunctuation(rawUrl);
+    const hashParams = parseVaultHashParams(url);
+    const filenameExt = hashParams?.filename?.split(".").pop()?.toLowerCase();
+    const urlExt = getExtensionFromUrl(url);
+    const ext = filenameExt ?? urlExt;
+    fileMatches.push({
+      start: match.index,
+      end: match.index + url.length,
+      file: {
+        type: "vault",
+        reference: url,
+        name: hashParams?.filename ?? getNameFromVaultReference(url),
+        mimeType: ext ? getMimeTypeFromExtension(ext) : "unknown",
+        hashParams
+      }
+    });
+  }
+  for (const match of text.matchAll(URL_REGEX)) {
+    const rawUrl = match[0];
+    const url = stripTrailingPunctuation(rawUrl);
+    if (isVaultS3Url(url)) {
+      const { name, mimeType } = getFileInfoFromVaultS3Url(url);
+      fileMatches.push({
+        start: match.index,
+        end: match.index + url.length,
+        file: {
+          type: "url",
+          reference: url,
+          name,
+          mimeType
+        }
+      });
+      continue;
+    }
+    if (isVaultPermalink(url)) {
+      fileMatches.push({
+        start: match.index,
+        end: match.index + url.length,
+        file: {
+          type: "url",
+          reference: normalizeVaultPermalinkUrl(url),
+          name: "Arquivo",
+          mimeType: "unknown"
+        }
+      });
+      continue;
+    }
+    if (isFileUrl(url)) {
+      const ext = getExtensionFromUrl(url);
+      fileMatches.push({
+        start: match.index,
+        end: match.index + url.length,
+        file: {
+          type: "url",
+          reference: url,
+          name: getNameFromUrl(url),
+          mimeType: ext ? getMimeTypeFromExtension(ext) : "unknown"
+        }
+      });
+    }
+  }
+  if (fileMatches.length === 0)
+    return [{ type: "text", content: text }];
+  fileMatches.sort((a, b) => a.start - b.start);
+  let lastEnd = 0;
+  for (const fm of fileMatches) {
+    if (fm.start > lastEnd) {
+      const textContent = text.slice(lastEnd, fm.start);
+      if (textContent)
+        segments.push({ type: "text", content: textContent });
+    }
+    segments.push({ type: "file", file: fm.file });
+    lastEnd = fm.end;
+  }
+  if (lastEnd < text.length) {
+    const textContent = text.slice(lastEnd);
+    if (textContent)
+      segments.push({ type: "text", content: textContent });
+  }
+  return segments;
+}
+function detectFileFromUrl(url) {
+  if (url.toLowerCase().startsWith("vault://")) {
+    const cleaned = stripTrailingPunctuation(url);
+    const hashParams = parseVaultHashParams(cleaned);
+    const filenameExt = hashParams?.filename?.split(".").pop()?.toLowerCase();
+    const urlExt = getExtensionFromUrl(cleaned);
+    const ext = filenameExt ?? urlExt;
+    return {
+      type: "vault",
+      reference: cleaned,
+      name: hashParams?.filename ?? getNameFromVaultReference(cleaned),
+      mimeType: ext ? getMimeTypeFromExtension(ext) : "unknown",
+      hashParams
+    };
+  }
+  if (isVaultPermalink(url)) {
+    const cleaned = normalizeVaultPermalinkUrl(stripTrailingPunctuation(url));
+    const hashParams = parseVaultHashParams(cleaned);
+    return {
+      type: "url",
+      reference: cleaned,
+      name: hashParams?.filename ?? getPermalinkId(cleaned),
+      mimeType: "unknown",
+      hashParams
+    };
+  }
+  if (isVaultS3Url(url)) {
+    const cleaned = stripTrailingPunctuation(url);
+    const { name, mimeType } = getFileInfoFromVaultS3Url(cleaned);
+    return {
+      type: "url",
+      reference: cleaned,
+      name,
+      mimeType
+    };
+  }
+  return null;
+}
+export function mergeFileUrls(contextFiles, messageFiles) {
+  const contextFileUrls = contextFiles?.map((f) => f.vaultReference || f.url) ?? [];
+  const messageFileUrls = messageFiles?.map((f) => f.vaultReference || f.url) ?? [];
+  const allFileUrls = [...contextFileUrls, ...messageFileUrls];
+  return allFileUrls.length > 0 ? allFileUrls : void 0;
+}
+function getMimeIcon(mimeType) {
+  if (!mimeType)
+    return "i-ph-file";
+  if (mimeType.includes("pdf"))
+    return "i-ph-file-pdf";
+  if (mimeType.startsWith("image/"))
+    return "i-ph-file-image";
+  if (mimeType.includes("spreadsheet") || mimeType.includes("excel"))
+    return "i-ph-file-xls";
+  if (mimeType.includes("document") || mimeType.includes("word"))
+    return "i-ph-file-doc";
+  if (mimeType.startsWith("text/"))
+    return "i-ph-file-text";
+  return "i-ph-file";
+}
+function getMimeLabel(mimeType) {
+  if (!mimeType)
+    return "Arquivo";
+  if (mimeType.includes("pdf"))
+    return "PDF";
+  if (mimeType.startsWith("image/"))
+    return "Imagem";
+  if (mimeType.includes("spreadsheet") || mimeType.includes("excel"))
+    return "Planilha";
+  if (mimeType.includes("document") || mimeType.includes("word"))
+    return "Documento";
+  if (mimeType.startsWith("text/"))
+    return "Texto";
+  return "Arquivo";
+}
+export {
+  detectFileFromUrl,
+  detectFilesInText,
+  FILE_ICONS,
+  formatUploadDate,
+  getFileIcon,
+  getFileTypeLabel,
+  getMimeIcon,
+  getMimeLabel,
+  getMimeTypeFromExtension,
+  isVaultPermalink,
+  MIME_TO_EXTENSION,
+  normalizeMimeType,
+  normalizeVaultPermalinkUrl,
+  parseContentWithFiles,
+  parseVaultHashParams,
+  stripTrailingPunctuation,
+  VAULT_PATTERN,
+  VAULT_PERMALINK_PATTERN
+};

package/dist/runtime/utils/format-time.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Formats a date to a relative or absolute string based on how old it is.
+ * - Today: "agora", "há 2 min", "há 3 horas"
+ * - Older: "18 de Dez." or "10/10/2024"
+ */
+export declare function formatRelativeTime(dateInput: Date | string): string;
+/**
+ * Groups a list of objects by a date field into chronological categories.
+ */
+export declare function groupConversationsByDate<T extends {
+    updatedAt: Date | string;
+}>(items: readonly T[]): {
+    title: string;
+    items: T[];
+}[];
+export declare function formatAbsoluteDate(dateInput: Date | string): string;
+export declare function formatDateWithTime(date?: string | Date): string;
+export declare function formatShortDate(dateStr: string): string;
+/**
+ * Legacy formatTime for backward compatibility if needed
+ */
+export declare function formatTime(time: string): string;