@orangecatai/adgen-canvas 0.0.6 → 0.0.8

package/dist/prod/subset-shared.chunk.js

@@ -1 +1 @@
-import{a,b,c,d}from"./chunk-Z5NKEFVG.js";import"./chunk-R5LMMFAL.js";import"./chunk-SRAX5OIU.js";export{a as Commands,b as subsetToBase64,c as subsetToBinary,d as toBase64};
+import{a,b,c,d}from"./chunk-Z5NKEFVG.js";import"./chunk-B427J75A.js";import"./chunk-SRAX5OIU.js";export{a as Commands,b as subsetToBase64,c as subsetToBinary,d as toBase64};

package/dist/prod/subset-worker.chunk.js

@@ -1 +1 @@
-import{a as r,c as t}from"./chunk-Z5NKEFVG.js";import"./chunk-R5LMMFAL.js";import"./chunk-SRAX5OIU.js";var s=import.meta.url?new URL(import.meta.url):void 0;typeof window>"u"&&typeof self<"u"&&(self.onmessage=async e=>{switch(e.data.command){case r.Subset:let a=await t(e.data.arrayBuffer,e.data.codePoints);self.postMessage(a,{transfer:[a]});break}});export{s as WorkerUrl};
+import{a as r,c as t}from"./chunk-Z5NKEFVG.js";import"./chunk-B427J75A.js";import"./chunk-SRAX5OIU.js";var s=import.meta.url?new URL(import.meta.url):void 0;typeof window>"u"&&typeof self<"u"&&(self.onmessage=async e=>{switch(e.data.command){case r.Subset:let a=await t(e.data.arrayBuffer,e.data.codePoints);self.postMessage(a,{transfer:[a]});break}});export{s as WorkerUrl};

package/dist/types/excalidraw/components/AIChatPanel.d.ts

@@ -54,7 +54,7 @@ export type AIChatPanelProps = {
     onAfterImageGen?: () => void;
     /**
      * OpenRouter model tag for the chat system (both plain chat and agent loop).
-     * @default "openai/gpt-4.1-mini"
+     * @default "google/gemini-2.0-flash-001"
      * @example "openai/gpt-4o" or "anthropic/claude-sonnet-4"
      */
     chatModel?: string;
@@ -69,5 +69,14 @@ export type AIChatPanelProps = {
      * @example "gemini-2.0-flash-preview-image-generation"
      */
     agentImageModel?: string;
+    /**
+     * Optional brand identity context. When provided, the AI agent receives
+     * the brand's colors, typography, tone of voice, and imagery direction as
+     * a system-level context message so it can create on-brand ads.
+     *
+     * Pair this with `customFonts` on `<Excalidraw>` so that any uploaded
+     * brand font files are also registered in the canvas.
+     */
+    brandContext?: import("../types").BrandContext;
 };
 export declare const AIChatPanel: React.ForwardRefExoticComponent<AIChatPanelProps & React.RefAttributes<AIChatPanelRef>>;

package/dist/types/excalidraw/components/DarkModeToggle.d.ts

@@ -1,5 +1,5 @@
-import type { Theme } from "@orangecatai/element/types";
 import "./ToolIcon.scss";
+import type { Theme } from "@orangecatai/element/types";
 export declare const DarkModeToggle: (props: {
     value: Theme;
     onChange: (value: Theme) => void;

package/dist/types/excalidraw/components/ElementCanvasButtons.d.ts

@@ -1,5 +1,5 @@
-import type { ElementsMap, NonDeletedExcalidrawElement } from "@orangecatai/element/types";
 import "./ElementCanvasButtons.scss";
+import type { ElementsMap, NonDeletedExcalidrawElement } from "@orangecatai/element/types";
 export declare const ElementCanvasButtons: ({ children, element, elementsMap, }: {
     children: React.ReactNode;
     element: NonDeletedExcalidrawElement;

package/dist/types/excalidraw/components/FrameToolbar.d.ts

@@ -1,5 +1,5 @@
-import type { ExcalidrawFrameLikeElement, NonDeletedExcalidrawElement } from "@orangecatai/element/types";
 import "./FrameToolbar.scss";
+import type { ExcalidrawFrameLikeElement, NonDeletedExcalidrawElement } from "@orangecatai/element/types";
 import type { AppClassProperties } from "../types";
 export declare const FrameToolbar: ({ element, app, }: {
     element: NonDeletedExcalidrawElement & ExcalidrawFrameLikeElement;

package/dist/types/excalidraw/components/HintViewer.d.ts

@@ -1,5 +1,5 @@
-import type { EditorInterface } from "@orangecatai/common";
 import "./HintViewer.scss";
+import type { EditorInterface } from "@orangecatai/common";
 import type { AppClassProperties, UIAppState } from "../types";
 interface HintViewerProps {
     appState: UIAppState;

package/dist/types/excalidraw/components/Stats/DragInput.d.ts

@@ -1,6 +1,6 @@
-import type { Scene } from "@orangecatai/element";
 import { useApp, useExcalidrawSetAppState } from "../App";
 import "./DragInput.scss";
+import type { Scene } from "@orangecatai/element";
 import type { ElementsMap, ExcalidrawElement } from "@orangecatai/element/types";
 import type { StatsInputProperty } from "./utils";
 import type { AppState } from "../../types";

package/dist/types/excalidraw/components/Stats/index.d.ts

@@ -1,5 +1,5 @@
-import type { NonDeletedExcalidrawElement } from "@orangecatai/element/types";
 import "./Stats.scss";
+import type { NonDeletedExcalidrawElement } from "@orangecatai/element/types";
 import type { AppClassProperties, AppState, ExcalidrawProps } from "../../types";
 interface StatsProps {
     app: AppClassProperties;

package/dist/types/excalidraw/components/TTDDialog/utils/TTDStreamFetch.d.ts

@@ -20,5 +20,6 @@ export type StreamChunk = {
         status?: number;
     };
 };
+export declare function parseSSEStream(reader: ReadableStreamDefaultReader<Uint8Array>): AsyncGenerator<string, void, unknown>;
 export declare function TTDStreamFetch(options: StreamingOptions): Promise<TTTDDialog.OnTextSubmitRetValue>;
 export {};

package/dist/types/excalidraw/components/ToolButton.d.ts

@@ -1,6 +1,6 @@
 import React from "react";
-import type { PointerType } from "@orangecatai/element/types";
 import "./ToolIcon.scss";
+import type { PointerType } from "@orangecatai/element/types";
 import type { CSSProperties } from "react";
 export type ToolButtonSize = "small" | "medium";
 type ToolButtonBaseProps = {

package/dist/types/excalidraw/components/ai-chat/agentLoop.d.ts

@@ -1,4 +1,5 @@
 import { type ToolExecutionContext, type ToolResult } from "./canvasTools";
+import type { BrandContext } from "../../types";
 type ContentPart = {
     type: "text";
     text: string;
@@ -37,7 +38,7 @@ export type ToolAction = {
     result: ToolResult;
 };
 export type AgentUpdate = {
-    type: "status" | "tool_start" | "tool_done" | "final";
+    type: "status" | "tool_start" | "tool_done" | "final" | "content_delta";
     message: string;
     toolAction?: ToolAction;
 };
@@ -55,6 +56,11 @@ export declare function runAgentLoop(opts: {
     userMessages: Array<{
         role: "user" | "assistant";
         content: string;
+        /** Images attached to THIS specific message (from the user's upload history) */
+        imageAttachments?: Array<{
+            name: string;
+            dataUrl: string;
+        }>;
     }>;
     elementContext?: string;
     frameScreenshot?: string;
@@ -71,5 +77,12 @@ export declare function runAgentLoop(opts: {
         error?: string;
     }>;
     onAfterImageGen?: () => void;
+    /** Optional brand identity context — injected as a system message before user messages. */
+    brandContext?: BrandContext;
+    /**
+     * @deprecated Font IDs are now derived from brandContext.typography.fontFamilyId.
+     * Kept for API compatibility but no longer used internally.
+     */
+    customFontIds?: number[];
 }): Promise<AgentResult>;
 export {};

package/dist/types/excalidraw/components/ai-chat/canvasTools.d.ts

@@ -110,7 +110,7 @@ export declare const CANVAS_TOOLS: readonly [{
                 readonly fontFamily: {
                     readonly type: "number";
                     readonly enum: readonly [1, 2, 3, 4, 5];
-                    readonly description: "Font family: 1=Excalifont(hand), 2=Nunito(sans), 3=Comic Shanns(code), 4=Liberation Sans(clean sans), 5=cascadia(code). Default 2.";
+                    readonly description: "Font family: 1=Excalifont(hand), 2=Nunito(sans), 3=Comic Shanns(code), 4=Liberation Sans(clean sans), 5=Cascadia(code). Default 2.";
                 };
                 readonly strokeColor: {
                     readonly type: "string";
@@ -260,6 +260,183 @@ export declare const CANVAS_TOOLS: readonly [{
         };
     };
 }];
+/**
+ * Returns the canvas tool definitions for the agent, optionally extending
+ * the `add_text` fontFamily enum with custom font IDs.
+ *
+ * Pass the family IDs registered via `Fonts.registerCustomFont` so the
+ * agent knows it can use those numbers in `add_text` calls.
+ */
+export declare function getCanvasTools(extraFontIds?: number[]): typeof CANVAS_TOOLS;
+export declare const BANNER_TOOLS: readonly [{
+    readonly type: "function";
+    readonly function: {
+        readonly name: "create_frame";
+        readonly description: "Create a new frame on the canvas to act as the root container for your banner. Default size is 512x512. ALWAYS call this FIRST before generating images or HTML.";
+        readonly parameters: {
+            readonly type: "object";
+            readonly properties: {
+                readonly width: {
+                    readonly type: "number";
+                    readonly description: "Frame width in pixels (default 512)";
+                };
+                readonly height: {
+                    readonly type: "number";
+                    readonly description: "Frame height in pixels (default 512)";
+                };
+                readonly name: {
+                    readonly type: "string";
+                    readonly description: "Optional display name for the frame";
+                };
+            };
+            readonly required: readonly [];
+            readonly additionalProperties: false;
+        };
+    };
+}, {
+    readonly type: "function";
+    readonly function: {
+        readonly name: "generate_image";
+        readonly description: "Generate an image using AI (Gemini) and place it onto the canvas. Always call this for any photo or image content — even when the user has attached a reference image. The attached image is passed to Gemini as visual reference; Gemini generates the final output. Use referenceImageIndex to tell Gemini which user attachment to reference. IMPORTANT: your prompt must describe a purely visual scene — NO text, NO typography, NO words, NO captions, NO watermarks. All copy is handled by the HTML layer. A 'no text' safety suffix will be auto-appended, but you must also describe composition clearly (e.g. which side should be left open/empty for the HTML text).";
+        readonly parameters: {
+            readonly type: "object";
+            readonly properties: {
+                readonly frameId: {
+                    readonly type: "string";
+                    readonly description: "ID of the parent frame to insert the image into";
+                };
+                readonly prompt: {
+                    readonly type: "string";
+                    readonly description: "Detailed generation prompt. When using a reference image, describe what you want Gemini to produce — e.g. 'use this building as the subject, wide cinematic crop with open sky on the left for text overlay'.";
+                };
+                readonly x: {
+                    readonly type: "number";
+                    readonly description: "X position relative to the frame's top-left corner";
+                };
+                readonly y: {
+                    readonly type: "number";
+                    readonly description: "Y position relative to the frame's top-left corner";
+                };
+                readonly width: {
+                    readonly type: "number";
+                    readonly description: "Image width in pixels";
+                };
+                readonly height: {
+                    readonly type: "number";
+                    readonly description: "Image height in pixels";
+                };
+                readonly referenceImageIndex: {
+                    readonly type: "number";
+                    readonly description: "0-based index of the user's attached image to pass to Gemini as reference. Always use 0 when the user has attached an image.";
+                };
+            };
+            readonly required: readonly ["frameId", "prompt", "x", "y", "width", "height"];
+            readonly additionalProperties: false;
+        };
+    };
+}, {
+    readonly type: "function";
+    readonly function: {
+        readonly name: "generate_html_banner";
+        readonly description: "Place HTML/CSS text and shape elements into an EXISTING frame on the canvas. Always call create_frame first to get a frameId, then generate_image, then call this with that frameId. frameId is required — this tool does NOT create frames.";
+        readonly parameters: {
+            readonly type: "object";
+            readonly properties: {
+                readonly html: {
+                    readonly type: "string";
+                    readonly description: "Complete self-contained HTML with inline <style>. All layer elements must use position:absolute with explicit left/top/width/height in px. Root div must have class='canvas'.";
+                };
+                readonly frameId: {
+                    readonly type: "string";
+                    readonly description: "Required. The ID of the frame created by create_frame. Adds HTML elements into this existing frame, preserving existing children like images.";
+                };
+            };
+            readonly required: readonly ["html", "frameId"];
+            readonly additionalProperties: false;
+        };
+    };
+}, {
+    readonly type: "function";
+    readonly function: {
+        readonly name: "get_frame_elements";
+        readonly description: "Get all child elements inside a frame. Use when editing an existing banner to understand its current state before replacing.";
+        readonly parameters: {
+            readonly type: "object";
+            readonly properties: {
+                readonly frameId: {
+                    readonly type: "string";
+                    readonly description: "ID of the frame to inspect";
+                };
+            };
+            readonly required: readonly ["frameId"];
+            readonly additionalProperties: false;
+        };
+    };
+}, {
+    readonly type: "function";
+    readonly function: {
+        readonly name: "update_element";
+        readonly description: "Update properties of an existing element. Use for minor targeted fixes after the banner is placed.";
+        readonly parameters: {
+            readonly type: "object";
+            readonly properties: {
+                readonly elementId: {
+                    readonly type: "string";
+                };
+                readonly x: {
+                    readonly type: "number";
+                };
+                readonly y: {
+                    readonly type: "number";
+                };
+                readonly width: {
+                    readonly type: "number";
+                };
+                readonly height: {
+                    readonly type: "number";
+                };
+                readonly backgroundColor: {
+                    readonly type: "string";
+                };
+                readonly strokeColor: {
+                    readonly type: "string";
+                };
+                readonly opacity: {
+                    readonly type: "number";
+                };
+                readonly fontSize: {
+                    readonly type: "number";
+                };
+                readonly text: {
+                    readonly type: "string";
+                };
+                readonly fillStyle: {
+                    readonly type: "string";
+                    readonly enum: readonly ["solid", "hachure", "cross-hatch"];
+                };
+            };
+            readonly required: readonly ["elementId"];
+            readonly additionalProperties: false;
+        };
+    };
+}, {
+    readonly type: "function";
+    readonly function: {
+        readonly name: "delete_element";
+        readonly description: "Delete an element from the canvas.";
+        readonly parameters: {
+            readonly type: "object";
+            readonly properties: {
+                readonly elementId: {
+                    readonly type: "string";
+                    readonly description: "ID of the element to delete";
+                };
+            };
+            readonly required: readonly ["elementId"];
+            readonly additionalProperties: false;
+        };
+    };
+}];
 export declare function serializeElements(elements: readonly ExcalidrawElement[]): Record<string, unknown>[];
 export type FrameInfo = {
     id: string;
@@ -280,6 +457,21 @@ export type ToolExecutionContext = {
     signal?: AbortSignal;
     /** Override Gemini model ID for the agent's generate_image tool. */
     agentImageModel?: string;
+    /**
+     * Maps lowercase brand font-family names to their registered Excalidraw
+     * fontFamilyIds. Built from BrandContext.typography in runAgentLoop and
+     * used by the HTML parser to preserve brand fonts in text elements.
+     */
+    customFontMap?: Record<string, number>;
+    /**
+     * Image file attachments the user uploaded in the current chat turn.
+     * Indexed 0-based in the order they were attached.
+     * Used by place_attachment (direct placement) and generate_image (as Gemini reference).
+     */
+    fileAttachments?: Array<{
+        name: string;
+        dataUrl?: string;
+    }>;
 };
 export type ToolResult = {
     success: boolean;

package/dist/types/excalidraw/components/ai-chat/htmlToExcalidraw.d.ts

@@ -0,0 +1,53 @@
+export type ParsedRectangle = {
+    kind: "rectangle";
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    backgroundColor: string;
+    backgroundGradient?: string;
+    strokeColor: string;
+    strokeWidth: number;
+    opacity: number;
+    borderRadius: number;
+};
+export type ParsedEllipse = {
+    kind: "ellipse";
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    backgroundColor: string;
+    backgroundGradient?: string;
+    strokeColor: string;
+    strokeWidth: number;
+    opacity: number;
+};
+export type ParsedText = {
+    kind: "text";
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    text: string;
+    fontSize: number;
+    fontFamily: number;
+    color: string;
+    textAlign: "left" | "center" | "right";
+    opacity: number;
+};
+export type ParsedImage = {
+    kind: "image";
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    dataUrl: string;
+};
+export type ParsedElement = ParsedRectangle | ParsedEllipse | ParsedText | ParsedImage;
+/**
+ * Render `html` in an off-screen iframe and walk the DOM to produce an
+ * array of ParsedElement objects, translated so the root .canvas div sits
+ * at (frameX, frameY) in Excalidraw canvas coordinates.
+ */
+export declare function htmlToExcalidrawElements(html: string, frameX: number, frameY: number, frameWidth: number, frameHeight: number, customFontMap?: Record<string, number>): Promise<ParsedElement[]>;

package/dist/types/excalidraw/components/ai-chat/openRouterStream.d.ts

@@ -0,0 +1,50 @@
+import type { ToolCall } from "./agentLoop";
+export type OpenRouterDelta = {
+    content: string | null;
+    toolCalls: Array<{
+        index: number;
+        id?: string;
+        type?: string;
+        function?: {
+            name?: string;
+            arguments?: string;
+        };
+    }> | null;
+    finishReason: string | null;
+};
+export type ToolCallAccumulator = {
+    id: string;
+    type: "function";
+    function: {
+        name: string;
+        arguments: string;
+    };
+};
+/**
+ * Parse a single OpenAI-compatible SSE chunk JSON string into a typed delta.
+ * Returns null if the JSON is invalid or missing expected structure.
+ */
+export declare function parseOpenRouterChunk(jsonStr: string): OpenRouterDelta | null;
+/**
+ * Async generator that yields parsed deltas from an OpenRouter streaming
+ * response. Reuses `parseSSEStream` for SSE line parsing.
+ */
+export declare function streamOpenRouter(response: Response): AsyncGenerator<OpenRouterDelta>;
+/**
+ * Accumulate streaming tool call deltas into complete ToolCall objects.
+ * OpenRouter sends tool calls in chunks:
+ *   - First chunk for a tool: has `id`, `type`, `function.name`, empty `function.arguments`
+ *   - Subsequent chunks: has `function.arguments` fragment to append
+ */
+export declare function accumulateToolCalls(accumulated: ToolCallAccumulator[], delta: OpenRouterDelta): ToolCallAccumulator[];
+/**
+ * Convert accumulators to the ToolCall type used by the agent loop.
+ */
+export declare function finalizeToolCalls(accumulated: ToolCallAccumulator[]): ToolCall[];
+/**
+ * Check if a response is a streaming SSE response.
+ * Returns true only when the response has a body AND the content-type
+ * indicates an SSE stream (`text/event-stream`). Any other content-type
+ * (including `application/json` or `text/plain`) falls back to non-streaming.
+ */
+export declare function isStreamingResponse(response: Response): boolean;

package/dist/types/excalidraw/components/auto-resize/AutoResizePanel.d.ts

@@ -0,0 +1,16 @@
+import "./AutoResizePanel.scss";
+import type { ExcalidrawFrameLikeElement, NonDeletedExcalidrawElement } from "@orangecatai/element/types";
+import type { AppClassProperties } from "../../types";
+export declare const AutoResizePanel: ({ element, app, onClose, onBeforeAutoResize, onAfterAutoResize, openRouterApiKey, chatModel, agentImageModel, }: {
+    element: NonDeletedExcalidrawElement & ExcalidrawFrameLikeElement;
+    app: AppClassProperties;
+    onClose: () => void;
+    onBeforeAutoResize?: () => Promise<{
+        allowed: boolean;
+        error?: string;
+    }>;
+    onAfterAutoResize?: () => void;
+    openRouterApiKey: string;
+    chatModel: string;
+    agentImageModel?: string;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/types/excalidraw/components/auto-resize/AutoResizeShimmerLayer.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Renders shimmer overlays on top of in-progress auto-resize frames.
+ * Rendered unconditionally from App.tsx — same React tree as FrameToolbar
+ * and ElementCanvasButtons. Uses useExcalidrawAppState() for reactive
+ * viewport state (scroll, zoom, offset) so it repositions on every change.
+ */
+export declare const AutoResizeShimmerLayer: () => import("react/jsx-runtime").JSX.Element | null;

package/dist/types/excalidraw/components/auto-resize/autoResizeEngine.d.ts

@@ -0,0 +1,89 @@
+import type { ExcalidrawElement, ExcalidrawFrameLikeElement } from "@orangecatai/element/types";
+import type { AppClassProperties } from "../../types";
+import type { BinaryFiles } from "../../types";
+export type TargetDimension = {
+    width: number;
+    height: number;
+    label?: string;
+};
+export type DimensionResult = {
+    status: "ok";
+    frameId: string;
+} | {
+    status: "error";
+    error: string;
+};
+export type ProgressCallback = (dimensionIndex: number, total: number, phase: "bg-regen" | "layout" | "inserting" | "done" | "error", label: string) => void;
+type ForegroundEl = {
+    kind: "text";
+    relX: number;
+    relY: number;
+    width: number;
+    height: number;
+    text: string;
+    fontSize: number;
+    color: string;
+    textAlign: string;
+    fontWeight: string;
+    opacity: number;
+} | {
+    kind: "image";
+    relX: number;
+    relY: number;
+    width: number;
+    height: number;
+    dataUrl: string;
+    opacity: number;
+} | {
+    kind: "rect";
+    relX: number;
+    relY: number;
+    width: number;
+    height: number;
+    backgroundColor: string;
+    borderRadius: number;
+    opacity: number;
+};
+type SourceFrameInfo = {
+    frame: ExcalidrawFrameLikeElement;
+    background: {
+        type: "solid";
+        color: string;
+    } | {
+        type: "image";
+        dataUrl: string;
+    } | {
+        type: "none";
+    };
+    foreground: ForegroundEl[];
+};
+export declare function extractFrameInfo(elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement, files: BinaryFiles): SourceFrameInfo;
+export declare function needsBackgroundRegeneration(srcW: number, srcH: number, tgtW: number, tgtH: number): boolean;
+export type PreCreatedFrameInfo = {
+    frameId: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export declare function preCreateAllFrames(targetDimensions: TargetDimension[], sourceFrame: ExcalidrawFrameLikeElement, app: AppClassProperties): PreCreatedFrameInfo[];
+export declare function runAutoResize(opts: {
+    sourceFrameId: string;
+    targetDimensions: TargetDimension[];
+    app: AppClassProperties;
+    geminiApiKey: string;
+    openRouterApiKey: string;
+    chatModel?: string;
+    agentImageModel?: string;
+    customFontMap?: Record<string, number>;
+    onBeforeAutoResize?: () => Promise<{
+        allowed: boolean;
+        error?: string;
+    }>;
+    onAfterAutoResize?: () => void;
+    onProgress?: ProgressCallback;
+    signal?: AbortSignal;
+    /** Pass the result of preCreateAllFrames() to skip redundant frame creation */
+    preCreatedFrameInfos?: PreCreatedFrameInfo[];
+}): Promise<DimensionResult[]>;
+export {};

package/dist/types/excalidraw/components/auto-resize/autoResizeStore.d.ts

@@ -0,0 +1,16 @@
+export type LoadingFrameInfo = {
+    frameId: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+type Listener = () => void;
+export declare const autoResizeStore: {
+    setLoadingFrames(frames: LoadingFrameInfo[]): void;
+    markComplete(frameId: string): void;
+    clear(): void;
+    getLoadingFrames(): LoadingFrameInfo[];
+    subscribe(fn: Listener): () => void;
+};
+export {};

package/dist/types/excalidraw/components/hyperlink/Hyperlink.d.ts

@@ -1,6 +1,6 @@
+import "./Hyperlink.scss";
 import type { Scene } from "@orangecatai/element";
 import type { ElementsMap, ExcalidrawEmbeddableElement, NonDeletedExcalidrawElement } from "@orangecatai/element/types";
-import "./Hyperlink.scss";
 import type { AppState, ExcalidrawProps, UIAppState } from "../../types";
 export declare const Hyperlink: ({ element, scene, setAppState, onLinkOpen, setToast, updateEmbedValidationStatus, }: {
     element: NonDeletedExcalidrawElement;

package/dist/types/excalidraw/components/main-menu/DefaultItems.d.ts

@@ -1,5 +1,5 @@
-import type { Theme } from "@orangecatai/element/types";
 import "./DefaultItems.scss";
+import type { Theme } from "@orangecatai/element/types";
 export declare const LoadScene: {
     (): import("react/jsx-runtime").JSX.Element | null;
     displayName: string;

package/dist/types/excalidraw/components/ui/button.d.ts

@@ -1,7 +1,7 @@
 import * as React from "react";
 import { type VariantProps } from "class-variance-authority";
 declare const buttonVariants: (props?: ({
-    variant?: "link" | "default" | "outline" | "destructive" | "secondary" | "ghost" | null | undefined;
+    variant?: "link" | "default" | "outline" | "secondary" | "destructive" | "ghost" | null | undefined;
     size?: "icon" | "default" | "sm" | "lg" | null | undefined;
 } & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
 export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {

package/dist/types/excalidraw/fonts/Fonts.d.ts

@@ -14,6 +14,17 @@ export declare class Fonts {
         metadata: FontMetadata;
         fontFaces: ExcalidrawFontFace[];
     }>;
+    /**
+     * Register a custom font from a URL into the canvas font system.
+     *
+     * Use family IDs >= 1000 to avoid collisions with built-in fonts.
+     *
+     * Note: custom fonts are registered without a weight/style descriptor
+     * because getFontString generates "${size}px ${familyName}" (no weight),
+     * so the browser always requests the normal-weight variant. Pass the font
+     * file that should render by default for this family ID.
+     */
+    static registerCustomFont(spec: import("../types").CustomFontSpec): void;
     private readonly scene;
     constructor(scene: Scene);
     /**

package/dist/types/excalidraw/index.d.ts

@@ -52,3 +52,4 @@ export type { ExcalidrawImperativeAPI } from "./types";
 export type { AppState, BinaryFiles, BinaryFileData, ExcalidrawProps, ExcalidrawInitialDataState, LibraryItem, LibraryItems, SceneData, UnsubscribeCallback, } from "./types";
 export type { ExcalidrawElement, NonDeletedExcalidrawElement, NonDeleted, OrderedExcalidrawElement, ExcalidrawElementType, } from "@orangecatai/element/types";
 export type { ImageEditToolbarCallbacks } from "./components/ImageEditToolbar";
+export type { CustomFontSpec, BrandContext } from "./types";