@singlebase/elements 0.3.0 → 0.5.0

package/dist/chat-messages.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Default copy for <singlebase-chat>. Same contract as the auth and upload
+ * bags: flat strings, overridable in whole or in part through `.messages`.
+ *
+ * `{name}`, `{n}` and `{query}` are filled in by `fill()` from upload-messages.
+ */
+export interface SinglebaseChatMessages {
+    eyebrowChat: string;
+    eyebrowRag: string;
+    eyebrowRich: string;
+    headingChat: string;
+    headingRag: string;
+    headingRich: string;
+    descriptionChat: string;
+    descriptionRag: string;
+    descriptionRich: string;
+    placeholderChat: string;
+    placeholderRag: string;
+    placeholderRich: string;
+    footnote: string;
+    attach: string;
+    send: string;
+    stop: string;
+    removeFile: string;
+    dropTitle: string;
+    dropSub: string;
+    thinking: string;
+    searching: string;
+    building: string;
+    chats: string;
+    newChat: string;
+    searchChats: string;
+    groupBookmarked: string;
+    groupToday: string;
+    groupYesterday: string;
+    groupWeek: string;
+    groupOlder: string;
+    noChats: string;
+    noMatch: string;
+    loadingChats: string;
+    showChats: string;
+    hideSidebar: string;
+    untitled: string;
+    renameChat: string;
+    bookmarkChat: string;
+    unbookmarkChat: string;
+    exportChat: string;
+    deleteChat: string;
+    expand: string;
+    restore: string;
+    minimize: string;
+    exportHeading: string;
+    exportMarkdown: string;
+    exportJson: string;
+    exportText: string;
+    exportCopy: string;
+    copy: string;
+    copied: string;
+    edit: string;
+    saveResend: string;
+    cancel: string;
+    regenerate: string;
+    helpful: string;
+    notHelpful: string;
+    markedHelpful: string;
+    thanksFeedback: string;
+    bookmarkMessage: string;
+    unbookmarkMessage: string;
+    deleteMessage: string;
+    saved: string;
+    stopped: string;
+    emptyReply: string;
+    newReply: string;
+    you: string;
+    sourcesCited: string;
+    sourcesRetrieved: string;
+    searchedSources: string;
+    sourceLabel: string;
+    openSource: string;
+    citedPassage: string;
+    copyReference: string;
+    alsoCited: string;
+    close: string;
+    undo: string;
+    chatDeleted: string;
+    messageDeleted: string;
+    messageBookmarked: string;
+    bookmarkRemoved: string;
+    chatBookmarked: string;
+    chatUnbookmarked: string;
+    exported: string;
+    copiedMarkdown: string;
+    fileTooLarge: string;
+    fileType: string;
+    tooManyFiles: string;
+    errGeneric: string;
+    errNotFound: string;
+    errNoClient: string;
+    errLoad: string;
+    retry: string;
+    offline: string;
+    bubbleText: string;
+    openChat: string;
+    closeChat: string;
+    dismiss: string;
+    brandingLabel: string;
+}
+export declare const defaultChatMessages: SinglebaseChatMessages;
+export declare function resolveChatMessages(overrides: Partial<SinglebaseChatMessages> | undefined): SinglebaseChatMessages;

package/dist/chat.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./chat-DRenTJlI.cjs");Object.defineProperty(exports,"SinglebaseChat",{enumerable:!0,get:()=>e.SinglebaseChat});exports.adaptBlocks=e.adaptBlocks;exports.citedNumbers=e.citedNumbers;exports.defaultChatMessages=e.defaultChatMessages;exports.describeSource=e.describeSource;exports.parseInline=e.parseInline;exports.parseMarkdown=e.parseMarkdown;exports.resolveChatMessages=e.resolveChatMessages;exports.splitFollowups=e.splitFollowups;
+//# sourceMappingURL=chat.cjs.map

package/dist/chat.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/chat.d.ts

@@ -0,0 +1,10 @@
+/**
+ * `@singlebase/elements/chat` — <singlebase-chat> on its own, without the
+ * authentication elements or the uploader. Importing it registers the tag.
+ */
+export { SinglebaseChat, describeSource } from "./elements/chat.js";
+export type { ChatAttachment, ChatClient, ChatConfig, ChatEmbed, ChatExportFormat, ChatGlow, ChatMessage, ChatMode, ChatPrompt, ChatSummary } from "./elements/chat.js";
+export { adaptBlocks, citedNumbers, parseInline, parseMarkdown, splitFollowups } from "./utils/markdown.js";
+export type { Block, ChartSpec, RenderAs, Segment } from "./utils/markdown.js";
+export { defaultChatMessages, resolveChatMessages } from "./chat-messages.js";
+export type { SinglebaseChatMessages } from "./chat-messages.js";

package/dist/chat.js

@@ -0,0 +1,13 @@
+import { S as e, a as r, c as l, d as o, b as t, p, e as d, r as c, s as i } from "./chat-bXaRWel7.js";
+export {
+  e as SinglebaseChat,
+  r as adaptBlocks,
+  l as citedNumbers,
+  o as defaultChatMessages,
+  t as describeSource,
+  p as parseInline,
+  d as parseMarkdown,
+  c as resolveChatMessages,
+  i as splitFollowups
+};
+//# sourceMappingURL=chat.js.map

package/dist/chat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/elements/{account-screen.d.ts → authui-account.d.ts}

@@ -1,6 +1,6 @@
 import { type PropertyValues } from "lit";
 import { type AuthSettings } from "@singlebase/singlebase-sdk";
-import { SinglebaseFormBase } from "./form-base.js";
+import { SinglebaseFormBase } from "./authui-form-base.js";
 import "./uploader.js";
 /**
  * The authenticated account view, laid out exactly as the design mock's

package/dist/elements/{buttons.d.ts → authui-buttons.d.ts}

@@ -1,6 +1,6 @@
 import { nothing, type PropertyValues } from "lit";
 import type { AuthSettings, OAuthIntent } from "@singlebase/singlebase-sdk";
-import { SinglebaseFormBase } from "./form-base.js";
+import { SinglebaseFormBase } from "./authui-form-base.js";
 export type ButtonsType = "signout" | "oauth" | "link";
 /**
  * The widget's action buttons, selected with `type`:

package/dist/elements/{display.d.ts → authui-display.d.ts}

@@ -1,5 +1,5 @@
 import { nothing, type PropertyValues } from "lit";
-import { SinglebaseElementBase } from "./base.js";
+import { SinglebaseElementBase } from "./authui-base.js";
 /**
  * Displays one value from the signed-in profile, as text or as an avatar.
  *

package/dist/elements/{form-base.d.ts → authui-form-base.d.ts}

@@ -1,4 +1,4 @@
-import { SinglebaseElementBase } from "./base.js";
+import { SinglebaseElementBase } from "./authui-base.js";
 export type FormPhase = "idle" | "submitting" | "success" | "error";
 /**
  * Adds the spec's required cross-cutting form behavior to SinglebaseElementBase:

package/dist/elements/{guard.d.ts → authui-guard.d.ts}

@@ -1,5 +1,5 @@
 import { type Predicate } from "@singlebase/core";
-import { SinglebaseElementBase } from "./base.js";
+import { SinglebaseElementBase } from "./authui-base.js";
 export type GuardState = "loading" | "authenticated" | "unauthenticated";
 /**
  * Renders content conditionally on auth state, and optionally on a predicate

package/dist/elements/{auth-screen.d.ts → authui.d.ts}

@@ -1,8 +1,8 @@
 import { nothing, type PropertyValues } from "lit";
 import { type AuthSettings } from "@singlebase/singlebase-sdk";
-import { SinglebaseElementBase } from "./base.js";
-import "./account-screen.js";
-import "./buttons.js";
+import { SinglebaseElementBase } from "./authui-base.js";
+import "./authui-account.js";
+import "./authui-buttons.js";
 /** Screens a signed-out visitor may reach. */
 export type GuestScreen = "signin" | "signup" | "forgot" | "verify" | "otp" | "newpass" | "invite";
 /** Screens that require a live session. */

package/dist/elements/chat.d.ts

@@ -0,0 +1,312 @@
+import { LitElement, type PropertyValues, type TemplateResult } from "lit";
+import { type SinglebaseChatMessages } from "../chat-messages.js";
+import { type RenderAs } from "../utils/markdown.js";
+export type ChatMode = "chat" | "rag" | "rich";
+export type ChatEmbed = "page" | "inline" | "launcher";
+export type ChatGlow = "subtle" | "vivid" | "off";
+export type ChatExportFormat = "md" | "txt" | "json" | "copy";
+/** What the chat needs from a client: `llm.call`, and nothing else. */
+export type ChatClient = {
+    llm: {
+        call<T = unknown>(method: string, payload?: unknown, options?: {
+            signal?: AbortSignal;
+        }): Promise<T>;
+    };
+};
+/** A row of `llm.list_chats`. */
+export interface ChatSummary {
+    _id: string;
+    title: string | null;
+    bookmarked?: boolean;
+    message_count?: number;
+    _created_at?: string;
+    _modified_at?: string;
+}
+/** A text file attached to one message, sent to the model as retrieval. */
+export interface ChatAttachment {
+    name: string;
+    size: number;
+    content: string;
+}
+export interface ChatMessage {
+    /** Local identity, stable across renders. */
+    key: string;
+    /** The server's message id, once known. Bookmark and delete need it. */
+    id: string | null;
+    role: "user" | "assistant";
+    /** The text. For replies, the FOLLOWUPS tail is already split off. */
+    content: string;
+    at: number;
+    bookmarked: boolean;
+    /** Retrieved documents the reply used, as the server recorded them. */
+    sources: Record<string, unknown>[];
+    followups: string[];
+    phase: "pending" | "streaming" | "done" | "error";
+    error?: string;
+    stopped?: boolean;
+    feedback?: "up" | "down";
+    attachments?: ChatAttachment[];
+    execTime?: number;
+    model?: string;
+}
+export interface ChatPrompt {
+    label?: string;
+    text: string;
+}
+/** Every setting in one object, keyed by property name. */
+export interface ChatConfig {
+    embed: ChatEmbed;
+    mode: ChatMode;
+    renderAs: RenderAs;
+    glow: ChatGlow;
+    position: "right" | "left";
+    sidebar: boolean | undefined;
+    showTitle: boolean;
+    assistantName: string;
+    logoUrl: string;
+    heading: string;
+    description: string;
+    prompts: string | (string | ChatPrompt)[];
+    bubbleText: string;
+    greetingBubble: boolean;
+    unreadBadge: boolean;
+    allowUpload: boolean;
+    allowExport: boolean;
+    branding: boolean;
+    followups: boolean;
+    autoTitle: boolean;
+    model: string;
+    params: Record<string, unknown>;
+    systemMessage: string;
+    retrieval: Record<string, unknown>[];
+    metadata: Record<string, unknown>;
+    messages: Partial<SinglebaseChatMessages>;
+    theme: "light" | "dark";
+}
+/** A readable view of whatever shape the server recorded for a source. */
+export declare function describeSource(source: Record<string, unknown>, n: number): {
+    n: number;
+    title: string;
+    path: string;
+    collection: string;
+    updated: string;
+    text: string;
+    score: number | null;
+};
+/**
+ * An AI chat workspace backed by the `llm.*` service.
+ *
+ *   <singlebase-chat></singlebase-chat>
+ *   <singlebase-chat embed="inline" mode="rag" retrieval='[{"type":"kdb","namespace":"docs"}]'></singlebase-chat>
+ *   <singlebase-chat embed="launcher" greeting-bubble unread-badge></singlebase-chat>
+ *
+ * Conversations live on the server, scoped to the signed-in user: the list
+ * comes from `llm.list_chats`, a thread from `llm.get_chat`, and each turn is
+ * one `llm.chat`. Titles and follow-up questions never add turns to the
+ * conversation — titles come from `llm.generate`, follow-ups from the reply.
+ */
+export declare class SinglebaseChat extends LitElement {
+    static styles: import("lit").CSSResult[];
+    /** An explicit client. Omit it and the page's SinglebaseClient() is used. */
+    accessor client: ChatClient | null;
+    accessor messages: Partial<SinglebaseChatMessages>;
+    accessor theme: "light" | "dark" | undefined;
+    /** `chat` free-form, `rag` grounded with citations, `rich` charts and tables. */
+    accessor mode: ChatMode;
+    /** How replies display. Copy and export always use the original text. */
+    accessor renderAs: RenderAs;
+    accessor glow: ChatGlow;
+    /** Ask for follow-up questions with each reply. */
+    accessor followups: boolean;
+    /** Replace the provisional title with a model-written one after the first reply. */
+    accessor autoTitle: boolean;
+    /** Model for new turns; empty uses the chat's, then the project default. */
+    accessor model: string;
+    accessor params: Record<string, unknown>;
+    /** Extra instructions, sent when a chat is created. */
+    accessor systemMessage: string;
+    /** Retrieval sources sent with every turn: `[{"type":"kdb","namespace":"docs"}]`. */
+    accessor retrieval: Record<string, unknown>[];
+    /** Stored on each user message. Never sent to the model. */
+    accessor metadata: Record<string, unknown>;
+    accessor embed: ChatEmbed;
+    /** Launcher side. */
+    accessor position: "right" | "left";
+    /** Force the chat list open or closed. Unset, it docks when there's room. */
+    accessor sidebar: boolean | undefined;
+    accessor showTitle: boolean;
+    /** Opens this chat on load. */
+    accessor chatIdAttr: string;
+    /** Used in placeholders, exports and labels. Never shown above messages. */
+    accessor assistantName: string;
+    accessor logoUrl: string;
+    accessor heading: string;
+    accessor description: string;
+    /** Suggested prompts: `|`-separated in markup, an array in JavaScript. */
+    accessor prompts: string | (string | ChatPrompt)[];
+    accessor bubbleText: string;
+    accessor greetingBubble: boolean;
+    accessor unreadBadge: boolean;
+    accessor allowUpload: boolean;
+    accessor allowExport: boolean;
+    /** The "Chat by Singlebase" credit. A plain link — it makes no request. */
+    accessor branding: boolean;
+    private accessor chatList;
+    private accessor listState;
+    private accessor activeId;
+    private accessor chatTitle;
+    private accessor bookmarked;
+    private accessor msgs;
+    private accessor loadingThread;
+    private accessor threadError;
+    private accessor busy;
+    private accessor draft;
+    private accessor files;
+    private accessor search;
+    private accessor sidebarOpen;
+    private accessor width;
+    private accessor panel;
+    private accessor menuOpen;
+    private accessor editingKey;
+    private accessor editDraft;
+    private accessor editingTitle;
+    private accessor renamingId;
+    private accessor toast;
+    private accessor copiedKey;
+    private accessor retrievalOpen;
+    private accessor arrivedKey;
+    private accessor dragging;
+    private accessor showJump;
+    private accessor offline;
+    private accessor isOpen;
+    private accessor expanded;
+    private accessor bubble;
+    private accessor seen;
+    private accessor mobile;
+    private run;
+    private abort;
+    private revealTimer;
+    private timers;
+    private toastTimer;
+    private stick;
+    private renamed;
+    private observer;
+    private observed;
+    private media;
+    private focusNext;
+    private bubbleScheduled;
+    get msg(): SinglebaseChatMessages;
+    /** An explicit `.client`, else the page default. */
+    get resolvedClient(): ChatClient | null;
+    /** The open conversation's id, or null for a new chat. */
+    get chatId(): string | null;
+    /** The open conversation's messages. */
+    get thread(): readonly ChatMessage[];
+    /** The loaded chat list. */
+    get chats(): readonly ChatSummary[];
+    set config(value: Partial<ChatConfig>);
+    get config(): Partial<ChatConfig>;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    willUpdate(changed: PropertyValues<this>): void;
+    firstUpdated(): void;
+    updated(): void;
+    private onNetwork;
+    private onMedia;
+    private later;
+    private emit;
+    private get docked();
+    private get panelDocked();
+    /** Starts a new, empty conversation. */
+    newChat(): void;
+    /** Opens a saved conversation. */
+    openChat(id: string): Promise<void>;
+    /** Sends a message; with no argument, sends the composer's text. */
+    send(text?: string): Promise<void>;
+    /** Stops waiting for, or revealing, the current reply. */
+    stop(): void;
+    /** Downloads the open conversation, or copies it as Markdown. */
+    exportChat(format?: ChatExportFormat): void;
+    /** Inline and launcher: fill the window. */
+    expand(): void;
+    collapse(): void;
+    /** Launcher: open the panel. */
+    open(): void;
+    /** Launcher: close the panel. */
+    close(): void;
+    private userMessage;
+    private systemPrompt;
+    private payloadFor;
+    private runTurn;
+    private failTurn;
+    /**
+     * The service answers in one piece; this reveals it progressively so it
+     * reads like a stream. Capped at about a second and a half.
+     */
+    private reveal;
+    /** Cancels any request or reveal in flight. */
+    private halt;
+    private retitle;
+    private applyTitle;
+    /**
+     * Enter and blur both land here. Saving on Enter directly (not via blur())
+     * matters: blur never fires on an input that doesn't have focus.
+     */
+    private commitTitle;
+    private commitRename;
+    private renameChat;
+    private fromServer;
+    private loadChats;
+    private upsertChat;
+    private touchChat;
+    private resetViewState;
+    private deleteOnServer;
+    private regenerate;
+    private retry;
+    private saveEdit;
+    private copy;
+    private toggleMessageBookmark;
+    private toggleChatBookmark;
+    /** Removed at once; the server call waits out the undo window. */
+    private deleteMessage;
+    private deleteChat;
+    private feedback;
+    private showToast;
+    /** Ends the current toast, committing whatever it was holding back. */
+    private flushToast;
+    private undo;
+    private addFiles;
+    private scrollToBottom;
+    private onScroll;
+    private jumpToLatest;
+    private onKeydown;
+    private onComposerKey;
+    private onComposerInput;
+    private onDragEnter;
+    private onDragLeave;
+    private onDrop;
+    render(): TemplateResult<1>;
+    private renderLauncher;
+    private renderWorkspace;
+    private renderSidebar;
+    private renderThreadRow;
+    private renderHeader;
+    private renderExportMenu;
+    private promptList;
+    private renderWelcome;
+    private renderThread;
+    private renderUser;
+    private pillLabel;
+    private renderBot;
+    private renderAnswer;
+    private renderInline;
+    private renderBlock;
+    private renderChart;
+    private renderPanel;
+    private renderComposer;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "singlebase-chat": SinglebaseChat;
+    }
+}

package/dist/files-BOwtpYyQ.js

@@ -0,0 +1,168 @@
+import { unsafeCSS as i, css as c } from "lit";
+const d = {
+  font: '"Geist", -apple-system, "Segoe UI", Helvetica, sans-serif',
+  mono: '"Geist Mono", ui-monospace, monospace',
+  accent: "#111111",
+  onAccent: "#ffffff",
+  radius: "4px",
+  surface: "#ffffff",
+  surfaceAlt: "#fafafa",
+  ink: "#16181a",
+  mutedInk: "#61666c",
+  border: "#e4e6e9",
+  borderStrong: "#cdd1d6",
+  danger: "#b4231a",
+  dangerBg: "#fdf1f0",
+  dangerBorder: "#f3d6d3",
+  dangerOutline: "#e8c4c0",
+  dangerPanelBorder: "#efd9d6",
+  dangerPanelBg: "#fdf7f6",
+  ok: "#0f6b4a",
+  okBg: "#f0f7f3",
+  okBorder: "#cfe5da",
+  gap: "16px",
+  pad: "20px",
+  fieldPad: "11px 13px"
+}, u = c`
+  :host {
+    display: block;
+    box-sizing: border-box;
+    font-family: var(--sb-font, ${i(d.font)});
+    color: var(--sb-ink, ${i(d.ink)});
+  }
+
+  :host([theme="dark"]) {
+    /* The light default accent is near-black, which disappears on a dark
+       surface — primary buttons and links both use it. A host that sets its
+       own --sb-accent still wins: outer-page declarations beat :host rules. */
+    --sb-accent: #f3f4f5;
+    --sb-on-accent: #17181b;
+    --sb-surface: #17181b;
+    --sb-surface-alt: #202226;
+    --sb-ink: #f3f4f5;
+    --sb-muted-ink: #a2a8ae;
+    --sb-border: #2c2f34;
+    --sb-border-strong: #3a3e44;
+    --sb-danger: #f08379;
+    --sb-danger-bg: rgba(240, 131, 121, 0.1);
+    --sb-danger-border: rgba(240, 131, 121, 0.3);
+    --sb-danger-outline: rgba(240, 131, 121, 0.4);
+    --sb-danger-panel-border: rgba(240, 131, 121, 0.3);
+    --sb-danger-panel-bg: rgba(240, 131, 121, 0.06);
+    --sb-ok: #6fd1a6;
+    --sb-ok-bg: rgba(111, 209, 166, 0.1);
+    --sb-ok-border: rgba(111, 209, 166, 0.28);
+  }
+
+  :host([density="compact"]) {
+    --sb-gap: 12px;
+    --sb-pad: 16px;
+    --sb-field-pad: 9px 11px;
+  }
+`, f = {
+  heading: "Upload files",
+  description: "Add one or more files. You can review the list before uploading.",
+  dropTitle: "Drag and drop files here",
+  dropSub: "or browse from your device",
+  hintUpTo: "up to {size} each",
+  chooseFiles: "Choose files",
+  chooseFile: "Choose file",
+  addMore: "+ Add more files",
+  remove: "Remove",
+  rename: "Rename",
+  retry: "Retry",
+  uploadCtaOne: "Upload {n} file",
+  uploadCtaMany: "Upload {n} files",
+  attachments: "Attachments",
+  dropOrChoose: "Drop files or choose",
+  checking: "Checking…",
+  pagesLabel: "{n} pages",
+  countOne: "{n} file of {max}",
+  countMany: "{n} files of {max}",
+  uploading: "Uploading…",
+  uploaded: "Uploaded",
+  failedLabel: "Failed",
+  errTooMany: "You can upload up to {max} files.",
+  errTooLarge: "{name} is larger than {size}.",
+  errTooSmall: "{name} is smaller than {size}.",
+  errDuplicate: "{name} is already in the list.",
+  errType: "{name} isn't an accepted file type.",
+  errNoClient: "No Singlebase client found on this page.",
+  errUpload: "Upload failed.",
+  errProtected: "{name} is password protected.",
+  errTooManyPages: "{name} has {pages} pages; the limit is {max}.",
+  brandingLabel: "Files by Singlebase"
+};
+function g(e) {
+  return e ? { ...f, ...e } : f;
+}
+function m(e, r) {
+  return e.replace(
+    /\{(\w+)\}/g,
+    (a, n) => n in r ? String(r[n]) : a
+  );
+}
+const l = {
+  b: 1,
+  kb: 1024,
+  mb: 1024 * 1024,
+  gb: 1024 * 1024 * 1024
+};
+function h(e) {
+  if (typeof e == "number") return e > 0 ? e : 0;
+  if (!e) return 0;
+  const r = String(e).trim().toLowerCase().match(/^([\d.]+)\s*(b|kb|mb|gb)?$/);
+  if (!r) return 0;
+  const a = Number.parseFloat(r[1]);
+  return !Number.isFinite(a) || a <= 0 ? 0 : Math.round(a * (l[r[2] ?? "b"] ?? 1));
+}
+function x(e) {
+  return e < 1024 ? `${e} B` : e < 1024 * 1024 ? `${Math.round(e / 1024)} KB` : e < 1024 * 1024 * 1024 ? `${(e / (1024 * 1024)).toFixed(1)} MB` : `${(e / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+}
+function p(e) {
+  const r = e.lastIndexOf(".");
+  return r <= 0 || r === e.length - 1 ? "" : e.slice(r + 1).toLowerCase();
+}
+function k(e) {
+  return p(e).toUpperCase().slice(0, 4);
+}
+function C(e, r, a) {
+  const n = e.split(",").map((t) => t.trim().toLowerCase()).filter(Boolean);
+  if (!n.length) return !0;
+  const o = r.toLowerCase(), s = (a || "").toLowerCase();
+  return n.some((t) => t.startsWith(".") ? o.endsWith(t) : t.endsWith("/*") ? s.startsWith(t.slice(0, -1)) : s === t);
+}
+function w(e) {
+  const r = e.split(",").map((a) => a.trim()).filter(Boolean).map((a) => {
+    if (a.startsWith(".")) return a.slice(1).toUpperCase();
+    if (a.endsWith("/*")) return a.slice(0, -2).toUpperCase();
+    const n = a.indexOf("/");
+    return (n >= 0 ? a.slice(n + 1) : a).toUpperCase();
+  });
+  return [...new Set(r)].join(", ");
+}
+function U(e) {
+  return `${e.name}:${e.size}:${e.lastModified ?? 0}`;
+}
+function S(e, r) {
+  const a = r.trim().replace(/[/\\]/g, "");
+  if (!a) return e;
+  const n = e.lastIndexOf("."), o = n > 0 ? e.slice(n) : "";
+  return o ? a.toLowerCase().endsWith(o.toLowerCase()) ? a : a + o : a;
+}
+export {
+  d as T,
+  x as a,
+  p as b,
+  C as c,
+  f as d,
+  U as e,
+  m as f,
+  S as g,
+  w as h,
+  k as i,
+  h as p,
+  g as r,
+  u as t
+};
+//# sourceMappingURL=files-BOwtpYyQ.js.map