@joinskips/brand 5.0.0 → 6.0.0-develop.124

package/chat/markdown.js

@@ -0,0 +1,129 @@
+import MarkdownIt from 'markdown-it';
+// Only addresses a visitor can safely follow. markdown-it already drops javascript:, vbscript:, file: and data:.
+export const LINK_PROTOCOLS = ['http:', 'https:', 'mailto:', 'tel:'];
+// HTML is shown as the text it is, and only an explicit address becomes a link. A single newline is a line break
+// (the tree has no soft breaks).
+// Headings, tables, images and reference links are left as typed: a chat bubble has no use for them.
+const reader = new MarkdownIt({ html: false, linkify: true, typographer: false })
+    .disable(['table', 'heading', 'lheading', 'image', 'reference'])
+    .enable('strikethrough');
+reader.linkify.set({ fuzzyLink: false, fuzzyEmail: false, fuzzyIP: false });
+function isFollowable(href) {
+    try {
+        return LINK_PROTOCOLS.includes(new URL(href).protocol);
+    }
+    catch {
+        return false;
+    }
+}
+const MARKS = {
+    strong_open: { type: 'strong', close: 'strong_close' },
+    em_open: { type: 'em', close: 'em_close' },
+    s_open: { type: 'del', close: 's_close' },
+};
+// markdown-it leaves empty and split text tokens where marks were weighed, so words are joined up here.
+function addInline(nodes, node) {
+    const last = nodes.at(-1);
+    if (node.type !== 'text')
+        nodes.push(node);
+    else if (last?.type === 'text')
+        last.text += node.text;
+    else if (node.text !== '')
+        nodes.push({ ...node });
+}
+// The inline nodes from tokens[from] up to the token that closes them.
+function inlinesFrom(tokens, from, closing) {
+    const nodes = [];
+    let i = from;
+    for (let token = tokens[i]; token !== undefined && token.type !== closing; token = tokens[i]) {
+        switch (token.type) {
+            case 'text':
+                addInline(nodes, { type: 'text', text: token.content });
+                break;
+            case 'softbreak':
+            case 'hardbreak':
+                addInline(nodes, { type: 'break' });
+                break;
+            case 'code_inline':
+                addInline(nodes, { type: 'code', text: token.content });
+                break;
+            case 'strong_open':
+            case 'em_open':
+            case 's_open': {
+                const mark = MARKS[token.type];
+                const inner = inlinesFrom(tokens, i + 1, mark.close);
+                addInline(nodes, { type: mark.type, children: inner.nodes });
+                i = inner.end;
+                break;
+            }
+            case 'link_open': {
+                const inner = inlinesFrom(tokens, i + 1, 'link_close');
+                // markdown-it gives every link its address. One that cannot be followed keeps its words and drops it.
+                const href = String(token.attrGet('href'));
+                if (isFollowable(href))
+                    addInline(nodes, { type: 'link', href, children: inner.nodes });
+                else
+                    for (const node of inner.nodes)
+                        addInline(nodes, node);
+                i = inner.end;
+                break;
+            }
+            // no default
+        }
+        i += 1;
+    }
+    return { nodes, end: i };
+}
+// An inline token's words. markdown-it's types allow a token with no children.
+export function inlinesOf(token) {
+    return inlinesFrom(token.children ?? [], 0, '').nodes;
+}
+// The blocks from tokens[from] up to the token that closes them.
+function blocksFrom(tokens, from, closing) {
+    const blocks = [];
+    let i = from;
+    for (let token = tokens[i]; token !== undefined && token.type !== closing; token = tokens[i]) {
+        switch (token.type) {
+            case 'inline':
+                blocks.push({ type: 'paragraph', children: inlinesOf(token) });
+                break;
+            case 'bullet_list_open':
+            case 'ordered_list_open': {
+                const items = [];
+                const close = token.type === 'bullet_list_open' ? 'bullet_list_close' : 'ordered_list_close';
+                // Each item holds its own blocks and ends at its closing token.
+                for (let at = i + 1; tokens[at]?.type !== close; at = i + 1) {
+                    const item = blocksFrom(tokens, at + 1, 'list_item_close');
+                    items.push(item.blocks);
+                    i = item.end;
+                }
+                blocks.push({
+                    type: 'list',
+                    ordered: token.type === 'ordered_list_open',
+                    start: Number(token.attrGet('start') ?? 1),
+                    items,
+                });
+                break;
+            }
+            case 'blockquote_open': {
+                const quoted = blocksFrom(tokens, i + 1, 'blockquote_close');
+                blocks.push({ type: 'quote', children: quoted.blocks });
+                i = quoted.end;
+                break;
+            }
+            case 'fence':
+            case 'code_block':
+                blocks.push({ type: 'code', text: token.content });
+                break;
+            case 'hr':
+                blocks.push({ type: 'rule' });
+                break;
+            // no default
+        }
+        i += 1;
+    }
+    return { blocks, end: i };
+}
+export function readMarkdown(source) {
+    return blocksFrom(reader.parse(source, {}), 0, '').blocks;
+}

package/chat/message.d.ts

@@ -0,0 +1,46 @@
+/** Who on Skips' side posted a line: a care team member, or the Skips App user or bot Skip's replies come from. */
+export interface ChatAuthor {
+    id: number | null;
+    name: string;
+    avatarUrl: string | null;
+    bot: boolean;
+}
+export interface ChatAttachment {
+    kind: 'image' | 'file';
+    url: string;
+    thumbUrl: string | null;
+    name: string;
+}
+/** A photo or PDF the member picked, before it is sent. The web's picker gives the file itself. */
+export interface PickedFile {
+    uri: string;
+    name: string;
+    type: string;
+    size: number;
+    file?: File;
+}
+/** One answer a question from Skips offers: the words on its button, and the value the Skips App keeps. */
+export interface ChoiceItem {
+    title: string;
+    value: string;
+}
+/** A question answered with one of its buttons. `chosen` is the answer's value, or null while there is none. */
+export interface MessageChoice {
+    items: ChoiceItem[];
+    chosen: string | null;
+}
+export interface ChatMessage {
+    id: number;
+    text: string;
+    sentAt: number;
+    mine: boolean;
+    notice: boolean;
+    author: ChatAuthor | null;
+    attachments: ChatAttachment[];
+    choice?: MessageChoice;
+}
+/**
+ * Whether a line from Skips is Skip's: one with no author, a bot's, or one from the Skips App user Skip's replies are
+ * posted as. A person on the care team is none of these.
+ */
+export declare function isSkip(message: Pick<ChatMessage, 'mine' | 'author'>, skipUserId: number | null): boolean;

package/chat/message.js

@@ -0,0 +1,12 @@
+// A message as the chat shows it. Each app maps its own Skips App API into this shape, so the chat never sees a
+// private note or an event the member does not.
+/**
+ * Whether a line from Skips is Skip's: one with no author, a bot's, or one from the Skips App user Skip's replies are
+ * posted as. A person on the care team is none of these.
+ */
+export function isSkip(message, skipUserId) {
+    if (message.mine)
+        return false;
+    const { author } = message;
+    return author === null || author.bot || author.id === null || author.id === skipUserId;
+}

package/chat/skipTyping.d.ts

@@ -0,0 +1,26 @@
+export declare const DOT_CYCLE_MS = 1000;
+export interface TypingState {
+    dots: boolean;
+    shown: boolean;
+    ending: boolean;
+    since: number;
+    turn: number;
+    beats: number;
+}
+export interface TypingStarted {
+    type: 'typing';
+    skipsLines: number;
+}
+export interface TypingSignal {
+    type: 'stopped' | 'shown' | 'capped';
+}
+export type TypingEvent = TypingStarted | TypingSignal;
+export declare const TYPING_IDLE: TypingState;
+export declare function typingReducer(state: TypingState, event: TypingEvent): TypingState;
+/** Where Skips' lines start being kept out of sight, or null while nothing is held. */
+export declare function heldFrom(state: TypingState): number | null;
+export interface TypingTimes {
+    leastMs: number;
+    limitMs: number;
+}
+export declare const TYPING_TIMES: TypingTimes;

package/chat/skipTyping.js

@@ -0,0 +1,29 @@
+// Skip typing, as the Skips App reports it: the dots come up when it says Skip is typing and go when it says Skip
+// stopped or the reply lands. They stay up for at least their minimum, and a reply that lands sooner waits out of
+// sight until then, so the dots never flash.
+// One rise and fall of the three dots. The dots stay up at least this long.
+export const DOT_CYCLE_MS = 1000;
+export const TYPING_IDLE = { dots: false, shown: false, ending: false, since: 0, turn: 0, beats: 0 };
+function down(state) {
+    return { ...state, dots: false, shown: false, ending: false };
+}
+export function typingReducer(state, event) {
+    if (event.type === 'typing') {
+        if (state.dots)
+            return { ...state, ending: false, beats: state.beats + 1 };
+        return { dots: true, shown: false, ending: false, since: event.skipsLines, turn: state.turn + 1, beats: state.beats + 1 };
+    }
+    // A timer or a stop that comes after the dots have gone changes nothing.
+    if (!state.dots)
+        return state;
+    if (event.type === 'shown')
+        return state.ending ? down(state) : { ...state, shown: true };
+    if (event.type === 'stopped' && !state.shown)
+        return { ...state, ending: true };
+    return down(state);
+}
+/** Where Skips' lines start being kept out of sight, or null while nothing is held. */
+export function heldFrom(state) {
+    return state.dots && !state.shown ? state.since : null;
+}
+export const TYPING_TIMES = { leastMs: DOT_CYCLE_MS, limitMs: 30_000 };

package/chat/thread.d.ts

@@ -0,0 +1,40 @@
+import { type ChatAuthor, type ChatMessage, type PickedFile } from './message.ts';
+export type Delivery = 'sent' | 'pending' | 'failed';
+export interface ThreadMessage extends ChatMessage {
+    delivery: Delivery;
+    localId?: number;
+    file?: PickedFile;
+}
+export interface Thread {
+    messages: ThreadMessage[];
+}
+export declare const EMPTY_THREAD: Thread;
+export declare function pendingId(): number;
+export declare function withPending(thread: Thread, id: number, text: string, sentAt: number, file?: PickedFile): Thread;
+/** The send answered: the pending line becomes the message the Skips App stored, or goes when the answer has none. */
+export declare function withSent(thread: Thread, pending: number, message: ChatMessage | null): Thread;
+/** Marks a pending line failed, or pending again as it is retried. */
+export declare function withFailed(thread: Thread, pending: number, failed?: boolean): Thread;
+export declare function withoutMessage(thread: Thread, id: number): Thread;
+/**
+ * A message from a page or the socket, added once. The socket can echo the member's line before the send that stored
+ * it answers, and the echo then takes the place of the earliest pending line with its text instead of showing twice.
+ */
+export declare function withReceived(thread: Thread, message: ChatMessage): Thread;
+export declare function withReceivedAll(thread: Thread, messages: ChatMessage[]): Thread;
+export declare const CLUSTER_GAP_MS = 120000;
+/** Who a run is from: the member, Skip, or a person on the care team. */
+export type RunSender = 'mine' | 'skip' | ChatAuthor;
+export type ThreadItem = {
+    kind: 'notice';
+    message: ThreadMessage;
+} | {
+    kind: 'unsent';
+    message: ThreadMessage;
+} | {
+    kind: 'run';
+    sender: RunSender;
+    messages: ThreadMessage[];
+};
+/** Notices and the member's unsent lines on their own, every other line in runs by sender, in order. */
+export declare function groupThread(messages: ThreadMessage[], skipUserId: number | null): ThreadItem[];

package/chat/thread.js

@@ -0,0 +1,107 @@
+// One conversation as the chat shows it: messages in time order, each sent, pending or failed, with no duplicates
+// when a page and the socket bring the same message, or when the socket echoes what the member just sent.
+import { isSkip } from "./message.js";
+export const EMPTY_THREAD = { messages: [] };
+// Pending lines get negative ids, which never collide with the Skips App's.
+let nextPendingId = -1;
+export function pendingId() {
+    const id = nextPendingId;
+    nextPendingId -= 1;
+    return id;
+}
+function ordered(messages) {
+    return { messages: [...messages].sort((a, b) => a.sentAt - b.sentAt || a.id - b.id) };
+}
+export function withPending(thread, id, text, sentAt, file) {
+    const line = {
+        id,
+        text,
+        sentAt,
+        mine: true,
+        notice: false,
+        author: null,
+        attachments: [],
+        delivery: 'pending',
+    };
+    return ordered([...thread.messages, file ? { ...line, file } : line]);
+}
+/** The send answered: the pending line becomes the message the Skips App stored, or goes when the answer has none. */
+export function withSent(thread, pending, message) {
+    const rest = thread.messages.filter((m) => m.id !== pending && m.id !== message?.id);
+    return message ? ordered([...rest, { ...message, delivery: 'sent', localId: pending }]) : { messages: rest };
+}
+/** Marks a pending line failed, or pending again as it is retried. */
+export function withFailed(thread, pending, failed = true) {
+    return {
+        messages: thread.messages.map((m) => (m.id === pending ? { ...m, delivery: failed ? 'failed' : 'pending' } : m)),
+    };
+}
+export function withoutMessage(thread, id) {
+    return { messages: thread.messages.filter((m) => m.id !== id) };
+}
+// An answer is never taken back, so a copy of a question without one keeps the answer the chat has.
+function keptChoice(known, incoming) {
+    if (incoming === undefined)
+        return known;
+    return incoming.chosen === null && known?.chosen != null ? known : incoming;
+}
+// A later copy of a message the chat has, such as an edit or an answered question, takes its place.
+function updated(known, message) {
+    const { choice: _incoming, ...rest } = message;
+    const choice = keptChoice(known.choice, message.choice);
+    return {
+        ...rest,
+        delivery: 'sent',
+        ...(known.localId === undefined ? {} : { localId: known.localId }),
+        ...(choice === undefined ? {} : { choice }),
+    };
+}
+/**
+ * A message from a page or the socket, added once. The socket can echo the member's line before the send that stored
+ * it answers, and the echo then takes the place of the earliest pending line with its text instead of showing twice.
+ */
+export function withReceived(thread, message) {
+    const known = thread.messages.find((m) => m.id === message.id);
+    if (known)
+        return { messages: thread.messages.map((m) => (m === known ? updated(known, message) : m)) };
+    const echoed = message.mine
+        ? thread.messages.find((m) => m.delivery === 'pending' && m.text === message.text)
+        : undefined;
+    if (echoed)
+        return withSent(thread, echoed.id, message);
+    return ordered([...thread.messages, { ...message, delivery: 'sent' }]);
+}
+export function withReceivedAll(thread, messages) {
+    return messages.reduce(withReceived, thread);
+}
+// Lines from the same sender within two minutes of the one before read as one run.
+export const CLUSTER_GAP_MS = 120_000;
+const senderKey = (sender) => (typeof sender === 'string' ? sender : `team:${sender.name}`);
+/** Notices and the member's unsent lines on their own, every other line in runs by sender, in order. */
+export function groupThread(messages, skipUserId) {
+    const senderOf = (m) => {
+        if (m.mine)
+            return 'mine';
+        return m.author && !isSkip(m, skipUserId) ? m.author : 'skip';
+    };
+    const items = [];
+    let run = null;
+    let runEnd = 0;
+    for (const message of messages) {
+        if (message.notice || message.delivery !== 'sent') {
+            items.push({ kind: message.notice ? 'notice' : 'unsent', message });
+            run = null;
+            continue;
+        }
+        const sender = senderOf(message);
+        if (run && senderKey(sender) === senderKey(run.sender) && message.sentAt - runEnd <= CLUSTER_GAP_MS) {
+            run.messages.push(message);
+        }
+        else {
+            run = { kind: 'run', sender, messages: [message] };
+            items.push(run);
+        }
+        runEnd = message.sentAt;
+    }
+    return items;
+}

package/chat/typing.d.ts

@@ -0,0 +1,13 @@
+export declare const TYPING_IDLE_MS = 3000;
+export declare const TYPING_CLEAR_MS = 10000;
+/** Tells the care team the member is typing. Call `typed` on each change of the text and `stop` when it is sent. */
+export declare function createTypingSignal(send: (typing: boolean) => void): {
+    typed(text: string): void;
+    stop: () => void;
+};
+/** Who on the care team is typing, each cleared after TYPING_CLEAR_MS without news. */
+export declare function createTypingWatch(onChange: (names: string[]) => void): {
+    update(name: string, typing: boolean): void;
+    clear: (name: string) => void;
+    dispose(): void;
+};

package/chat/typing.js

@@ -0,0 +1,60 @@
+// Typing, both ways. The member's typing goes out once when it starts and once when it stops, never per keystroke.
+// The care team's typing clears itself if the stop never arrives.
+export const TYPING_IDLE_MS = 3_000;
+export const TYPING_CLEAR_MS = 10_000;
+/** Tells the care team the member is typing. Call `typed` on each change of the text and `stop` when it is sent. */
+export function createTypingSignal(send) {
+    let typing = false;
+    let idle = null;
+    const stop = () => {
+        if (idle)
+            clearTimeout(idle);
+        idle = null;
+        if (typing)
+            send((typing = false));
+    };
+    return {
+        typed(text) {
+            if (!text.trim())
+                return stop();
+            if (!typing)
+                send((typing = true));
+            if (idle)
+                clearTimeout(idle);
+            idle = setTimeout(stop, TYPING_IDLE_MS);
+        },
+        stop,
+    };
+}
+/** Who on the care team is typing, each cleared after TYPING_CLEAR_MS without news. */
+export function createTypingWatch(onChange) {
+    const timers = new Map();
+    const publish = () => onChange([...timers.keys()]);
+    const clear = (name) => {
+        const timer = timers.get(name);
+        if (!timer)
+            return;
+        clearTimeout(timer);
+        timers.delete(name);
+        publish();
+    };
+    return {
+        update(name, typing) {
+            if (!typing)
+                return clear(name);
+            const timer = timers.get(name);
+            if (timer)
+                clearTimeout(timer);
+            timers.set(name, setTimeout(() => clear(name), TYPING_CLEAR_MS));
+            if (!timer)
+                publish();
+        },
+        // A message from someone ends their typing.
+        clear,
+        dispose() {
+            for (const timer of timers.values())
+                clearTimeout(timer);
+            timers.clear();
+        },
+    };
+}

package/chat/visibleArea.d.ts

@@ -0,0 +1,15 @@
+export interface VisualViewportBox {
+    offsetTop: number;
+    height: number;
+    scale: number;
+}
+export interface Fit {
+    top: number;
+    height: number;
+}
+export declare const UNZOOMED_WITHIN = 0.01;
+/**
+ * Where the chat sits so that it fills exactly what the visitor can see. A visitor who has zoomed in is reading one
+ * part of the chat, so it keeps the size it has and they move around it.
+ */
+export declare function fitVisibleArea(viewport: VisualViewportBox): Fit | undefined;

package/chat/visibleArea.js

@@ -0,0 +1,11 @@
+// A browser reports a scale a hair off 1 on a page nobody zoomed.
+export const UNZOOMED_WITHIN = 0.01;
+/**
+ * Where the chat sits so that it fills exactly what the visitor can see. A visitor who has zoomed in is reading one
+ * part of the chat, so it keeps the size it has and they move around it.
+ */
+export function fitVisibleArea(viewport) {
+    if (Math.abs(viewport.scale - 1) > UNZOOMED_WITHIN)
+        return undefined;
+    return { top: viewport.offsetTop, height: viewport.height };
+}

package/chat/welcome.d.ts

@@ -0,0 +1,25 @@
+export type WelcomeStep = 'choosing' | 'email' | 'code' | 'name' | 'through';
+export declare const NAME_MAX_LENGTH = 100;
+export declare const EMAIL_MAX_LENGTH = 254;
+export declare function isEmail(email: string): boolean;
+export declare function isName(name: string): boolean;
+export declare function givenEmail(typed: string): string | null;
+export declare function givenName(typed: string): string | null;
+export interface WelcomeTypingTimes {
+    leastMs: number;
+    mostMs: number;
+}
+export declare const WELCOME_TYPING_TIMES: WelcomeTypingTimes;
+/**
+ * Whether reaching this step has Skip say a new line. Going back a step, as Change email does, or staying on one,
+ * as a new code does, says nothing new, and the conversation after the welcome is the Skips App's to type.
+ */
+export declare function typesBefore(from: WelcomeStep | null, to: WelcomeStep): boolean;
+/** What the code field holds: its digits only, never more than the code has. A pasted "246 810" keeps its digits. */
+export declare function codeDigits(typed: string, length: number): string;
+/** Whether a change to the code field has just made it a whole code, so it goes on with no button pressed. */
+export declare function completesCode(digits: string, before: string, length: number): boolean;
+export declare const RESEND_AFTER_MS = 30000;
+/** The wait before a new code, as a clock: 0:30, then 0:09. */
+export declare function resendClock(seconds: number): string;
+export declare function typingMs(times: WelcomeTypingTimes, random: number): number;

package/chat/welcome.js

@@ -0,0 +1,51 @@
+// What a new visitor gives before the conversation starts, as the website's welcome asks for it: a choice, their
+// email, the code sent to it, and their name if the Skips App does not know them.
+import isEmailAddress from 'validator/lib/isEmail.js';
+export const NAME_MAX_LENGTH = 100;
+// The longest address a mailbox can have.
+export const EMAIL_MAX_LENGTH = 254;
+export function isEmail(email) {
+    return isEmailAddress(email);
+}
+export function isName(name) {
+    return name.length > 0 && name.length <= NAME_MAX_LENGTH;
+}
+// What was typed, without the spaces around it that a phone keyboard can add, or null when it is no address.
+export function givenEmail(typed) {
+    const given = typed.trim();
+    return isEmail(given) ? given : null;
+}
+export function givenName(typed) {
+    const given = typed.trim();
+    return isName(given) ? given : null;
+}
+// Skip types before a line the welcome says, as before a reply from the Skips App, for a random time between the
+// two so it reads as typed.
+export const WELCOME_TYPING_TIMES = { leastMs: 1000, mostMs: 2000 };
+// The steps that each bring a new line from Skip, in the order the welcome goes through them.
+const NEW_LINE_STEPS = ['choosing', 'email', 'code', 'name'];
+/**
+ * Whether reaching this step has Skip say a new line. Going back a step, as Change email does, or staying on one,
+ * as a new code does, says nothing new, and the conversation after the welcome is the Skips App's to type.
+ */
+export function typesBefore(from, to) {
+    const next = NEW_LINE_STEPS.indexOf(to);
+    return next !== -1 && (from === null || next > NEW_LINE_STEPS.indexOf(from));
+}
+/** What the code field holds: its digits only, never more than the code has. A pasted "246 810" keeps its digits. */
+export function codeDigits(typed, length) {
+    return typed.replace(/\D/g, '').slice(0, length);
+}
+/** Whether a change to the code field has just made it a whole code, so it goes on with no button pressed. */
+export function completesCode(digits, before, length) {
+    return digits.length === length && digits !== before;
+}
+// How long after a code goes out before a new one can be asked for. The code service holds the same wait.
+export const RESEND_AFTER_MS = 30_000;
+/** The wait before a new code, as a clock: 0:30, then 0:09. */
+export function resendClock(seconds) {
+    return `${String(Math.floor(seconds / 60))}:${String(seconds % 60).padStart(2, '0')}`;
+}
+export function typingMs(times, random) {
+    return times.leastMs + random * (times.mostMs - times.leastMs);
+}

package/manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": 5,
+  "version": 6,
   "files": {
     "app-icons/adaptive-foreground-1024.png": {
       "sha256": "1cfdc826654866b7bd1e4f549417f9f1918a66d5d8a0133dafbfd3d75d5ecc5f",
@@ -409,6 +409,10 @@
       "sha256": "6606d135bbbd06103bacef4cb89bf4019e53e092dcd19b51278edcbab1786b9d",
       "bytes": 130031
     },
+    "logos/png-2048/skips-wordmark-dark-2048.png": {
+      "sha256": "286ed3c2b3d37b8559ab773a692eca07d04d843ae093820c94ce5bdadff78713",
+      "bytes": 46330
+    },
     "logos/png-2048/skips-wordmark-light-2048.png": {
       "sha256": "61da312bae3aec7dddef398494fa98d13de940c81b3ecdb038c6904d26d85506",
       "bytes": 59707
@@ -484,6 +488,10 @@
     "tokens/skips-design-tokens.json": {
       "sha256": "bd0deecdedbad1a5ab28d0ec3231095d2b4691390a7d42257d259f3197f181ef",
       "bytes": 3205
+    },
+    "tokens/skips-tailwind-theme.css": {
+      "sha256": "00fef53e4e6c3bde68e93a2e5f0ba28edcf17e6da5df6823c7601461462364af",
+      "bytes": 3240
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@joinskips/brand",
-  "version": "5.0.0",
+  "version": "6.0.0-develop.124",
   "description": "Skips design tokens, Onest, logos, favicons, interface icons, member pictures and app icons.",
   "license": "UNLICENSED",
   "homepage": "https://brand.joinskips.com",
@@ -9,6 +9,38 @@
     "url": "git+https://github.com/joinskips/brand.git"
   },
   "exports": {
+    "./chat": {
+      "types": "./chat/index.d.ts",
+      "default": "./chat/index.js"
+    },
     "./*": "./*"
+  },
+  "dependencies": {
+    "markdown-it": "^14.3.3",
+    "validator": "^13.15.35"
+  },
+  "peerDependencies": {
+    "react": "^19.0.0",
+    "react-native": ">=0.81.0",
+    "react-native-web": "~0.21.0",
+    "tailwindcss": "^4.0.0",
+    "uniwind": "1.13.2"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "react-native": {
+      "optional": true
+    },
+    "react-native-web": {
+      "optional": true
+    },
+    "tailwindcss": {
+      "optional": true
+    },
+    "uniwind": {
+      "optional": true
+    }
   }
 }