@unicom-cloud/ui 0.8.168 → 0.8.170

package/draw/core/data/blob.d.ts

@@ -0,0 +1,357 @@
+import { IMAGE_MIME_TYPES, MIME_TYPES } from '../../common';
+import type { ValueOf } from '../../common/utility-types';
+import type { DrawElement, FileId } from '../../element/types';
+import type { AppState, DataURL, LibraryItem } from '../../interface';
+import type { FileSystemHandle } from '../../libs/browser-fs-access';
+import type { ImportedLibraryData } from './types';
+export declare const getMimeType: (blob: Blob | string) => string;
+export declare const getFileHandleType: (handle: FileSystemHandle | null) => string | null;
+export declare const isImageFileHandleType: (type: string | null) => type is "png" | "svg";
+export declare const isImageFileHandle: (handle: FileSystemHandle | null) => boolean;
+export declare const isSupportedImageFileType: (type: string | null | undefined) => boolean;
+export declare const isSupportedImageFile: (blob: Blob | null | undefined) => blob is Blob & {
+    type: ValueOf<typeof IMAGE_MIME_TYPES>;
+};
+export declare const loadSceneOrLibraryFromBlob: (blob: Blob | File, 
+/** @see restore.localAppState */
+localAppState: AppState | null, localElements: readonly DrawElement[] | null, 
+/** FileSystemHandle. Defaults to `blob.handle` if defined, otherwise null. */
+fileHandle?: FileSystemHandle | null) => Promise<{
+    type: "application/vnd.draw+json";
+    data: {
+        elements: import("../../element/types").OrderedDrawElement[];
+        appState: {
+            name: string | null;
+            contextMenu: {
+                items: import("../components/ContextMenu").ContextMenuItems;
+                top: number;
+                left: number;
+            } | null;
+            zoom: import("../../interface").Zoom;
+            theme: import("../../element/types").Theme;
+            viewModeEnabled: boolean;
+            zenModeEnabled: boolean;
+            gridModeEnabled: boolean;
+            objectsSnapModeEnabled: boolean;
+            currentItemArrowType: "sharp" | "round" | "elbow";
+            gridSize: number;
+            activeTool: {
+                lastActiveTool: import("../../interface").ActiveTool | null;
+                locked: boolean;
+                fromSelection: boolean;
+            } & import("../../interface").ActiveTool;
+            showWelcomeScreen: boolean;
+            isLoading: boolean;
+            errorMessage: React.ReactNode;
+            activeEmbeddable: {
+                element: import("../../element/types").NonDeletedDrawElement;
+                state: "hover" | "active";
+            } | null;
+            newElement: import("../../element/types").NonDeleted<import("../../element/types").DrawNonSelectionElement> | null;
+            resizingElement: import("../../element/types").NonDeletedDrawElement | null;
+            multiElement: import("../../element/types").NonDeleted<import("../../element/types").DrawLinearElement> | null;
+            selectionElement: import("../../element/types").NonDeletedDrawElement | null;
+            isBindingEnabled: boolean;
+            startBoundElement: import("../../element/types").NonDeleted<import("../../element/types").DrawBindableElement> | null;
+            suggestedBinding: import("../../element/types").NonDeleted<import("../../element/types").DrawBindableElement> | null;
+            frameToHighlight: import("../../element/types").NonDeleted<import("../../element/types").DrawFrameLikeElement> | null;
+            frameRendering: {
+                enabled: boolean;
+                name: boolean;
+                outline: boolean;
+                clip: boolean;
+            };
+            editingFrame: string | null;
+            elementsToHighlight: import("../../element/types").NonDeleted<DrawElement>[] | null;
+            editingTextElement: import("../../element/types").NonDeletedDrawElement | null;
+            preferredSelectionTool: {
+                type: "selection" | "lasso";
+                initialized: boolean;
+            };
+            penMode: boolean;
+            penDetected: boolean;
+            exportBackground: boolean;
+            exportEmbedScene: boolean;
+            exportWithDarkMode: boolean;
+            exportScale: number;
+            currentItemStrokeColor: string;
+            currentItemBackgroundColor: string;
+            currentItemFillStyle: DrawElement["fillStyle"];
+            currentItemStrokeWidth: number;
+            currentItemStrokeStyle: DrawElement["strokeStyle"];
+            currentItemRoughness: number;
+            currentItemOpacity: number;
+            currentItemFontFamily: import("../../element/types").FontFamilyValues;
+            currentItemFontSize: number;
+            currentItemTextAlign: import("../../element/types").TextAlign;
+            currentItemStartArrowhead: import("../../element/types").Arrowhead | null;
+            currentItemEndArrowhead: import("../../element/types").Arrowhead | null;
+            currentHoveredFontFamily: import("../../element/types").FontFamilyValues | null;
+            currentItemRoundness: import("../../element/types").StrokeRoundness;
+            viewBackgroundColor: string;
+            scrollX: number;
+            scrollY: number;
+            cursorButton: "up" | "down";
+            scrolledOutside: boolean;
+            isResizing: boolean;
+            isRotating: boolean;
+            openMenu: "canvas" | null;
+            openPopup: "canvasBackground" | "elementBackground" | "elementStroke" | "fontFamily" | "compactTextProperties" | "compactStrokeStyles" | "compactOtherProperties" | "compactArrowProperties" | null;
+            openSidebar: {
+                name: import("../../interface").SidebarName;
+                tab?: import("../../interface").SidebarTabName;
+            } | null;
+            openDialog: null | {
+                name: "imageExport" | "help" | "jsonExport";
+            } | {
+                name: "commandPalette";
+            } | {
+                name: "settings";
+            } | {
+                name: "elementLinkSelector";
+                sourceElementId: DrawElement["id"];
+            };
+            defaultSidebarDockedPreference: boolean;
+            lastPointerDownWith: import("../../element/types").PointerType;
+            selectedElementIds: Readonly<{
+                [id: string]: true;
+            }>;
+            hoveredElementIds: Readonly<{
+                [id: string]: true;
+            }>;
+            previousSelectedElementIds: {
+                [id: string]: true;
+            };
+            selectedElementsAreBeingDragged: boolean;
+            shouldCacheIgnoreZoom: boolean;
+            toast: {
+                message: string;
+                closable?: boolean;
+                duration?: number;
+            } | null;
+            gridStep: number;
+            selectedGroupIds: {
+                [groupId: string]: boolean;
+            };
+            editingGroupId: import("../../element/types").GroupId | null;
+            fileHandle: FileSystemHandle | null;
+            collaborators: Map<import("../../interface").SocketId, import("../../interface").Collaborator>;
+            stats: {
+                open: boolean;
+                panels: number;
+            };
+            currentChartType: import("../../element/types").ChartType;
+            pasteDialog: {
+                shown: false;
+                data: null;
+            } | {
+                shown: true;
+                data: import("../charts").Spreadsheet;
+            };
+            selectedLinearElement: import("../../element").LinearElementEditor | null;
+            snapLines: readonly import("../snapping").SnapLine[];
+            originSnapOffset: {
+                x: number;
+                y: number;
+            } | null;
+            followedBy: Set<import("../../interface").SocketId>;
+            isCropping: boolean;
+            croppingElementId: DrawElement["id"] | null;
+            searchMatches: Readonly<{
+                focusedId: DrawElement["id"] | null;
+                matches: readonly import("../../interface").SearchMatch[];
+            }> | null;
+            activeLockedId: string | null;
+            lockedMultiSelections: {
+                [groupId: string]: true;
+            };
+            bindMode: import("../../element/types").BindMode;
+        };
+        files: import("../../interface").BinaryFiles;
+    };
+} | {
+    type: "application/vnd.drawlib+json";
+    data: ImportedLibraryData;
+}>;
+export declare const loadFromBlob: (blob: Blob, 
+/** @see restore.localAppState */
+localAppState: AppState | null, localElements: readonly DrawElement[] | null, 
+/** FileSystemHandle. Defaults to `blob.handle` if defined, otherwise null. */
+fileHandle?: FileSystemHandle | null) => Promise<{
+    elements: import("../../element/types").OrderedDrawElement[];
+    appState: {
+        name: string | null;
+        contextMenu: {
+            items: import("../components/ContextMenu").ContextMenuItems;
+            top: number;
+            left: number;
+        } | null;
+        zoom: import("../../interface").Zoom;
+        theme: import("../../element/types").Theme;
+        viewModeEnabled: boolean;
+        zenModeEnabled: boolean;
+        gridModeEnabled: boolean;
+        objectsSnapModeEnabled: boolean;
+        currentItemArrowType: "sharp" | "round" | "elbow";
+        gridSize: number;
+        activeTool: {
+            lastActiveTool: import("../../interface").ActiveTool | null;
+            locked: boolean;
+            fromSelection: boolean;
+        } & import("../../interface").ActiveTool;
+        showWelcomeScreen: boolean;
+        isLoading: boolean;
+        errorMessage: React.ReactNode;
+        activeEmbeddable: {
+            element: import("../../element/types").NonDeletedDrawElement;
+            state: "hover" | "active";
+        } | null;
+        newElement: import("../../element/types").NonDeleted<import("../../element/types").DrawNonSelectionElement> | null;
+        resizingElement: import("../../element/types").NonDeletedDrawElement | null;
+        multiElement: import("../../element/types").NonDeleted<import("../../element/types").DrawLinearElement> | null;
+        selectionElement: import("../../element/types").NonDeletedDrawElement | null;
+        isBindingEnabled: boolean;
+        startBoundElement: import("../../element/types").NonDeleted<import("../../element/types").DrawBindableElement> | null;
+        suggestedBinding: import("../../element/types").NonDeleted<import("../../element/types").DrawBindableElement> | null;
+        frameToHighlight: import("../../element/types").NonDeleted<import("../../element/types").DrawFrameLikeElement> | null;
+        frameRendering: {
+            enabled: boolean;
+            name: boolean;
+            outline: boolean;
+            clip: boolean;
+        };
+        editingFrame: string | null;
+        elementsToHighlight: import("../../element/types").NonDeleted<DrawElement>[] | null;
+        editingTextElement: import("../../element/types").NonDeletedDrawElement | null;
+        preferredSelectionTool: {
+            type: "selection" | "lasso";
+            initialized: boolean;
+        };
+        penMode: boolean;
+        penDetected: boolean;
+        exportBackground: boolean;
+        exportEmbedScene: boolean;
+        exportWithDarkMode: boolean;
+        exportScale: number;
+        currentItemStrokeColor: string;
+        currentItemBackgroundColor: string;
+        currentItemFillStyle: DrawElement["fillStyle"];
+        currentItemStrokeWidth: number;
+        currentItemStrokeStyle: DrawElement["strokeStyle"];
+        currentItemRoughness: number;
+        currentItemOpacity: number;
+        currentItemFontFamily: import("../../element/types").FontFamilyValues;
+        currentItemFontSize: number;
+        currentItemTextAlign: import("../../element/types").TextAlign;
+        currentItemStartArrowhead: import("../../element/types").Arrowhead | null;
+        currentItemEndArrowhead: import("../../element/types").Arrowhead | null;
+        currentHoveredFontFamily: import("../../element/types").FontFamilyValues | null;
+        currentItemRoundness: import("../../element/types").StrokeRoundness;
+        viewBackgroundColor: string;
+        scrollX: number;
+        scrollY: number;
+        cursorButton: "up" | "down";
+        scrolledOutside: boolean;
+        isResizing: boolean;
+        isRotating: boolean;
+        openMenu: "canvas" | null;
+        openPopup: "canvasBackground" | "elementBackground" | "elementStroke" | "fontFamily" | "compactTextProperties" | "compactStrokeStyles" | "compactOtherProperties" | "compactArrowProperties" | null;
+        openSidebar: {
+            name: import("../../interface").SidebarName;
+            tab?: import("../../interface").SidebarTabName;
+        } | null;
+        openDialog: null | {
+            name: "imageExport" | "help" | "jsonExport";
+        } | {
+            name: "commandPalette";
+        } | {
+            name: "settings";
+        } | {
+            name: "elementLinkSelector";
+            sourceElementId: DrawElement["id"];
+        };
+        defaultSidebarDockedPreference: boolean;
+        lastPointerDownWith: import("../../element/types").PointerType;
+        selectedElementIds: Readonly<{
+            [id: string]: true;
+        }>;
+        hoveredElementIds: Readonly<{
+            [id: string]: true;
+        }>;
+        previousSelectedElementIds: {
+            [id: string]: true;
+        };
+        selectedElementsAreBeingDragged: boolean;
+        shouldCacheIgnoreZoom: boolean;
+        toast: {
+            message: string;
+            closable?: boolean;
+            duration?: number;
+        } | null;
+        gridStep: number;
+        selectedGroupIds: {
+            [groupId: string]: boolean;
+        };
+        editingGroupId: import("../../element/types").GroupId | null;
+        fileHandle: FileSystemHandle | null;
+        collaborators: Map<import("../../interface").SocketId, import("../../interface").Collaborator>;
+        stats: {
+            open: boolean;
+            panels: number;
+        };
+        currentChartType: import("../../element/types").ChartType;
+        pasteDialog: {
+            shown: false;
+            data: null;
+        } | {
+            shown: true;
+            data: import("../charts").Spreadsheet;
+        };
+        selectedLinearElement: import("../../element").LinearElementEditor | null;
+        snapLines: readonly import("../snapping").SnapLine[];
+        originSnapOffset: {
+            x: number;
+            y: number;
+        } | null;
+        followedBy: Set<import("../../interface").SocketId>;
+        isCropping: boolean;
+        croppingElementId: DrawElement["id"] | null;
+        searchMatches: Readonly<{
+            focusedId: DrawElement["id"] | null;
+            matches: readonly import("../../interface").SearchMatch[];
+        }> | null;
+        activeLockedId: string | null;
+        lockedMultiSelections: {
+            [groupId: string]: true;
+        };
+        bindMode: import("../../element/types").BindMode;
+    };
+    files: import("../../interface").BinaryFiles;
+}>;
+export declare const parseLibraryJSON: (json: string, defaultStatus?: LibraryItem["status"]) => LibraryItem[];
+export declare const loadLibraryFromBlob: (blob: Blob, defaultStatus?: LibraryItem["status"]) => Promise<LibraryItem[]>;
+export declare const canvasToBlob: (canvas: HTMLCanvasElement | Promise<HTMLCanvasElement>) => Promise<Blob>;
+/** generates SHA-1 digest from supplied file (if not supported, falls back
+    to a 40-char base64 random id) */
+export declare const generateIdFromFile: (file: File) => Promise<FileId>;
+/** async. For sync variant, use getDataURL_sync */
+export declare const getDataURL: (file: Blob | File) => Promise<DataURL>;
+export declare const getDataURL_sync: (data: string | Uint8Array | ArrayBuffer, mimeType: ValueOf<typeof MIME_TYPES>) => DataURL;
+export declare const dataURLToFile: (dataURL: DataURL, filename?: string) => File;
+export declare const dataURLToString: (dataURL: DataURL) => string;
+export declare const resizeImageFile: (file: File, opts: {
+    /** undefined indicates auto */
+    outputType?: (typeof MIME_TYPES)["jpg"];
+    maxWidthOrHeight: number;
+}) => Promise<File>;
+export declare const SVGStringToFile: (SVGString: string, filename?: string) => File & {
+    type: typeof MIME_TYPES.svg;
+};
+export declare const ImageURLToFile: (imageUrl: string, filename?: string) => Promise<File | undefined>;
+export declare const getFileHandle: (event: DragEvent | React.DragEvent | DataTransferItem) => Promise<FileSystemHandle | null>;
+export declare const createFile: (blob: File | Blob | ArrayBuffer, mimeType: string, name: string | undefined) => File;
+/** attempts to detect correct mimeType if none is set, or if an image
+ * has an incorrect extension.
+ * Note: doesn't handle missing .draw/.drawlib extension  */
+export declare const normalizeFile: (file: File) => Promise<File>;
+export declare const blobToArrayBuffer: (blob: Blob) => Promise<ArrayBuffer>;

package/draw/core/data/blob.js

@@ -0,0 +1,171 @@
+/* 潘启宝 2026-06-25 17:54:57 星期四 山东省济南市 */
+import { IMAGE_MIME_TYPES as e, MIME_TYPES as t } from "../../common/constants.js";
+import { bytesToHexString as n, isPromiseLike as r } from "../../common/utils.js";
+import { nanoid as i } from "../../libs/nanoid/index.js";
+import "../../common/index.js";
+import { cleanAppStateForExport as a } from "../appState.js";
+import { calculateScrollCenter as o } from "../scene/scroll.js";
+import "../scene/index.js";
+import s from "../../libs/pica/index.js";
+import c from "../../libs/image-blob-reduce/index.js";
+import { CanvasError as l, ImageSceneDataError as u } from "../errors.js";
+import { base64ToString as d, stringToBase64 as f, toByteString as p } from "./encode.js";
+import m from "../../libs/browser-fs-access/supported.js";
+import "./filesystem.js";
+import { isValidDrawData as h, isValidLibrary as g } from "./json.js";
+import { decodeSvgBase64Payload as _ } from "../scene/export.js";
+import { decodePngMetadata as v } from "./image.js";
+import { restoreAppState as y, restoreElements as b, restoreLibraryItems as x } from "./restore.js";
+//#region components/pc/draw/core/data/blob.ts
+var S = async (e) => {
+	let n;
+	if (e.type === t.png) try {
+		return await v(e);
+	} catch (e) {
+		throw e.message === "INVALID" ? new u("Image doesn't contain scene", "IMAGE_NOT_CONTAINS_SCENE_DATA") : new u("Error: cannot restore image");
+	}
+	else if (n = "text" in Blob ? await e.text() : await new Promise((t) => {
+		let n = new FileReader();
+		n.readAsText(e, "utf8"), n.onloadend = () => {
+			n.readyState === FileReader.DONE && t(n.result);
+		};
+	}), e.type === t.svg) try {
+		return _({ svg: n });
+	} catch (e) {
+		throw e.message === "INVALID" ? new u("Image doesn't contain scene", "IMAGE_NOT_CONTAINS_SCENE_DATA") : new u("Error: cannot restore image");
+	}
+	return n;
+}, C = (e) => e && e.name.match(/\.(json|draw|png|svg)$/)?.[1] || null, w = (e) => e === "png" || e === "svg", T = (e) => {
+	let t = C(e);
+	return t === "png" || t === "svg";
+}, E = (t) => !!t && Object.values(e).includes(t), D = (e) => {
+	let { type: t } = e || {};
+	return E(t);
+}, O = "错误：文件无效", k = async (e, n, r, i) => {
+	let s = await S(e), c;
+	try {
+		try {
+			c = JSON.parse(s);
+		} catch (t) {
+			throw D(e) ? new u("Image doesn't contain scene", "IMAGE_NOT_CONTAINS_SCENE_DATA") : t;
+		}
+		if (h(c)) return {
+			type: t.draw,
+			data: {
+				elements: b(c.elements, r, {
+					repairBindings: !0,
+					deleteInvisibleElements: !0
+				}),
+				appState: y({
+					theme: n?.theme,
+					fileHandle: i || e.handle || null,
+					...a(c.appState || {}),
+					...n ? o(c.elements || [], n) : {}
+				}, n),
+				files: c.files || {}
+			}
+		};
+		if (g(c)) return {
+			type: t.drawlib,
+			data: c
+		};
+		throw Error(O);
+	} catch (e) {
+		throw e instanceof u ? e : Error(O, { cause: e });
+	}
+}, A = async (e, n, r, i) => {
+	let a = await k(e, n, r, i);
+	if (a.type !== t.draw) throw Error(O);
+	return a.data;
+}, j = (e, t = "unpublished") => {
+	let n = JSON.parse(e);
+	if (!g(n)) throw Error("Invalid library");
+	return x(n.libraryItems || n.library, t);
+}, M = async (e, t = "unpublished") => j(await S(e), t), N = async (e) => new Promise(async (t, n) => {
+	try {
+		r(e) && (e = await e), e.toBlob((e) => {
+			if (!e) return n(new l("Error: Canvas too big", "CANVAS_POSSIBLY_TOO_BIG"));
+			t(e);
+		});
+	} catch (e) {
+		n(e);
+	}
+}), P = async (e) => {
+	try {
+		let t = await window.crypto.subtle.digest("SHA-1", await K(e));
+		return n(new Uint8Array(t));
+	} catch (e) {
+		return console.error(e), i(40);
+	}
+}, F = async (e) => new Promise((t, n) => {
+	let r = new FileReader();
+	r.onload = () => {
+		let e = r.result;
+		t(e);
+	}, r.onerror = (e) => n(e), r.readAsDataURL(e);
+}), I = (e, t) => `data:${t};base64,${f(p(e), !0)}`, L = (e) => d(e.slice(e.indexOf(",") + 1)), R = async (e, n) => {
+	if (e.type === t.svg) return e;
+	let r = c({ pica: s({ features: ["js", "wasm"] }) });
+	if (n.outputType) {
+		let { outputType: e } = n;
+		r._create_blob = function(t) {
+			return this.pica.toBlob(t.out_canvas, e, .8).then((e) => (t.out_blob = e, t));
+		};
+	}
+	if (!D(e)) throw Error("Error: unsupported file type", { cause: "UNSUPPORTED" });
+	return new File([await r.toBlob(e, {
+		max: n.maxWidthOrHeight,
+		alpha: !0
+	})], e.name, { type: n.outputType || e.type });
+}, z = (e, n = "") => new File([new TextEncoder().encode(e)], n, { type: t.svg }), B = async (e, t = "") => {
+	let n;
+	try {
+		n = await fetch(e);
+	} catch {
+		throw Error("Error: failed to fetch image", { cause: "FETCH_ERROR" });
+	}
+	if (!n.ok) throw Error("Error: failed to fetch image", { cause: "FETCH_ERROR" });
+	let r = await n.blob();
+	if (r.type && D(r)) {
+		let e = t || r.name || "";
+		return new File([r], e, { type: r.type });
+	}
+	throw Error("Error: unsupported file type", { cause: "UNSUPPORTED" });
+}, V = async (e) => {
+	if (m) try {
+		return await (e instanceof DataTransferItem ? e : e.dataTransfer?.items?.[0]).getAsFileSystemHandle() || null;
+	} catch (e) {
+		return console.warn(e.name, e.message), null;
+	}
+	return null;
+}, H = async (e) => {
+	let n = null, r = [...new Uint8Array(await K(e.slice(0, 15)))].join(" "), i = {
+		png: /^137 80 78 71 13 10 26 10\b/,
+		jpg: /^255 216 255\b/,
+		gif: /^71 73 70 56 57 97\b/,
+		webp: /^82 73 70 70 \d+ \d+ \d+ \d+ 87 69 66 80 86 80 56\b/
+	};
+	for (let e of Object.keys(i)) if (r.match(i[e])) {
+		n = t[e];
+		break;
+	}
+	return n || e.type || null;
+}, U = (e, t, n) => new File([e], n || "", { type: t }), W = Symbol("fileNormalized"), G = async (e) => {
+	if (e[W]) return e;
+	if (e?.name?.endsWith?.(".drawlib")) e = U(e, t.drawlib, e.name);
+	else if (e?.name?.endsWith?.(".draw")) e = U(e, t.draw, e.name);
+	else if (!e.type || e.type?.startsWith?.("image/")) {
+		let t = await H(e);
+		t && t !== e.type && (e = U(e, t, e.name));
+	}
+	return e[W] = !0, e;
+}, K = (e) => "arrayBuffer" in e ? e.arrayBuffer() : new Promise((t, n) => {
+	let r = new FileReader();
+	r.onload = (e) => {
+		if (!e.target?.result) return n(/* @__PURE__ */ Error("Couldn't convert blob to ArrayBuffer"));
+		t(e.target.result);
+	}, r.readAsArrayBuffer(e);
+});
+//#endregion
+export { B as ImageURLToFile, z as SVGStringToFile, K as blobToArrayBuffer, N as canvasToBlob, U as createFile, L as dataURLToString, P as generateIdFromFile, F as getDataURL, I as getDataURL_sync, V as getFileHandle, C as getFileHandleType, T as isImageFileHandle, w as isImageFileHandleType, D as isSupportedImageFile, E as isSupportedImageFileType, A as loadFromBlob, M as loadLibraryFromBlob, k as loadSceneOrLibraryFromBlob, G as normalizeFile, j as parseLibraryJSON, R as resizeImageFile };
+/* 独立思考，明辨是非 */

package/draw/core/data/encode.d.ts

@@ -0,0 +1,55 @@
+export declare const toByteString: (data: string | Uint8Array | ArrayBuffer) => string;
+/**
+ * @param isByteString set to true if already byte string to prevent bloat
+ *  due to reencoding
+ */
+export declare const stringToBase64: (str: string, isByteString?: boolean) => string;
+export declare const base64ToString: (base64: string, isByteString?: boolean) => string;
+export declare const base64ToArrayBuffer: (base64: string) => ArrayBuffer;
+export declare const base64urlToString: (str: string) => string;
+type EncodedData = {
+    encoded: string;
+    encoding: 'bstring';
+    /** whether text is compressed (zlib) */
+    compressed: boolean;
+    /** version for potential migration purposes */
+    version?: string;
+};
+/**
+ * Encodes (and potentially compresses via zlib) text to byte string
+ */
+export declare const encode: ({ text, compress, }: {
+    text: string;
+    /** defaults to `true`. If compression fails, falls back to bstring alone. */
+    compress?: boolean;
+}) => EncodedData;
+export declare const decode: (data: EncodedData) => string;
+/**
+ * The returned buffer has following format:
+ * `[]` refers to a buffers wrapper (see `concatBuffers`)
+ *
+ * [
+ *   encodingMetadataBuffer,
+ *   iv,
+ *   [
+ *      contentsMetadataBuffer
+ *      contentsBuffer
+ *   ]
+ * ]
+ */
+export declare const compressData: <T extends Record<string, any> = never>(dataBuffer: Uint8Array, options: {
+    encryptionKey: string;
+} & ([T] extends [never] ? {
+    metadata?: T;
+} : {
+    metadata: T;
+})) => Promise<Uint8Array<ArrayBuffer>>;
+export declare const decompressData: <T extends Record<string, any>>(bufferView: Uint8Array, options: {
+    decryptionKey: string;
+}) => Promise<{
+    /** metadata source is always JSON so we can decode it here */
+    metadata: T;
+    /** data can be anything so the caller must decode it */
+    data: Uint8Array<ArrayBuffer>;
+}>;
+export {};

package/draw/core/data/encode.js

@@ -0,0 +1,38 @@
+/* 潘启宝 2026-06-25 17:54:57 星期四 山东省济南市 */
+import { deflate_1$2 as e, inflate_1$2 as t } from "../../libs/pako/index.js";
+import "./encryption.js";
+//#region components/pc/draw/core/data/encode.ts
+var n = (e) => {
+	let t = typeof e == "string" ? new TextEncoder().encode(e) : e instanceof Uint8Array ? e : new Uint8Array(e), n = "";
+	for (let e of t) n += String.fromCharCode(e);
+	return n;
+}, r = (e) => {
+	let t = new ArrayBuffer(e.length), n = new Uint8Array(t);
+	for (let t = 0, r = e.length; t < r; t++) n[t] = e.charCodeAt(t);
+	return t;
+}, i = (e) => new TextDecoder("utf-8").decode(r(e)), a = (e, t = !1) => t ? window.btoa(e) : window.btoa(n(e)), o = (e, t = !1) => t ? window.atob(e) : i(window.atob(e)), s = ({ text: t, compress: r }) => {
+	let i;
+	if (r !== !1) try {
+		i = n(e(t));
+	} catch (e) {
+		console.error("encode: cannot deflate", e);
+	}
+	return {
+		version: "1",
+		encoding: "bstring",
+		compressed: !!i,
+		encoded: i || n(t)
+	};
+}, c = (e) => {
+	let n;
+	switch (e.encoding) {
+		case "bstring":
+			n = e.compressed ? e.encoded : i(e.encoded);
+			break;
+		default: throw Error(`decode: unknown encoding "${e.encoding}"`);
+	}
+	return e.compressed ? t(new Uint8Array(r(n)), { to: "string" }) : n;
+};
+//#endregion
+export { o as base64ToString, c as decode, s as encode, a as stringToBase64, n as toByteString };
+/* 独立思考，明辨是非 */

package/draw/core/data/encryption.d.ts

@@ -0,0 +1,9 @@
+export declare const IV_LENGTH_BYTES = 12;
+export declare const createIV: () => Uint8Array<ArrayBuffer>;
+export declare const generateEncryptionKey: <T extends "string" | "cryptoKey" = "string">(returnAs?: T) => Promise<T extends "cryptoKey" ? CryptoKey : string>;
+export declare const getCryptoKey: (key: string, usage: KeyUsage) => Promise<CryptoKey>;
+export declare const encryptData: (key: string | CryptoKey, data: Uint8Array<ArrayBuffer> | ArrayBuffer | Blob | File | string) => Promise<{
+    encryptedBuffer: ArrayBuffer;
+    iv: Uint8Array<ArrayBuffer>;
+}>;
+export declare const decryptData: (iv: Uint8Array<ArrayBuffer>, encrypted: Uint8Array<ArrayBuffer> | ArrayBuffer, privateKey: string) => Promise<ArrayBuffer>;

package/draw/core/data/encryption.js

@@ -0,0 +1,4 @@
+/* 潘启宝 2026-06-25 17:54:57 星期四 山东省济南市 */
+import "../../common/index.js";
+import "./blob.js";
+/* 独立思考，明辨是非 */

package/draw/core/data/filesystem.d.ts

@@ -0,0 +1,21 @@
+import { MIME_TYPES } from '../../common';
+import type { FileSystemHandle } from '../../libs/browser-fs-access';
+import { supported as nativeFileSystemSupported } from '../../libs/browser-fs-access';
+type FILE_EXTENSION = Exclude<keyof typeof MIME_TYPES, 'binary'>;
+export declare const fileOpen: <M extends boolean | undefined = false>(opts: {
+    extensions?: FILE_EXTENSION[];
+    description: string;
+    multiple?: M;
+}) => Promise<M extends false | undefined ? File : File[]>;
+export declare const fileSave: (blob: Blob | Promise<Blob>, opts: {
+    /** supply without the extension */
+    name: string;
+    /** file extension */
+    extension: FILE_EXTENSION;
+    mimeTypes?: string[];
+    description: string;
+    /** existing FileSystemHandle */
+    fileHandle?: FileSystemHandle | null;
+}) => Promise<FileSystemFileHandle | null>;
+export { nativeFileSystemSupported };
+export type { FileSystemHandle };