@excalidraw/excalidraw 0.15.2-a89952e → 0.15.2-b57b3b5

package/types/element/linearElementEditor.d.ts

@@ -62,7 +62,7 @@ export declare class LinearElementEditor {
     static isSegmentTooShort(element: NonDeleted<ExcalidrawLinearElement>, startPoint: Point, endPoint: Point, zoom: AppState["zoom"]): boolean;
     static getSegmentMidPoint(element: NonDeleted<ExcalidrawLinearElement>, startPoint: Point, endPoint: Point, endPointIndex: number): readonly [number, number];
     static getSegmentMidPointIndex(linearElementEditor: LinearElementEditor, appState: AppState, midPoint: Point): number;
-    static handlePointerDown(event: React.PointerEvent<HTMLCanvasElement>, appState: AppState, history: History, scenePointer: {
+    static handlePointerDown(event: React.PointerEvent<HTMLElement>, appState: AppState, history: History, scenePointer: {
         x: number;
         y: number;
     }, linearElementEditor: LinearElementEditor): {
@@ -131,6 +131,10 @@ export declare class LinearElementEditor {
             showWelcomeScreen: boolean;
             isLoading: boolean;
             errorMessage: import("react").ReactNode;
+            activeEmbeddable: {
+                element: import("./types").NonDeletedExcalidrawElement;
+                state: "active" | "hover";
+            } | null;
             draggingElement: import("./types").NonDeletedExcalidrawElement | null;
             resizingElement: import("./types").NonDeletedExcalidrawElement | null;
             multiElement: NonDeleted<ExcalidrawLinearElement> | null;
@@ -138,12 +142,21 @@ export declare class LinearElementEditor {
             isBindingEnabled: boolean;
             startBoundElement: NonDeleted<ExcalidrawBindableElement> | null;
             suggestedBindings: import("./binding").SuggestedBinding[];
+            frameToHighlight: NonDeleted<import("./types").ExcalidrawFrameElement> | null;
+            frameRendering: {
+                enabled: boolean;
+                name: boolean;
+                outline: boolean;
+                clip: boolean;
+            };
+            editingFrame: string | null;
+            elementsToHighlight: NonDeleted<ExcalidrawElement>[] | null;
             editingElement: import("./types").NonDeletedExcalidrawElement | null;
             activeTool: {
                 lastActiveTool: import("../types").LastActiveTool;
                 locked: boolean;
             } & ({
-                type: "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "image" | "freedraw" | "eraser" | "hand";
+                type: "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "embeddable" | "image" | "frame" | "freedraw" | "eraser" | "hand";
                 customType: null;
             } | {
                 type: "custom";
@@ -167,7 +180,7 @@ export declare class LinearElementEditor {
             currentItemTextAlign: string;
             currentItemStartArrowhead: import("./types").Arrowhead | null;
             currentItemEndArrowhead: import("./types").Arrowhead | null;
-            currentItemRoundness: import("./types").StrokeRoundness;
+            currentItemRoundness: import("./types").StrokeRoundness; /** @returns whether point was dragged */
             viewBackgroundColor: string;
             scrollX: number;
             scrollY: number;
@@ -188,12 +201,13 @@ export declare class LinearElementEditor {
             openDialog: "imageExport" | "help" | "jsonExport" | null;
             defaultSidebarDockedPreference: boolean;
             lastPointerDownWith: import("./types").PointerType;
-            selectedElementIds: {
-                [id: string]: boolean;
-            };
+            selectedElementIds: Readonly<{
+                [id: string]: true;
+            }>;
             previousSelectedElementIds: {
-                [id: string]: boolean;
+                [id: string]: true;
             };
+            selectedElementsAreBeingDragged: boolean;
             shouldCacheIgnoreZoom: boolean;
             toast: {
                 message: string;
@@ -201,7 +215,7 @@ export declare class LinearElementEditor {
                 duration?: number | undefined;
             } | null;
             zenModeEnabled: boolean;
-            theme: string;
+            theme: import("./types").Theme;
             gridSize: number | null;
             viewModeEnabled: boolean;
             selectedGroupIds: {
@@ -224,7 +238,7 @@ export declare class LinearElementEditor {
                 data: import("../charts").Spreadsheet;
             };
             pendingImageElementId: string | null;
-            showHyperlinkPopup: false | "info" | "editor";
+            showHyperlinkPopup: false | "editor" | "info";
             selectedLinearElement: LinearElementEditor | null;
         };
     };

package/types/element/newElement.d.ts

@@ -1,10 +1,15 @@
-import { ExcalidrawElement, ExcalidrawImageElement, ExcalidrawTextElement, ExcalidrawLinearElement, ExcalidrawGenericElement, NonDeleted, TextAlign, GroupId, VerticalAlign, Arrowhead, ExcalidrawFreeDrawElement, FontFamilyValues, ExcalidrawTextContainer } from "../element/types";
+import { ExcalidrawElement, ExcalidrawImageElement, ExcalidrawTextElement, ExcalidrawLinearElement, ExcalidrawGenericElement, NonDeleted, TextAlign, GroupId, VerticalAlign, Arrowhead, ExcalidrawFreeDrawElement, FontFamilyValues, ExcalidrawTextContainer, ExcalidrawFrameElement, ExcalidrawEmbeddableElement } from "../element/types";
 import { AppState } from "../types";
 import { MarkOptional, Mutable } from "../utility-types";
-type ElementConstructorOpts = MarkOptional<Omit<ExcalidrawGenericElement, "id" | "type" | "isDeleted" | "updated">, "width" | "height" | "angle" | "groupIds" | "boundElements" | "seed" | "version" | "versionNonce" | "link" | "strokeStyle" | "fillStyle" | "strokeColor" | "backgroundColor" | "roughness" | "strokeWidth" | "roundness" | "locked" | "opacity">;
+type ElementConstructorOpts = MarkOptional<Omit<ExcalidrawGenericElement, "id" | "type" | "isDeleted" | "updated">, "width" | "height" | "angle" | "groupIds" | "frameId" | "boundElements" | "seed" | "version" | "versionNonce" | "link" | "strokeStyle" | "fillStyle" | "strokeColor" | "backgroundColor" | "roughness" | "strokeWidth" | "roundness" | "locked" | "opacity">;
 export declare const newElement: (opts: {
     type: ExcalidrawGenericElement["type"];
 } & ElementConstructorOpts) => NonDeleted<ExcalidrawGenericElement>;
+export declare const newEmbeddableElement: (opts: {
+    type: "embeddable";
+    validated: boolean | undefined;
+} & ElementConstructorOpts) => NonDeleted<ExcalidrawEmbeddableElement>;
+export declare const newFrameElement: (opts: ElementConstructorOpts) => NonDeleted<ExcalidrawFrameElement>;
 export declare const newTextElement: (opts: {
     text: string;
     fontSize?: number;

package/types/element/resizeElements.d.ts

@@ -4,5 +4,6 @@ import { PointerDownState } from "../types";
 export declare const normalizeAngle: (angle: number) => number;
 export declare const transformElements: (pointerDownState: PointerDownState, transformHandleType: MaybeTransformHandleType, selectedElements: readonly NonDeletedExcalidrawElement[], resizeArrowDirection: "origin" | "end", shouldRotateWithDiscreteAngle: boolean, shouldResizeFromCenter: boolean, shouldMaintainAspectRatio: boolean, pointerX: number, pointerY: number, centerX: number, centerY: number) => boolean;
 export declare const resizeSingleElement: (originalElements: PointerDownState["originalElements"], shouldMaintainAspectRatio: boolean, element: NonDeletedExcalidrawElement, transformHandleDirection: TransformHandleDirection, shouldResizeFromCenter: boolean, pointerX: number, pointerY: number) => void;
+export declare const resizeMultipleElements: (pointerDownState: PointerDownState, selectedElements: readonly NonDeletedExcalidrawElement[], transformHandleType: "nw" | "ne" | "sw" | "se", shouldResizeFromCenter: boolean, pointerX: number, pointerY: number) => void;
 export declare const getResizeOffsetXY: (transformHandleType: MaybeTransformHandleType, selectedElements: NonDeletedExcalidrawElement[], x: number, y: number) => [number, number];
 export declare const getResizeArrowDirection: (transformHandleType: MaybeTransformHandleType, element: NonDeleted<ExcalidrawLinearElement>) => "origin" | "end";

package/types/element/transformHandles.d.ts

@@ -13,11 +13,18 @@ export declare const OMIT_SIDES_FOR_MULTIPLE_ELEMENTS: {
     n: boolean;
     w: boolean;
 };
+export declare const OMIT_SIDES_FOR_FRAME: {
+    e: boolean;
+    s: boolean;
+    n: boolean;
+    w: boolean;
+    rotation: boolean;
+};
 export declare const getTransformHandlesFromCoords: ([x1, y1, x2, y2, cx, cy]: [number, number, number, number, number, number], angle: number, zoom: Zoom, pointerType: PointerType, omitSides?: {
     s?: boolean | undefined;
     e?: boolean | undefined;
-    n?: boolean | undefined;
     w?: boolean | undefined;
+    n?: boolean | undefined;
     nw?: boolean | undefined;
     ne?: boolean | undefined;
     sw?: boolean | undefined;

package/types/element/typeChecks.d.ts

@@ -1,10 +1,12 @@
 import { AppState } from "../types";
 import { MarkNonNullable } from "../utility-types";
-import { ExcalidrawElement, ExcalidrawTextElement, ExcalidrawLinearElement, ExcalidrawBindableElement, ExcalidrawGenericElement, ExcalidrawFreeDrawElement, InitializedExcalidrawImageElement, ExcalidrawImageElement, ExcalidrawTextElementWithContainer, ExcalidrawTextContainer, RoundnessType } from "./types";
+import { ExcalidrawElement, ExcalidrawTextElement, ExcalidrawEmbeddableElement, ExcalidrawLinearElement, ExcalidrawBindableElement, ExcalidrawGenericElement, ExcalidrawFreeDrawElement, InitializedExcalidrawImageElement, ExcalidrawImageElement, ExcalidrawTextElementWithContainer, ExcalidrawTextContainer, ExcalidrawFrameElement, RoundnessType } from "./types";
 export declare const isGenericElement: (element: ExcalidrawElement | null) => element is ExcalidrawGenericElement;
 export declare const isInitializedImageElement: (element: ExcalidrawElement | null) => element is InitializedExcalidrawImageElement;
 export declare const isImageElement: (element: ExcalidrawElement | null) => element is ExcalidrawImageElement;
+export declare const isEmbeddableElement: (element: ExcalidrawElement | null | undefined) => element is ExcalidrawEmbeddableElement;
 export declare const isTextElement: (element: ExcalidrawElement | null) => element is ExcalidrawTextElement;
+export declare const isFrameElement: (element: ExcalidrawElement | null) => element is ExcalidrawFrameElement;
 export declare const isFreeDrawElement: (element?: ExcalidrawElement | null) => element is ExcalidrawFreeDrawElement;
 export declare const isFreeDrawElementType: (elementType: ExcalidrawElement["type"]) => boolean;
 export declare const isLinearElement: (element?: ExcalidrawElement | null) => element is ExcalidrawLinearElement;

package/types/element/types.d.ts

@@ -49,6 +49,7 @@ type _ExcalidrawElementBase = Readonly<{
     /** List of groups the element belongs to.
         Ordered from deepest to shallowest. */
     groupIds: readonly GroupId[];
+    frameId: string | null;
     /** other elements that are bound to this element */
     boundElements: readonly Readonly<{
         id: ExcalidrawLinearElement["id"];
@@ -72,6 +73,17 @@ export type ExcalidrawDiamondElement = _ExcalidrawElementBase & {
 export type ExcalidrawEllipseElement = _ExcalidrawElementBase & {
     type: "ellipse";
 };
+export type ExcalidrawEmbeddableElement = _ExcalidrawElementBase & Readonly<{
+    /**
+     * indicates whether the embeddable src (url) has been validated for rendering.
+     * nullish value indicates that the validation is pending. We reset the
+     * value on each restore (or url change) so that we can guarantee
+     * the validation came from a trusted source (the editor). Also because we
+     * may not have access to host-app supplied url validator during restore.
+     */
+    validated?: boolean;
+    type: "embeddable";
+}>;
 export type ExcalidrawImageElement = _ExcalidrawElementBase & Readonly<{
     type: "image";
     fileId: FileId | null;
@@ -81,16 +93,20 @@ export type ExcalidrawImageElement = _ExcalidrawElementBase & Readonly<{
     scale: [number, number];
 }>;
 export type InitializedExcalidrawImageElement = MarkNonNullable<ExcalidrawImageElement, "fileId">;
+export type ExcalidrawFrameElement = _ExcalidrawElementBase & {
+    type: "frame";
+    name: string | null;
+};
 /**
  * These are elements that don't have any additional properties.
  */
-export type ExcalidrawGenericElement = ExcalidrawSelectionElement | ExcalidrawRectangleElement | ExcalidrawDiamondElement | ExcalidrawEllipseElement;
+export type ExcalidrawGenericElement = ExcalidrawSelectionElement | ExcalidrawRectangleElement | ExcalidrawEmbeddableElement | ExcalidrawDiamondElement | ExcalidrawEllipseElement;
 /**
  * ExcalidrawElement should be JSON serializable and (eventually) contain
  * no computed data. The list of all ExcalidrawElements should be shareable
  * between peers and contain no state local to the peer.
  */
-export type ExcalidrawElement = ExcalidrawGenericElement | ExcalidrawTextElement | ExcalidrawLinearElement | ExcalidrawFreeDrawElement | ExcalidrawImageElement;
+export type ExcalidrawElement = ExcalidrawGenericElement | ExcalidrawTextElement | ExcalidrawLinearElement | ExcalidrawFreeDrawElement | ExcalidrawImageElement | ExcalidrawFrameElement;
 export type NonDeleted<TElement extends ExcalidrawElement> = TElement & {
     isDeleted: boolean;
 };
@@ -113,8 +129,8 @@ export type ExcalidrawTextElement = _ExcalidrawElementBase & Readonly<{
         _brand: "unitlessLineHeight";
     };
 }>;
-export type ExcalidrawBindableElement = ExcalidrawRectangleElement | ExcalidrawDiamondElement | ExcalidrawEllipseElement | ExcalidrawTextElement | ExcalidrawImageElement;
-export type ExcalidrawTextContainer = ExcalidrawRectangleElement | ExcalidrawDiamondElement | ExcalidrawEllipseElement | ExcalidrawImageElement | ExcalidrawArrowElement;
+export type ExcalidrawBindableElement = ExcalidrawRectangleElement | ExcalidrawDiamondElement | ExcalidrawEllipseElement | ExcalidrawTextElement | ExcalidrawImageElement | ExcalidrawEmbeddableElement | ExcalidrawFrameElement;
+export type ExcalidrawTextContainer = ExcalidrawRectangleElement | ExcalidrawDiamondElement | ExcalidrawEllipseElement | ExcalidrawArrowElement;
 export type ExcalidrawTextElementWithContainer = {
     containerId: ExcalidrawTextContainer["id"];
 } & ExcalidrawTextElement;

package/types/frame.d.ts

@@ -0,0 +1,40 @@
+import { ExcalidrawElement, ExcalidrawFrameElement, NonDeleted, NonDeletedExcalidrawElement } from "./element/types";
+import { AppClassProperties, AppState } from "./types";
+import { ExcalidrawElementsIncludingDeleted } from "./scene/Scene";
+export declare const bindElementsToFramesAfterDuplication: (nextElements: ExcalidrawElement[], oldElements: readonly ExcalidrawElement[], oldIdToDuplicatedId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>) => void;
+export declare const getElementsCompletelyInFrame: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameElement) => ExcalidrawElement[];
+export declare const isElementContainingFrame: (elements: readonly ExcalidrawElement[], element: ExcalidrawElement, frame: ExcalidrawFrameElement) => boolean;
+export declare const getElementsIntersectingFrame: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameElement) => ExcalidrawElement[];
+export declare const elementsAreInFrameBounds: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameElement) => boolean;
+export declare const elementOverlapsWithFrame: (element: ExcalidrawElement, frame: ExcalidrawFrameElement) => boolean;
+export declare const isCursorInFrame: (cursorCoords: {
+    x: number;
+    y: number;
+}, frame: NonDeleted<ExcalidrawFrameElement>) => boolean;
+export declare const groupsAreAtLeastIntersectingTheFrame: (elements: readonly NonDeletedExcalidrawElement[], groupIds: readonly string[], frame: ExcalidrawFrameElement) => boolean;
+export declare const groupsAreCompletelyOutOfFrame: (elements: readonly NonDeletedExcalidrawElement[], groupIds: readonly string[], frame: ExcalidrawFrameElement) => boolean;
+/**
+ * Returns a map of frameId to frame elements. Includes empty frames.
+ */
+export declare const groupByFrames: (elements: readonly ExcalidrawElement[]) => Map<string, ExcalidrawElement[]>;
+export declare const getFrameElements: (allElements: ExcalidrawElementsIncludingDeleted, frameId: string) => ExcalidrawElement[];
+export declare const getElementsInResizingFrame: (allElements: ExcalidrawElementsIncludingDeleted, frame: ExcalidrawFrameElement, appState: AppState) => ExcalidrawElement[];
+export declare const getElementsInNewFrame: (allElements: ExcalidrawElementsIncludingDeleted, frame: ExcalidrawFrameElement) => ExcalidrawElement[];
+export declare const getContainingFrame: (element: ExcalidrawElement, elementsMap?: Map<string, ExcalidrawElement>) => ExcalidrawFrameElement | null;
+export declare const addElementsToFrame: (allElements: ExcalidrawElementsIncludingDeleted, elementsToAdd: NonDeletedExcalidrawElement[], frame: ExcalidrawFrameElement) => ExcalidrawElement[];
+export declare const removeElementsFromFrame: (allElements: ExcalidrawElementsIncludingDeleted, elementsToRemove: NonDeletedExcalidrawElement[], appState: AppState) => ExcalidrawElement[];
+export declare const removeAllElementsFromFrame: (allElements: ExcalidrawElementsIncludingDeleted, frame: ExcalidrawFrameElement, appState: AppState) => ExcalidrawElement[];
+export declare const replaceAllElementsInFrame: (allElements: ExcalidrawElementsIncludingDeleted, nextElementsInFrame: ExcalidrawElement[], frame: ExcalidrawFrameElement, appState: AppState) => ExcalidrawElement[];
+/** does not mutate elements, but return new ones */
+export declare const updateFrameMembershipOfSelectedElements: (allElements: ExcalidrawElementsIncludingDeleted, appState: AppState, app: AppClassProperties) => ExcalidrawElementsIncludingDeleted;
+/**
+ * filters out elements that are inside groups that contain a frame element
+ * anywhere in the group tree
+ */
+export declare const omitGroupsContainingFrames: (allElements: ExcalidrawElementsIncludingDeleted, selectedElements?: readonly ExcalidrawElement[]) => ExcalidrawElement[];
+/**
+ * depending on the appState, return target frame, which is the frame the given element
+ * is going to be added to or remove from
+ */
+export declare const getTargetFrame: (element: ExcalidrawElement, appState: AppState) => ExcalidrawFrameElement | null;
+export declare const isElementInFrame: (element: ExcalidrawElement, allElements: ExcalidrawElementsIncludingDeleted, appState: AppState) => boolean;

package/types/groups.d.ts

@@ -1,5 +1,5 @@
-import { GroupId, ExcalidrawElement, NonDeleted } from "./element/types";
-import { AppState } from "./types";
+import { GroupId, ExcalidrawElement, NonDeleted, NonDeletedExcalidrawElement } from "./element/types";
+import { AppClassProperties, AppState } from "./types";
 export declare const selectGroup: (groupId: GroupId, appState: AppState, elements: readonly NonDeleted<ExcalidrawElement>[]) => AppState;
 /**
  * If the element's group is selected, don't render an individual
@@ -12,7 +12,10 @@ export declare const getSelectedGroupIds: (appState: AppState) => GroupId[];
  * When you select an element, you often want to actually select the whole group it's in, unless
  * you're currently editing that group.
  */
-export declare const selectGroupsForSelectedElements: (appState: AppState, elements: readonly NonDeleted<ExcalidrawElement>[]) => AppState;
+export declare const selectGroupsForSelectedElements: (appState: AppState, elements: readonly NonDeletedExcalidrawElement[], prevAppState: AppState, app: AppClassProperties | null) => AppState;
+export declare const selectGroupsFromGivenElements: (elements: readonly NonDeleted<ExcalidrawElement>[], appState: AppState) => {
+    [groupId: string]: boolean;
+};
 export declare const editGroupForSelectedElement: (appState: AppState, element: NonDeleted<ExcalidrawElement>) => AppState;
 export declare const isElementInGroup: (element: ExcalidrawElement, groupId: string) => boolean;
 export declare const getElementsInGroup: (elements: readonly ExcalidrawElement[], groupId: string) => ExcalidrawElement[];
@@ -25,3 +28,4 @@ export declare const removeFromSelectedGroups: (groupIds: ExcalidrawElement["gro
     [groupId: string]: boolean;
 }) => string[];
 export declare const getMaximumGroups: (elements: ExcalidrawElement[]) => ExcalidrawElement[][];
+export declare const elementsAreInSameGroup: (elements: ExcalidrawElement[]) => boolean;

package/types/history.d.ts

@@ -5,9 +5,9 @@ export interface HistoryEntry {
     elements: ExcalidrawElement[];
 }
 declare const clearAppStatePropertiesForHistory: (appState: AppState) => {
-    selectedElementIds: {
-        [id: string]: boolean;
-    };
+    selectedElementIds: Readonly<{
+        [id: string]: true;
+    }>;
     selectedGroupIds: {
         [groupId: string]: boolean;
     };

package/types/hooks/useCreatePortalContainer.d.ts

@@ -0,0 +1,4 @@
+export declare const useCreatePortalContainer: (opts?: {
+    className?: string;
+    parentSelector?: string;
+}) => HTMLDivElement | null;

package/types/hooks/useLibraryItemSvg.d.ts

@@ -0,0 +1,11 @@
+import { LibraryItem } from "../types";
+export type SvgCache = Map<LibraryItem["id"], SVGSVGElement>;
+export declare const libraryItemSvgsCache: import("jotai").PrimitiveAtom<SvgCache> & {
+    init: SvgCache;
+};
+export declare const useLibraryItemSvg: (id: LibraryItem["id"] | null, elements: LibraryItem["elements"] | undefined, svgCache: SvgCache) => SVGSVGElement | undefined;
+export declare const useLibraryCache: () => {
+    clearLibraryCache: () => void;
+    deleteItemsFromLibraryCache: (items: LibraryItem["id"][]) => void;
+    svgCache: SvgCache;
+};

package/types/hooks/useOutsideClick.d.ts

@@ -1,2 +1,20 @@
 /// <reference types="react" />
-export declare const useOutsideClick: (handler: (event: Event) => void) => import("react").MutableRefObject<null>;
+export declare function useOutsideClick<T extends HTMLElement>(ref: React.RefObject<T>, 
+/** if performance is of concern, memoize the callback */
+callback: (event: Event) => void, 
+/**
+ * Optional callback which is called on every click.
+ *
+ * Should return `true` if click should be considered as inside the container,
+ * and `false` if it falls outside and should call the `callback`.
+ *
+ * Returning `true` overrides the default behavior and `callback` won't be
+ * called.
+ *
+ * Returning `undefined` will fallback to the default behavior.
+ */
+isInside?: (event: Event & {
+    target: HTMLElement;
+}, 
+/** the element of the passed ref */
+container: T) => boolean | undefined): void;

package/types/hooks/useScrollPosition.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const useScrollPosition: <T extends HTMLElement>(elementRef: import("react").RefObject<T>) => number;

package/types/hooks/useTransition.d.ts

@@ -0,0 +1,2 @@
+import React from "react";
+export declare const useTransition: typeof React.useTransition;

package/types/i18n.d.ts

@@ -1,8 +1,11 @@
+import fallbackLangData from "./locales/en.json";
+import { NestedKeyOf } from "./utility-types";
 export interface Language {
     code: string;
     label: string;
     rtl?: boolean;
 }
+export type TranslationKeys = NestedKeyOf<typeof fallbackLangData>;
 export declare const defaultLang: {
     code: string;
     label: string;
@@ -10,11 +13,11 @@ export declare const defaultLang: {
 export declare const languages: Language[];
 export declare const setLanguage: (lang: Language) => Promise<void>;
 export declare const getLanguage: () => Language;
-export declare const t: (path: string, replacement?: {
+export declare const t: (path: NestedKeyOf<typeof fallbackLangData>, replacement?: {
     [key: string]: string | number;
 } | null | undefined, fallback?: string) => string;
 export declare const useI18n: () => {
-    t: (path: string, replacement?: {
+    t: (path: NestedKeyOf<typeof fallbackLangData>, replacement?: {
         [key: string]: string | number;
     } | null | undefined, fallback?: string) => string;
     langCode: string;

package/types/jotai.d.ts

@@ -1,122 +1,34 @@
 import { PrimitiveAtom } from "jotai";
 export declare const jotaiScope: unique symbol;
 export declare const jotaiStore: {
-    get: <Value>(atom: import("jotai").Atom<Value>) => (Value extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? any : V : V : V : V : V : V : V : V : V : V : Value) | undefined;
-    asyncGet: <Value_1>(atom: import("jotai").Atom<Value_1>) => Promise<Value_1 extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? any : V : V : V : V : V : V : V : V : V : V : Value_1>;
+    get: <Value>(atom: import("jotai").Atom<Value>) => Awaited<Value> | undefined;
+    asyncGet: <Value_1>(atom: import("jotai").Atom<Value_1>) => Promise<Awaited<Value_1>>;
     set: <Value_2, Update, Result extends void | Promise<void>>(atom: import("jotai").WritableAtom<Value_2, Update, Result>, update: Update) => Result;
-    sub: (atom: {
-        toString: () => string;
-        debugLabel?: string | undefined;
-        read: (get: {
-            <Value_3>(atom: import("jotai").Atom<Value_3 | Promise<Value_3>>): Value_3;
-            <Value_4>(atom: import("jotai").Atom<Promise<Value_4>>): Value_4;
-            <Value_5>(atom: import("jotai").Atom<Value_5>): Value_5 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? any : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : Value_5;
-        }) => unknown;
-    }, callback: () => void) => () => void;
+    sub: (atom: import("jotai").Atom<unknown>, callback: () => void) => () => void;
     SECRET_INTERNAL_store: {
-        r: <Value_6>(readingAtom: import("jotai").Atom<Value_6>, version?: import("jotai/core/store").VersionObject | undefined) => import("jotai/core/store").AtomState<Value_6>;
+        r: <Value_3>(readingAtom: import("jotai").Atom<Value_3>, version?: import("jotai/core/store").VersionObject | undefined) => import("jotai/core/store").AtomState<Value_3>;
         w: <Value_1_1, Update_1, Result_1 extends void | Promise<void>>(writingAtom: import("jotai").WritableAtom<Value_1_1, Update_1, Result_1>, update: Update_1, version?: import("jotai/core/store").VersionObject | undefined) => Result_1;
-        c: (_atom: {
-            toString: () => string;
-            debugLabel?: string | undefined;
-            read: (get: {
-                <Value_3>(atom: import("jotai").Atom<Value_3 | Promise<Value_3>>): Value_3;
-                <Value_4>(atom: import("jotai").Atom<Promise<Value_4>>): Value_4;
-                <Value_5>(atom: import("jotai").Atom<Value_5>): Value_5 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? any : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : Value_5;
-            }) => unknown;
-        } | null, version?: import("jotai/core/store").VersionObject | undefined) => void;
-        s: (atom: {
-            toString: () => string;
-            debugLabel?: string | undefined;
-            read: (get: {
-                <Value_3>(atom: import("jotai").Atom<Value_3 | Promise<Value_3>>): Value_3;
-                <Value_4>(atom: import("jotai").Atom<Promise<Value_4>>): Value_4;
-                <Value_5>(atom: import("jotai").Atom<Value_5>): Value_5 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? any : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : Value_5;
-            }) => unknown;
-        }, callback: (version?: import("jotai/core/store").VersionObject | undefined) => void) => () => void;
-        h: (values: Iterable<readonly [{
-            toString: () => string;
-            debugLabel?: string | undefined;
-            read: (get: {
-                <Value_3>(atom: import("jotai").Atom<Value_3 | Promise<Value_3>>): Value_3;
-                <Value_4>(atom: import("jotai").Atom<Promise<Value_4>>): Value_4;
-                <Value_5>(atom: import("jotai").Atom<Value_5>): Value_5 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? any : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : Value_5;
-            }) => unknown;
-        }, unknown]>, version?: import("jotai/core/store").VersionObject | undefined) => void;
+        c: (_atom: import("jotai").Atom<unknown> | null, version?: import("jotai/core/store").VersionObject | undefined) => void;
+        s: (atom: import("jotai").Atom<unknown>, callback: (version?: import("jotai/core/store").VersionObject | undefined) => void, version?: import("jotai/core/store").VersionObject | undefined) => () => void;
+        h: (values: Iterable<readonly [import("jotai").Atom<unknown>, unknown]>, version?: import("jotai/core/store").VersionObject | undefined) => void;
         n: (l: () => void) => () => void;
-        l: () => IterableIterator<{
-            toString: () => string;
-            debugLabel?: string | undefined;
-            read: (get: {
-                <Value_3>(atom: import("jotai").Atom<Value_3 | Promise<Value_3>>): Value_3;
-                <Value_4>(atom: import("jotai").Atom<Promise<Value_4>>): Value_4;
-                <Value_5>(atom: import("jotai").Atom<Value_5>): Value_5 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? any : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : Value_5;
-            }) => unknown;
-        }>;
-        a: (a: {
-            toString: () => string;
-            debugLabel?: string | undefined;
-            read: (get: {
-                <Value_3>(atom: import("jotai").Atom<Value_3 | Promise<Value_3>>): Value_3;
-                <Value_4>(atom: import("jotai").Atom<Promise<Value_4>>): Value_4;
-                <Value_5>(atom: import("jotai").Atom<Value_5>): Value_5 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? any : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : Value_5;
-            }) => unknown;
-        }) => import("jotai/core/store").AtomState<unknown> | undefined;
-        m: (a: {
-            toString: () => string;
-            debugLabel?: string | undefined;
-            read: (get: {
-                <Value_3>(atom: import("jotai").Atom<Value_3 | Promise<Value_3>>): Value_3;
-                <Value_4>(atom: import("jotai").Atom<Promise<Value_4>>): Value_4;
-                <Value_5>(atom: import("jotai").Atom<Value_5>): Value_5 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? any : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : Value_5;
-            }) => unknown;
-        }) => {
+        l: () => IterableIterator<import("jotai").Atom<unknown>>;
+        a: (a: import("jotai").Atom<unknown>) => import("jotai/core/store").AtomState<unknown> | undefined;
+        m: (a: import("jotai").Atom<unknown>) => {
             l: Set<(version?: import("jotai/core/store").VersionObject | undefined) => void>;
-            t: Set<{
-                toString: () => string;
-                debugLabel?: string | undefined;
-                read: (get: {
-                    <Value_3>(atom: import("jotai").Atom<Value_3 | Promise<Value_3>>): Value_3;
-                    <Value_4>(atom: import("jotai").Atom<Promise<Value_4>>): Value_4;
-                    <Value_5>(atom: import("jotai").Atom<Value_5>): Value_5 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? any : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : Value_5;
-                }) => unknown;
-            }>;
+            t: Set<import("jotai").Atom<unknown>>;
             u?: (() => void) | undefined;
         } | undefined;
     } | {
-        r: <Value_7>(readingAtom: import("jotai").Atom<Value_7>, version?: import("jotai/core/store").VersionObject | undefined) => import("jotai/core/store").AtomState<Value_7>;
+        r: <Value_4>(readingAtom: import("jotai").Atom<Value_4>, version?: import("jotai/core/store").VersionObject | undefined) => import("jotai/core/store").AtomState<Value_4>;
         w: <Value_1_2, Update_2, Result_2 extends void | Promise<void>>(writingAtom: import("jotai").WritableAtom<Value_1_2, Update_2, Result_2>, update: Update_2, version?: import("jotai/core/store").VersionObject | undefined) => Result_2;
-        c: (_atom: {
-            toString: () => string;
-            debugLabel?: string | undefined;
-            read: (get: {
-                <Value_3>(atom: import("jotai").Atom<Value_3 | Promise<Value_3>>): Value_3;
-                <Value_4>(atom: import("jotai").Atom<Promise<Value_4>>): Value_4;
-                <Value_5>(atom: import("jotai").Atom<Value_5>): Value_5 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? any : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : Value_5;
-            }) => unknown;
-        } | null, version?: import("jotai/core/store").VersionObject | undefined) => void;
-        s: (atom: {
-            toString: () => string;
-            debugLabel?: string | undefined;
-            read: (get: {
-                <Value_3>(atom: import("jotai").Atom<Value_3 | Promise<Value_3>>): Value_3;
-                <Value_4>(atom: import("jotai").Atom<Promise<Value_4>>): Value_4;
-                <Value_5>(atom: import("jotai").Atom<Value_5>): Value_5 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? any : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : Value_5;
-            }) => unknown;
-        }, callback: (version?: import("jotai/core/store").VersionObject | undefined) => void) => () => void;
-        h: (values: Iterable<readonly [{
-            toString: () => string;
-            debugLabel?: string | undefined;
-            read: (get: {
-                <Value_3>(atom: import("jotai").Atom<Value_3 | Promise<Value_3>>): Value_3;
-                <Value_4>(atom: import("jotai").Atom<Promise<Value_4>>): Value_4;
-                <Value_5>(atom: import("jotai").Atom<Value_5>): Value_5 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? V_1 extends Promise<infer V_1> ? any : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : Value_5;
-            }) => unknown;
-        }, unknown]>, version?: import("jotai/core/store").VersionObject | undefined) => void;
+        c: (_atom: import("jotai").Atom<unknown> | null, version?: import("jotai/core/store").VersionObject | undefined) => void;
+        s: (atom: import("jotai").Atom<unknown>, callback: (version?: import("jotai/core/store").VersionObject | undefined) => void, version?: import("jotai/core/store").VersionObject | undefined) => () => void;
+        h: (values: Iterable<readonly [import("jotai").Atom<unknown>, unknown]>, version?: import("jotai/core/store").VersionObject | undefined) => void;
         n?: undefined;
         l?: undefined;
         a?: undefined;
         m?: undefined;
     };
 };
-export declare const useAtomWithInitialValue: <T extends unknown, A extends PrimitiveAtom<T>>(atom: A, initialValue: T | (() => T)) => readonly [T extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? any : V : V : V : V : V : V : V : V : V : V : T, import("jotai/core/atom").SetAtom<T | ((prev: T) => T), void>];
+export declare const useAtomWithInitialValue: <T extends unknown, A extends PrimitiveAtom<T>>(atom: A, initialValue: T | (() => T)) => readonly [Awaited<T>, import("jotai/core/atom").SetAtom<T | ((prev: T) => T), void>];

package/types/keys.d.ts

@@ -8,6 +8,7 @@ export declare const CODES: {
     readonly BRACKET_LEFT: "BracketLeft";
     readonly ONE: "Digit1";
     readonly TWO: "Digit2";
+    readonly THREE: "Digit3";
     readonly NINE: "Digit9";
     readonly QUOTE: "Quote";
     readonly ZERO: "Digit0";
@@ -39,6 +40,7 @@ export declare const KEYS: {
     readonly CHEVRON_RIGHT: ">";
     readonly PERIOD: ".";
     readonly COMMA: ",";
+    readonly SUBTRACT: "-";
     readonly A: "a";
     readonly C: "c";
     readonly D: "d";
@@ -59,6 +61,7 @@ export declare const KEYS: {
     readonly Y: "y";
     readonly Z: "z";
     readonly K: "k";
+    readonly W: "w";
     readonly 0: "0";
     readonly 1: "1";
     readonly 2: "2";

package/types/math.d.ts

@@ -17,6 +17,7 @@ export declare const distance2d: (x1: number, y1: number, x2: number, y2: number
 export declare const centerPoint: (a: readonly [number, number], b: readonly [number, number]) => readonly [number, number];
 export declare const isPathALoop: (points: ExcalidrawLinearElement["points"], zoomValue?: Zoom["value"]) => boolean;
 export declare const isPointInPolygon: (points: Point[], x: number, y: number) => boolean;
+export declare const isPointWithinBounds: (p: readonly [number, number], q: readonly [number, number], r: readonly [number, number]) => boolean;
 export declare const getGridPoint: (x: number, y: number, gridSize: number | null) => [number, number];
 export declare const getCornerRadius: (x: number, element: ExcalidrawElement) => number;
 export declare const getControlPointsForBezierCurve: (element: NonDeleted<ExcalidrawLinearElement>, endPoint: readonly [number, number]) => [number, number][] | null;

package/types/packages/excalidraw/dist/excalidraw-assets-dev/locales/zh-TW-json-e4eb1416e4564d3a1fd9.d.ts

@@ -0,0 +1,2 @@
+declare const _exports: any;
+export = _exports;

package/types/packages/excalidraw/example/initialData.d.ts

@@ -19,6 +19,7 @@ declare namespace _default {
         height: number;
         seed: number;
         groupIds: never[];
+        frameId: null;
         fileId?: undefined;
         strokeSharpness?: undefined;
         boundElements?: undefined;
@@ -42,6 +43,7 @@ declare namespace _default {
         roughness: number;
         opacity: number;
         groupIds: never[];
+        frameId: null;
         strokeSharpness: string;
         seed: number;
         version: number;
@@ -79,6 +81,7 @@ declare namespace _default {
         height: number;
         seed: number;
         groupIds: string[];
+        frameId: null;
         strokeSharpness: string;
         boundElementIds: never[];
         startBinding: null;
@@ -107,6 +110,7 @@ declare namespace _default {
         height: number;
         seed: number;
         groupIds: string[];
+        frameId: null;
         strokeSharpness: string;
         boundElementIds: string[];
         startBinding?: undefined;
@@ -135,6 +139,7 @@ declare namespace _default {
         height: number;
         seed: number;
         groupIds: string[];
+        frameId: null;
         strokeSharpness: string;
         boundElementIds: string[];
         points?: undefined;
@@ -161,6 +166,7 @@ declare namespace _default {
         height: number;
         seed: number;
         groupIds: string[];
+        frameId: null;
         strokeSharpness: string;
         boundElementIds: never[];
         points: number[][];

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

@@ -25,3 +25,4 @@ export { useDevice } from "../../components/App";
 export { WelcomeScreen };
 export { LiveCollaborationTrigger };
 export { DefaultSidebar } from "../../components/DefaultSidebar";
+export { normalizeLink } from "../../data/url";