@excalidraw/excalidraw 0.18.0-39ce38a0d-200a6bd94 → 0.18.0-3bdaafe

package/dist/dev/{chunk-GZYPVQVV.js → chunk-WQARCR2O.js}

@@ -1,6 +1,6 @@
 import {
   define_import_meta_env_default
-} from "./chunk-Y7B3JU7D.js";
+} from "./chunk-CP5DND7P.js";
 import {
   __publicField
 } from "./chunk-XDFCUUT6.js";
@@ -9,15 +9,15 @@ import {
 import tEXt from "png-chunk-text";
 import encodePng from "png-chunks-encode";
 import decodePng from "png-chunks-extract";
-import { EXPORT_DATA_TYPES as EXPORT_DATA_TYPES3, MIME_TYPES as MIME_TYPES7 } from "@excalidraw/common";
+import { EXPORT_DATA_TYPES as EXPORT_DATA_TYPES4, MIME_TYPES as MIME_TYPES8 } from "@excalidraw/common";
 
 // data/blob.ts
 import { nanoid } from "nanoid";
 import {
   IMAGE_MIME_TYPES,
-  MIME_TYPES as MIME_TYPES6,
+  MIME_TYPES as MIME_TYPES7,
   bytesToHexString,
-  isPromiseLike
+  isPromiseLike as isPromiseLike2
 } from "@excalidraw/common";
 import { clearElementsForExport as clearElementsForExport2 } from "@excalidraw/element";
 
@@ -4677,10 +4677,709 @@ var getExportSize = (elements, exportPadding, scale) => {
   return [width, height];
 };
 
-// data/restore.ts
-import { isFiniteNumber, pointFrom as pointFrom3 } from "@excalidraw/math";
+// clipboard.ts
+import {
+  ALLOWED_PASTE_MIME_TYPES,
+  EXPORT_DATA_TYPES as EXPORT_DATA_TYPES3,
+  MIME_TYPES as MIME_TYPES6,
+  arrayToMap as arrayToMap2,
+  isMemberOf,
+  isPromiseLike,
+  EVENT as EVENT2
+} from "@excalidraw/common";
+import { mutateElement } from "@excalidraw/element";
+import { deepCopyElement } from "@excalidraw/element";
+import {
+  isFrameLikeElement as isFrameLikeElement2,
+  isInitializedImageElement as isInitializedImageElement2
+} from "@excalidraw/element";
+import { getContainingFrame as getContainingFrame2 } from "@excalidraw/element";
+
+// charts.ts
+import { pointFrom as pointFrom3 } from "@excalidraw/math";
 import {
+  COLOR_PALETTE as COLOR_PALETTE2,
+  DEFAULT_CHART_COLOR_INDEX,
+  getAllColorsSpecificShade,
   DEFAULT_FONT_FAMILY as DEFAULT_FONT_FAMILY2,
+  DEFAULT_FONT_SIZE as DEFAULT_FONT_SIZE2,
+  VERTICAL_ALIGN,
+  randomId,
+  isDevEnv
+} from "@excalidraw/common";
+import {
+  newTextElement as newTextElement2,
+  newLinearElement,
+  newElement
+} from "@excalidraw/element";
+var BAR_WIDTH = 32;
+var BAR_GAP = 12;
+var BAR_HEIGHT = 256;
+var GRID_OPACITY = 50;
+var NOT_SPREADSHEET = "NOT_SPREADSHEET";
+var VALID_SPREADSHEET = "VALID_SPREADSHEET";
+var tryParseNumber = (s) => {
+  const match = /^([-+]?)[$€£¥₩]?([-+]?)([\d.,]+)[%]?$/.exec(s);
+  if (!match) {
+    return null;
+  }
+  return parseFloat(`${(match[1] || match[2]) + match[3]}`.replace(/,/g, ""));
+};
+var isNumericColumn = (lines, columnIndex) => lines.slice(1).every((line) => tryParseNumber(line[columnIndex]) !== null);
+var tryParseCells = (cells) => {
+  const numCols = cells[0].length;
+  if (numCols > 2) {
+    return { type: NOT_SPREADSHEET, reason: "More than 2 columns" };
+  }
+  if (numCols === 1) {
+    if (!isNumericColumn(cells, 0)) {
+      return { type: NOT_SPREADSHEET, reason: "Value is not numeric" };
+    }
+    const hasHeader2 = tryParseNumber(cells[0][0]) === null;
+    const values = (hasHeader2 ? cells.slice(1) : cells).map(
+      (line) => tryParseNumber(line[0])
+    );
+    if (values.length < 2) {
+      return { type: NOT_SPREADSHEET, reason: "Less than two rows" };
+    }
+    return {
+      type: VALID_SPREADSHEET,
+      spreadsheet: {
+        title: hasHeader2 ? cells[0][0] : null,
+        labels: null,
+        values
+      }
+    };
+  }
+  const labelColumnNumeric = isNumericColumn(cells, 0);
+  const valueColumnNumeric = isNumericColumn(cells, 1);
+  if (!labelColumnNumeric && !valueColumnNumeric) {
+    return { type: NOT_SPREADSHEET, reason: "Value is not numeric" };
+  }
+  const [labelColumnIndex, valueColumnIndex] = valueColumnNumeric ? [0, 1] : [1, 0];
+  const hasHeader = tryParseNumber(cells[0][valueColumnIndex]) === null;
+  const rows = hasHeader ? cells.slice(1) : cells;
+  if (rows.length < 2) {
+    return { type: NOT_SPREADSHEET, reason: "Less than 2 rows" };
+  }
+  return {
+    type: VALID_SPREADSHEET,
+    spreadsheet: {
+      title: hasHeader ? cells[0][valueColumnIndex] : null,
+      labels: rows.map((row) => row[labelColumnIndex]),
+      values: rows.map((row) => tryParseNumber(row[valueColumnIndex]))
+    }
+  };
+};
+var transposeCells = (cells) => {
+  const nextCells = [];
+  for (let col = 0; col < cells[0].length; col++) {
+    const nextCellRow = [];
+    for (let row = 0; row < cells.length; row++) {
+      nextCellRow.push(cells[row][col]);
+    }
+    nextCells.push(nextCellRow);
+  }
+  return nextCells;
+};
+var tryParseSpreadsheet = (text) => {
+  let lines = text.trim().split("\n").map((line) => line.trim().split("	"));
+  if (lines.length && lines[0].length !== 2) {
+    lines = text.trim().split("\n").map((line) => line.trim().split(","));
+  }
+  if (lines.length === 0) {
+    return { type: NOT_SPREADSHEET, reason: "No values" };
+  }
+  const numColsFirstLine = lines[0].length;
+  const isSpreadsheet = lines.every((line) => line.length === numColsFirstLine);
+  if (!isSpreadsheet) {
+    return {
+      type: NOT_SPREADSHEET,
+      reason: "All rows don't have same number of columns"
+    };
+  }
+  const result = tryParseCells(lines);
+  if (result.type !== VALID_SPREADSHEET) {
+    const transposedResults = tryParseCells(transposeCells(lines));
+    if (transposedResults.type === VALID_SPREADSHEET) {
+      return transposedResults;
+    }
+  }
+  return result;
+};
+var bgColors = getAllColorsSpecificShade(DEFAULT_CHART_COLOR_INDEX);
+var commonProps = {
+  fillStyle: "hachure",
+  fontFamily: DEFAULT_FONT_FAMILY2,
+  fontSize: DEFAULT_FONT_SIZE2,
+  opacity: 100,
+  roughness: 1,
+  strokeColor: COLOR_PALETTE2.black,
+  roundness: null,
+  strokeStyle: "solid",
+  strokeWidth: 1,
+  verticalAlign: VERTICAL_ALIGN.MIDDLE,
+  locked: false
+};
+var getChartDimensions = (spreadsheet) => {
+  const chartWidth = (BAR_WIDTH + BAR_GAP) * spreadsheet.values.length + BAR_GAP;
+  const chartHeight = BAR_HEIGHT + BAR_GAP * 2;
+  return { chartWidth, chartHeight };
+};
+var chartXLabels = (spreadsheet, x, y, groupId, backgroundColor) => {
+  return spreadsheet.labels?.map((label, index) => {
+    return newTextElement2({
+      groupIds: [groupId],
+      backgroundColor,
+      ...commonProps,
+      text: label.length > 8 ? `${label.slice(0, 5)}...` : label,
+      x: x + index * (BAR_WIDTH + BAR_GAP) + BAR_GAP * 2,
+      y: y + BAR_GAP / 2,
+      width: BAR_WIDTH,
+      angle: 5.87,
+      fontSize: 16,
+      textAlign: "center",
+      verticalAlign: "top"
+    });
+  }) || [];
+};
+var chartYLabels = (spreadsheet, x, y, groupId, backgroundColor) => {
+  const minYLabel = newTextElement2({
+    groupIds: [groupId],
+    backgroundColor,
+    ...commonProps,
+    x: x - BAR_GAP,
+    y: y - BAR_GAP,
+    text: "0",
+    textAlign: "right"
+  });
+  const maxYLabel = newTextElement2({
+    groupIds: [groupId],
+    backgroundColor,
+    ...commonProps,
+    x: x - BAR_GAP,
+    y: y - BAR_HEIGHT - minYLabel.height / 2,
+    text: Math.max(...spreadsheet.values).toLocaleString(),
+    textAlign: "right"
+  });
+  return [minYLabel, maxYLabel];
+};
+var chartLines = (spreadsheet, x, y, groupId, backgroundColor) => {
+  const { chartWidth, chartHeight } = getChartDimensions(spreadsheet);
+  const xLine = newLinearElement({
+    backgroundColor,
+    groupIds: [groupId],
+    ...commonProps,
+    type: "line",
+    x,
+    y,
+    width: chartWidth,
+    points: [pointFrom3(0, 0), pointFrom3(chartWidth, 0)]
+  });
+  const yLine = newLinearElement({
+    backgroundColor,
+    groupIds: [groupId],
+    ...commonProps,
+    type: "line",
+    x,
+    y,
+    height: chartHeight,
+    points: [pointFrom3(0, 0), pointFrom3(0, -chartHeight)]
+  });
+  const maxLine = newLinearElement({
+    backgroundColor,
+    groupIds: [groupId],
+    ...commonProps,
+    type: "line",
+    x,
+    y: y - BAR_HEIGHT - BAR_GAP,
+    strokeStyle: "dotted",
+    width: chartWidth,
+    opacity: GRID_OPACITY,
+    points: [pointFrom3(0, 0), pointFrom3(chartWidth, 0)]
+  });
+  return [xLine, yLine, maxLine];
+};
+var chartBaseElements = (spreadsheet, x, y, groupId, backgroundColor, debug) => {
+  const { chartWidth, chartHeight } = getChartDimensions(spreadsheet);
+  const title = spreadsheet.title ? newTextElement2({
+    backgroundColor,
+    groupIds: [groupId],
+    ...commonProps,
+    text: spreadsheet.title,
+    x: x + chartWidth / 2,
+    y: y - BAR_HEIGHT - BAR_GAP * 2 - DEFAULT_FONT_SIZE2,
+    roundness: null,
+    textAlign: "center"
+  }) : null;
+  const debugRect = debug ? newElement({
+    backgroundColor,
+    groupIds: [groupId],
+    ...commonProps,
+    type: "rectangle",
+    x,
+    y: y - chartHeight,
+    width: chartWidth,
+    height: chartHeight,
+    strokeColor: COLOR_PALETTE2.black,
+    fillStyle: "solid",
+    opacity: 6
+  }) : null;
+  return [
+    ...debugRect ? [debugRect] : [],
+    ...title ? [title] : [],
+    ...chartXLabels(spreadsheet, x, y, groupId, backgroundColor),
+    ...chartYLabels(spreadsheet, x, y, groupId, backgroundColor),
+    ...chartLines(spreadsheet, x, y, groupId, backgroundColor)
+  ];
+};
+var chartTypeBar = (spreadsheet, x, y) => {
+  const max = Math.max(...spreadsheet.values);
+  const groupId = randomId();
+  const backgroundColor = bgColors[Math.floor(Math.random() * bgColors.length)];
+  const bars = spreadsheet.values.map((value, index) => {
+    const barHeight = value / max * BAR_HEIGHT;
+    return newElement({
+      backgroundColor,
+      groupIds: [groupId],
+      ...commonProps,
+      type: "rectangle",
+      x: x + index * (BAR_WIDTH + BAR_GAP) + BAR_GAP,
+      y: y - barHeight - BAR_GAP,
+      width: BAR_WIDTH,
+      height: barHeight
+    });
+  });
+  return [
+    ...bars,
+    ...chartBaseElements(
+      spreadsheet,
+      x,
+      y,
+      groupId,
+      backgroundColor,
+      isDevEnv()
+    )
+  ];
+};
+var chartTypeLine = (spreadsheet, x, y) => {
+  const max = Math.max(...spreadsheet.values);
+  const groupId = randomId();
+  const backgroundColor = bgColors[Math.floor(Math.random() * bgColors.length)];
+  let index = 0;
+  const points = [];
+  for (const value of spreadsheet.values) {
+    const cx = index * (BAR_WIDTH + BAR_GAP);
+    const cy = -(value / max) * BAR_HEIGHT;
+    points.push([cx, cy]);
+    index++;
+  }
+  const maxX = Math.max(...points.map((element) => element[0]));
+  const maxY = Math.max(...points.map((element) => element[1]));
+  const minX = Math.min(...points.map((element) => element[0]));
+  const minY = Math.min(...points.map((element) => element[1]));
+  const line = newLinearElement({
+    backgroundColor,
+    groupIds: [groupId],
+    ...commonProps,
+    type: "line",
+    x: x + BAR_GAP + BAR_WIDTH / 2,
+    y: y - BAR_GAP,
+    height: maxY - minY,
+    width: maxX - minX,
+    strokeWidth: 2,
+    points
+  });
+  const dots = spreadsheet.values.map((value, index2) => {
+    const cx = index2 * (BAR_WIDTH + BAR_GAP) + BAR_GAP / 2;
+    const cy = -(value / max) * BAR_HEIGHT + BAR_GAP / 2;
+    return newElement({
+      backgroundColor,
+      groupIds: [groupId],
+      ...commonProps,
+      fillStyle: "solid",
+      strokeWidth: 2,
+      type: "ellipse",
+      x: x + cx + BAR_WIDTH / 2,
+      y: y + cy - BAR_GAP * 2,
+      width: BAR_GAP,
+      height: BAR_GAP
+    });
+  });
+  const lines = spreadsheet.values.map((value, index2) => {
+    const cx = index2 * (BAR_WIDTH + BAR_GAP) + BAR_GAP / 2;
+    const cy = value / max * BAR_HEIGHT + BAR_GAP / 2 + BAR_GAP;
+    return newLinearElement({
+      backgroundColor,
+      groupIds: [groupId],
+      ...commonProps,
+      type: "line",
+      x: x + cx + BAR_WIDTH / 2 + BAR_GAP / 2,
+      y: y - cy,
+      height: cy,
+      strokeStyle: "dotted",
+      opacity: GRID_OPACITY,
+      points: [pointFrom3(0, 0), pointFrom3(0, cy)]
+    });
+  });
+  return [
+    ...chartBaseElements(
+      spreadsheet,
+      x,
+      y,
+      groupId,
+      backgroundColor,
+      isDevEnv()
+    ),
+    line,
+    ...lines,
+    ...dots
+  ];
+};
+var renderSpreadsheet = (chartType, spreadsheet, x, y) => {
+  if (chartType === "line") {
+    return chartTypeLine(spreadsheet, x, y);
+  }
+  return chartTypeBar(spreadsheet, x, y);
+};
+
+// clipboard.ts
+var probablySupportsClipboardReadText = "clipboard" in navigator && "readText" in navigator.clipboard;
+var probablySupportsClipboardWriteText = "clipboard" in navigator && "writeText" in navigator.clipboard;
+var probablySupportsClipboardBlob = "clipboard" in navigator && "write" in navigator.clipboard && "ClipboardItem" in window && "toBlob" in HTMLCanvasElement.prototype;
+var clipboardContainsElements = (contents) => {
+  if ([
+    EXPORT_DATA_TYPES3.excalidraw,
+    EXPORT_DATA_TYPES3.excalidrawClipboard,
+    EXPORT_DATA_TYPES3.excalidrawClipboardWithAPI
+  ].includes(contents?.type) && Array.isArray(contents.elements)) {
+    return true;
+  }
+  return false;
+};
+var createPasteEvent = ({
+  types,
+  files
+}) => {
+  if (!types && !files) {
+    console.warn("createPasteEvent: no types or files provided");
+  }
+  const event = new ClipboardEvent(EVENT2.PASTE, {
+    clipboardData: new DataTransfer()
+  });
+  if (types) {
+    for (const [type, value] of Object.entries(types)) {
+      if (typeof value !== "string") {
+        files = files || [];
+        files.push(value);
+        continue;
+      }
+      try {
+        event.clipboardData?.setData(type, value);
+        if (event.clipboardData?.getData(type) !== value) {
+          throw new Error(`Failed to set "${type}" as clipboardData item`);
+        }
+      } catch (error) {
+        throw new Error(error.message);
+      }
+    }
+  }
+  if (files) {
+    let idx = -1;
+    for (const file of files) {
+      idx++;
+      try {
+        event.clipboardData?.items.add(file);
+        if (event.clipboardData?.files[idx] !== file) {
+          throw new Error(
+            `Failed to set file "${file.name}" as clipboardData item`
+          );
+        }
+      } catch (error) {
+        throw new Error(error.message);
+      }
+    }
+  }
+  return event;
+};
+var serializeAsClipboardJSON = ({
+  elements,
+  files
+}) => {
+  const elementsMap = arrayToMap2(elements);
+  const framesToCopy = new Set(
+    elements.filter((element) => isFrameLikeElement2(element))
+  );
+  let foundFile = false;
+  const _files = elements.reduce((acc, element) => {
+    if (isInitializedImageElement2(element)) {
+      foundFile = true;
+      if (files && files[element.fileId]) {
+        acc[element.fileId] = files[element.fileId];
+      }
+    }
+    return acc;
+  }, {});
+  if (foundFile && !files) {
+    console.warn(
+      "copyToClipboard: attempting to file element(s) without providing associated `files` object."
+    );
+  }
+  const contents = {
+    type: EXPORT_DATA_TYPES3.excalidrawClipboard,
+    elements: elements.map((element) => {
+      if (getContainingFrame2(element, elementsMap) && !framesToCopy.has(getContainingFrame2(element, elementsMap))) {
+        const copiedElement = deepCopyElement(element);
+        mutateElement(copiedElement, elementsMap, {
+          frameId: null
+        });
+        return copiedElement;
+      }
+      return element;
+    }),
+    files: files ? _files : void 0
+  };
+  return JSON.stringify(contents);
+};
+var copyToClipboard = async (elements, files, clipboardEvent) => {
+  await copyTextToSystemClipboard(
+    serializeAsClipboardJSON({ elements, files }),
+    clipboardEvent
+  );
+};
+var parsePotentialSpreadsheet = (text) => {
+  const result = tryParseSpreadsheet(text);
+  if (result.type === VALID_SPREADSHEET) {
+    return { spreadsheet: result.spreadsheet };
+  }
+  return null;
+};
+function parseHTMLTree(el) {
+  let result = [];
+  for (const node of el.childNodes) {
+    if (node.nodeType === 3) {
+      const text = node.textContent?.trim();
+      if (text) {
+        result.push({ type: "text", value: text });
+      }
+    } else if (node instanceof HTMLImageElement) {
+      const url = node.getAttribute("src");
+      if (url && url.startsWith("http")) {
+        result.push({ type: "imageUrl", value: url });
+      }
+    } else {
+      result = result.concat(parseHTMLTree(node));
+    }
+  }
+  return result;
+}
+var maybeParseHTMLPaste = (event) => {
+  const html = event.clipboardData?.getData(MIME_TYPES6.html);
+  if (!html) {
+    return null;
+  }
+  try {
+    const doc = new DOMParser().parseFromString(html, MIME_TYPES6.html);
+    const content = parseHTMLTree(doc.body);
+    if (content.length) {
+      return { type: "mixedContent", value: content };
+    }
+  } catch (error) {
+    console.error(`error in parseHTMLFromPaste: ${error.message}`);
+  }
+  return null;
+};
+var readSystemClipboard = async () => {
+  const types = {};
+  let clipboardItems;
+  try {
+    clipboardItems = await navigator.clipboard?.read();
+  } catch (error) {
+    try {
+      if (navigator.clipboard?.readText) {
+        console.warn(
+          `navigator.clipboard.readText() failed (${error.message}). Failling back to navigator.clipboard.read()`
+        );
+        const readText = await navigator.clipboard?.readText();
+        if (readText) {
+          return { [MIME_TYPES6.text]: readText };
+        }
+      }
+    } catch (error2) {
+      if (navigator.clipboard?.read) {
+        console.warn(
+          `navigator.clipboard.readText() failed (${error2.message}). Failling back to navigator.clipboard.read()`
+        );
+      } else {
+        if (error2.name === "DataError") {
+          console.warn(
+            `navigator.clipboard.read() error, clipboard is probably empty: ${error2.message}`
+          );
+          return types;
+        }
+        throw error2;
+      }
+    }
+    throw error;
+  }
+  for (const item of clipboardItems) {
+    for (const type of item.types) {
+      if (!isMemberOf(ALLOWED_PASTE_MIME_TYPES, type)) {
+        continue;
+      }
+      try {
+        if (type === MIME_TYPES6.text || type === MIME_TYPES6.html) {
+          types[type] = await (await item.getType(type)).text();
+        } else if (isSupportedImageFileType(type)) {
+          const imageBlob = await item.getType(type);
+          const file = createFile(imageBlob, type, void 0);
+          types[type] = file;
+        } else {
+          throw new ExcalidrawError(`Unsupported clipboard type: ${type}`);
+        }
+      } catch (error) {
+        console.warn(
+          error instanceof ExcalidrawError ? error.message : `Cannot retrieve ${type} from clipboardItem: ${error.message}`
+        );
+      }
+    }
+  }
+  if (Object.keys(types).length === 0) {
+    console.warn("No clipboard data found from clipboard.read().");
+    return types;
+  }
+  return types;
+};
+var parseClipboardEventTextData = async (event, isPlainPaste = false) => {
+  try {
+    const mixedContent = !isPlainPaste && event && maybeParseHTMLPaste(event);
+    if (mixedContent) {
+      if (mixedContent.value.every((item) => item.type === "text")) {
+        return {
+          type: "text",
+          value: event.clipboardData?.getData(MIME_TYPES6.text) || mixedContent.value.map((item) => item.value).join("\n").trim()
+        };
+      }
+      return mixedContent;
+    }
+    const text = event.clipboardData?.getData(MIME_TYPES6.text);
+    return { type: "text", value: (text || "").trim() };
+  } catch {
+    return { type: "text", value: "" };
+  }
+};
+var parseClipboard = async (event, isPlainPaste = false) => {
+  const parsedEventData = await parseClipboardEventTextData(
+    event,
+    isPlainPaste
+  );
+  if (parsedEventData.type === "mixedContent") {
+    return {
+      mixedContent: parsedEventData.value
+    };
+  }
+  try {
+    const spreadsheetResult = !isPlainPaste && parsePotentialSpreadsheet(parsedEventData.value);
+    if (spreadsheetResult) {
+      return spreadsheetResult;
+    }
+  } catch (error) {
+    console.error(error);
+  }
+  try {
+    const systemClipboardData = JSON.parse(parsedEventData.value);
+    const programmaticAPI = systemClipboardData.type === EXPORT_DATA_TYPES3.excalidrawClipboardWithAPI;
+    if (clipboardContainsElements(systemClipboardData)) {
+      return {
+        elements: systemClipboardData.elements,
+        files: systemClipboardData.files,
+        text: isPlainPaste ? JSON.stringify(systemClipboardData.elements, null, 2) : void 0,
+        programmaticAPI
+      };
+    }
+  } catch {
+  }
+  return { text: parsedEventData.value };
+};
+var copyBlobToClipboardAsPng = async (blob) => {
+  try {
+    await navigator.clipboard.write([
+      new window.ClipboardItem({
+        [MIME_TYPES6.png]: blob
+      })
+    ]);
+  } catch (error) {
+    if (isPromiseLike(blob)) {
+      await navigator.clipboard.write([
+        new window.ClipboardItem({
+          [MIME_TYPES6.png]: await blob
+        })
+      ]);
+    } else {
+      throw error;
+    }
+  }
+};
+var copyTextToSystemClipboard = async (text, clipboardEvent) => {
+  if (probablySupportsClipboardWriteText) {
+    try {
+      await navigator.clipboard.writeText(text || "");
+      return;
+    } catch (error) {
+      console.error(error);
+    }
+  }
+  try {
+    if (clipboardEvent) {
+      clipboardEvent.clipboardData?.setData(MIME_TYPES6.text, text || "");
+      if (clipboardEvent.clipboardData?.getData(MIME_TYPES6.text) !== text) {
+        throw new Error("Failed to setData on clipboardEvent");
+      }
+      return;
+    }
+  } catch (error) {
+    console.error(error);
+  }
+  if (!copyTextViaExecCommand(text)) {
+    throw new Error("Error copying to clipboard.");
+  }
+};
+var copyTextViaExecCommand = (text) => {
+  if (!text) {
+    text = " ";
+  }
+  const isRTL2 = document.documentElement.getAttribute("dir") === "rtl";
+  const textarea = document.createElement("textarea");
+  textarea.style.border = "0";
+  textarea.style.padding = "0";
+  textarea.style.margin = "0";
+  textarea.style.position = "absolute";
+  textarea.style[isRTL2 ? "right" : "left"] = "-9999px";
+  const yPosition = window.pageYOffset || document.documentElement.scrollTop;
+  textarea.style.top = `${yPosition}px`;
+  textarea.style.fontSize = "12pt";
+  textarea.setAttribute("readonly", "");
+  textarea.value = text;
+  document.body.appendChild(textarea);
+  let success = false;
+  try {
+    textarea.select();
+    textarea.setSelectionRange(0, textarea.value.length);
+    success = document.execCommand("copy");
+  } catch (error) {
+    console.error(error);
+  }
+  textarea.remove();
+  return success;
+};
+var isClipboardEvent = (event) => {
+  return event.type === EVENT2.PASTE || event.type === EVENT2.COPY || event.type === EVENT2.CUT;
+};
+
+// data/restore.ts
+import { isFiniteNumber, pointFrom as pointFrom4 } from "@excalidraw/math";
+import {
+  DEFAULT_FONT_FAMILY as DEFAULT_FONT_FAMILY3,
   DEFAULT_TEXT_ALIGN as DEFAULT_TEXT_ALIGN2,
   DEFAULT_VERTICAL_ALIGN,
   FONT_FAMILY as FONT_FAMILY3,
@@ -4689,10 +5388,10 @@ import {
   DEFAULT_ELEMENT_PROPS as DEFAULT_ELEMENT_PROPS2,
   DEFAULT_GRID_SIZE as DEFAULT_GRID_SIZE2,
   DEFAULT_GRID_STEP as DEFAULT_GRID_STEP2,
-  randomId,
+  randomId as randomId2,
   getUpdatedTimestamp,
   updateActiveTool,
-  arrayToMap as arrayToMap2,
+  arrayToMap as arrayToMap3,
   getSizeFromPoints,
   normalizeLink as normalizeLink2,
   getLineHeight
@@ -4744,7 +5443,7 @@ var getFontFamilyByName = (fontFamilyName) => {
   if (Object.keys(FONT_FAMILY3).includes(fontFamilyName)) {
     return FONT_FAMILY3[fontFamilyName];
   }
-  return DEFAULT_FONT_FAMILY2;
+  return DEFAULT_FONT_FAMILY3;
 };
 var repairBinding = (element, binding) => {
   if (!binding) {
@@ -4773,7 +5472,7 @@ var restoreElementWithProperties = (element, extra) => {
     versionNonce: element.versionNonce ?? 0,
     index: element.index ?? null,
     isDeleted: element.isDeleted ?? false,
-    id: element.id || randomId(),
+    id: element.id || randomId2(),
     fillStyle: element.fillStyle || DEFAULT_ELEMENT_PROPS2.fillStyle,
     strokeWidth: element.strokeWidth || DEFAULT_ELEMENT_PROPS2.strokeWidth,
     strokeStyle: element.strokeStyle ?? DEFAULT_ELEMENT_PROPS2.strokeStyle,
@@ -4815,7 +5514,7 @@ var restoreElementWithProperties = (element, extra) => {
   delete ret.boundElementIds;
   return ret;
 };
-var restoreElement = (element) => {
+var restoreElement = (element, opts) => {
   element = { ...element };
   switch (element.type) {
     case "text":
@@ -4847,7 +5546,7 @@ var restoreElement = (element) => {
         autoResize: element.autoResize ?? true,
         lineHeight
       });
-      if (!text && !element.isDeleted) {
+      if (opts?.deleteInvisibleElements && !text && !element.isDeleted) {
         element = { ...element, originalText: text, isDeleted: true };
         element = bumpVersion(element);
       }
@@ -4874,7 +5573,7 @@ var restoreElement = (element) => {
       let y = element.y;
       let points = (
         // migrate old arrow model to new one
-        !Array.isArray(element.points) || element.points.length < 2 ? [pointFrom3(0, 0), pointFrom3(element.width, element.height)] : element.points
+        !Array.isArray(element.points) || element.points.length < 2 ? [pointFrom4(0, 0), pointFrom4(element.width, element.height)] : element.points
       );
       if (points[0][0] !== 0 || points[0][1] !== 0) {
         ({ points, x, y } = LinearElementEditor2.getNormalizeElementPointsAndCoords(element));
@@ -4900,7 +5599,7 @@ var restoreElement = (element) => {
       let y2 = element.y;
       let points2 = (
         // migrate old arrow model to new one
-        !Array.isArray(element.points) || element.points.length < 2 ? [pointFrom3(0, 0), pointFrom3(element.width, element.height)] : element.points
+        !Array.isArray(element.points) || element.points.length < 2 ? [pointFrom4(0, 0), pointFrom4(element.width, element.height)] : element.points
       );
       if (points2[0][0] !== 0 || points2[0][1] !== 0) {
         ({ points: points2, x: x2, y: y2 } = LinearElementEditor2.getNormalizeElementPointsAndCoords(element));
@@ -4923,7 +5622,7 @@ var restoreElement = (element) => {
         elbowed: true,
         startBinding: repairBinding(element, element.startBinding),
         endBinding: repairBinding(element, element.endBinding),
-        fixedSegments: element.fixedSegments,
+        fixedSegments: element.fixedSegments?.length && base.points.length >= 4 ? element.fixedSegments : null,
         startIsSpecial: element.startIsSpecial,
         endIsSpecial: element.endIsSpecial
       }) : restoreElementWithProperties(element, base);
@@ -4993,25 +5692,29 @@ var repairFrameMembership = (element, elementsMap) => {
 };
 var restoreElements = (elements, localElements, opts) => {
   const existingIds = /* @__PURE__ */ new Set();
-  const localElementsMap = localElements ? arrayToMap2(localElements) : null;
+  const localElementsMap = localElements ? arrayToMap3(localElements) : null;
   const restoredElements = syncInvalidIndices2(
     (elements || []).reduce((elements2, element) => {
-      if (element.type !== "selection" && !isInvisiblySmallElement(element)) {
-        let migratedElement = restoreElement(element);
-        if (migratedElement) {
-          const localElement = localElementsMap?.get(element.id);
-          if (localElement && localElement.version > migratedElement.version) {
-            migratedElement = bumpVersion(
-              migratedElement,
-              localElement.version
-            );
-          }
-          if (existingIds.has(migratedElement.id)) {
-            migratedElement = { ...migratedElement, id: randomId() };
-          }
-          existingIds.add(migratedElement.id);
-          elements2.push(migratedElement);
+      if (element.type === "selection") {
+        return elements2;
+      }
+      let migratedElement = restoreElement(element, {
+        deleteInvisibleElements: opts?.deleteInvisibleElements
+      });
+      if (migratedElement) {
+        const localElement = localElementsMap?.get(element.id);
+        const shouldMarkAsDeleted = opts?.deleteInvisibleElements && isInvisiblySmallElement(element);
+        if (shouldMarkAsDeleted || localElement && localElement.version > migratedElement.version) {
+          migratedElement = bumpVersion(migratedElement, localElement?.version);
+        }
+        if (shouldMarkAsDeleted) {
+          migratedElement = { ...migratedElement, isDeleted: true };
         }
+        if (existingIds.has(migratedElement.id)) {
+          migratedElement = { ...migratedElement, id: randomId2() };
+        }
+        existingIds.add(migratedElement.id);
+        elements2.push(migratedElement);
       }
       return elements2;
     }, [])
@@ -5019,7 +5722,7 @@ var restoreElements = (elements, localElements, opts) => {
   if (!opts?.repairBindings) {
     return restoredElements;
   }
-  const restoredElementsMap = arrayToMap2(restoredElements);
+  const restoredElementsMap = arrayToMap3(restoredElements);
   for (const element of restoredElements) {
     if (element.frameId) {
       repairFrameMembership(element, restoredElementsMap);
@@ -5057,7 +5760,7 @@ var restoreElements = (elements, localElements, opts) => {
           restoredElementsMap,
           {
             points: [
-              pointFrom3(0, 0),
+              pointFrom4(0, 0),
               element.points[element.points.length - 1]
             ]
           }
@@ -5086,10 +5789,10 @@ var restoreElements = (elements, localElements, opts) => {
         width: boundElement.width,
         height: boundElement.height,
         points: [
-          pointFrom3(0, 0),
-          pointFrom3(0, -10),
-          pointFrom3(boundElement.width / 2 + 5, -10),
-          pointFrom3(
+          pointFrom4(0, 0),
+          pointFrom4(0, -10),
+          pointFrom4(boundElement.width / 2 + 5, -10),
+          pointFrom4(
             boundElement.width / 2 + 5,
             boundElement.height / 2 + 5
           )
@@ -5188,7 +5891,7 @@ var restoreLibraryItems = (libraryItems = [], defaultStatus) => {
       const restoredItem = restoreLibraryItem({
         status: defaultStatus,
         elements: item,
-        id: randomId(),
+        id: randomId2(),
         created: Date.now()
       });
       if (restoredItem) {
@@ -5198,7 +5901,7 @@ var restoreLibraryItems = (libraryItems = [], defaultStatus) => {
       const _item = item;
       const restoredItem = restoreLibraryItem({
         ..._item,
-        id: _item.id || randomId(),
+        id: _item.id || randomId2(),
         status: _item.status || defaultStatus,
         created: _item.created || Date.now()
       });
@@ -5213,9 +5916,9 @@ var restoreLibraryItems = (libraryItems = [], defaultStatus) => {
 // data/blob.ts
 var parseFileContents = async (blob) => {
   let contents;
-  if (blob.type === MIME_TYPES6.png) {
+  if (blob.type === MIME_TYPES7.png) {
     try {
-      return await (await import("./data/image-V3RGFWEQ.js")).decodePngMetadata(blob);
+      return await (await import("./data/image-6EX7CJAB.js")).decodePngMetadata(blob);
     } catch (error) {
       if (error.message === "INVALID") {
         throw new ImageSceneDataError(
@@ -5240,7 +5943,7 @@ var parseFileContents = async (blob) => {
         };
       });
     }
-    if (blob.type === MIME_TYPES6.svg) {
+    if (blob.type === MIME_TYPES7.svg) {
       try {
         return decodeSvgBase64Payload({
           svg: contents
@@ -5296,7 +5999,7 @@ var loadSceneOrLibraryFromBlob = async (blob, localAppState, localElements, file
     }
     if (isValidExcalidrawData(data)) {
       return {
-        type: MIME_TYPES6.excalidraw,
+        type: MIME_TYPES7.excalidraw,
         data: restore(
           {
             elements: clearElementsForExport2(data.elements || []),
@@ -5310,12 +6013,16 @@ var loadSceneOrLibraryFromBlob = async (blob, localAppState, localElements, file
           },
           localAppState,
           localElements,
-          { repairBindings: true, refreshDimensions: false }
+          {
+            repairBindings: true,
+            refreshDimensions: false,
+            deleteInvisibleElements: true
+          }
         )
       };
     } else if (isValidLibrary(data)) {
       return {
-        type: MIME_TYPES6.excalidrawlib,
+        type: MIME_TYPES7.excalidrawlib,
         data
       };
     }
@@ -5334,7 +6041,7 @@ var loadFromBlob = async (blob, localAppState, localElements, fileHandle) => {
     localElements,
     fileHandle
   );
-  if (ret.type !== MIME_TYPES6.excalidraw) {
+  if (ret.type !== MIME_TYPES7.excalidraw) {
     throw new Error("Error: invalid file");
   }
   return ret.data;
@@ -5353,7 +6060,7 @@ var loadLibraryFromBlob = async (blob, defaultStatus = "unpublished") => {
 var canvasToBlob = async (canvas) => {
   return new Promise(async (resolve, reject) => {
     try {
-      if (isPromiseLike(canvas)) {
+      if (isPromiseLike2(canvas)) {
         canvas = await canvas;
       }
       canvas.toBlob((blob) => {
@@ -5402,7 +6109,7 @@ var dataURLToString = (dataURL) => {
   return base64ToString(dataURL.slice(dataURL.indexOf(",") + 1));
 };
 var resizeImageFile = async (file, opts) => {
-  if (file.type === MIME_TYPES6.svg) {
+  if (file.type === MIME_TYPES7.svg) {
     return file;
   }
   const [pica, imageBlobReduce] = await Promise.all([
@@ -5435,7 +6142,7 @@ var resizeImageFile = async (file, opts) => {
 };
 var SVGStringToFile = (SVGString, filename = "") => {
   return new File([new TextEncoder().encode(SVGString)], filename, {
-    type: MIME_TYPES6.svg
+    type: MIME_TYPES7.svg
   });
 };
 var ImageURLToFile = async (imageUrl, filename = "") => {
@@ -5455,16 +6162,37 @@ var ImageURLToFile = async (imageUrl, filename = "") => {
   }
   throw new Error("Error: unsupported file type", { cause: "UNSUPPORTED" });
 };
-var getFileFromEvent = async (event) => {
-  const file = event.dataTransfer.files.item(0);
-  const fileHandle = await getFileHandle(event);
-  return { file: file ? await normalizeFile(file) : null, fileHandle };
+var getFilesFromEvent = async (event) => {
+  let fileList = void 0;
+  let items = void 0;
+  if (isClipboardEvent(event)) {
+    fileList = event.clipboardData?.files;
+    items = event.clipboardData?.items;
+  } else {
+    const dragEvent = event;
+    fileList = dragEvent.dataTransfer?.files;
+    items = dragEvent.dataTransfer?.items;
+  }
+  const files = Array.from(fileList || []);
+  return await Promise.all(
+    files.map(async (file, idx) => {
+      const dataTransferItem = items?.[idx];
+      const fileHandle = dataTransferItem ? getFileHandle(dataTransferItem) : null;
+      return file ? {
+        file: await normalizeFile(file),
+        fileHandle: await fileHandle
+      } : {
+        file: null,
+        fileHandle: null
+      };
+    })
+  );
 };
 var getFileHandle = async (event) => {
   if (nativeFileSystemSupported) {
     try {
-      const item = event.dataTransfer.items[0];
-      const handle = await item.getAsFileSystemHandle() || null;
+      const dataTransferItem = event instanceof DataTransferItem ? event : event.dataTransfer?.items?.[0];
+      const handle = await dataTransferItem.getAsFileSystemHandle() || null;
       return handle;
     } catch (error) {
       console.warn(error.name, error.message);
@@ -5487,11 +6215,11 @@ var getActualMimeTypeFromImage = (buffer) => {
     gif: "71 73 70 56 57 97 "
   };
   if (first8Bytes === headerBytes.png) {
-    mimeType = MIME_TYPES6.png;
+    mimeType = MIME_TYPES7.png;
   } else if (first8Bytes.startsWith(headerBytes.jpg)) {
-    mimeType = MIME_TYPES6.jpg;
+    mimeType = MIME_TYPES7.jpg;
   } else if (first8Bytes.startsWith(headerBytes.gif)) {
-    mimeType = MIME_TYPES6.gif;
+    mimeType = MIME_TYPES7.gif;
   }
   return mimeType;
 };
@@ -5505,13 +6233,13 @@ var normalizeFile = async (file) => {
     if (file?.name?.endsWith(".excalidrawlib")) {
       file = createFile(
         await blobToArrayBuffer(file),
-        MIME_TYPES6.excalidrawlib,
+        MIME_TYPES7.excalidrawlib,
         file.name
       );
     } else if (file?.name?.endsWith(".excalidraw")) {
       file = createFile(
         await blobToArrayBuffer(file),
-        MIME_TYPES6.excalidraw,
+        MIME_TYPES7.excalidraw,
         file.name
       );
     } else {
@@ -5561,7 +6289,7 @@ var encodePngMetadata = async ({
 }) => {
   const chunks = decodePng(new Uint8Array(await blobToArrayBuffer(blob)));
   const metadataChunk = tEXt.encode(
-    MIME_TYPES7.excalidraw,
+    MIME_TYPES8.excalidraw,
     JSON.stringify(
       encode({
         text: metadata,
@@ -5570,15 +6298,15 @@ var encodePngMetadata = async ({
     )
   );
   chunks.splice(-1, 0, metadataChunk);
-  return new Blob([encodePng(chunks)], { type: MIME_TYPES7.png });
+  return new Blob([encodePng(chunks)], { type: MIME_TYPES8.png });
 };
 var decodePngMetadata = async (blob) => {
   const metadata = await getTEXtChunk(blob);
-  if (metadata?.keyword === MIME_TYPES7.excalidraw) {
+  if (metadata?.keyword === MIME_TYPES8.excalidraw) {
     try {
       const encodedData = JSON.parse(metadata.text);
       if (!("encoded" in encodedData)) {
-        if ("type" in encodedData && encodedData.type === EXPORT_DATA_TYPES3.excalidraw) {
+        if ("type" in encodedData && encodedData.type === EXPORT_DATA_TYPES4.excalidraw) {
           return metadata.text;
         }
         throw new Error("FAILED");
@@ -5608,7 +6336,6 @@ export {
   canChangeRoundness,
   AbortError,
   ImageSceneDataError,
-  ExcalidrawError,
   Fonts,
   getDefaultAppState,
   isEraserActive,
@@ -5637,6 +6364,7 @@ export {
   exportToCanvas,
   exportToSvg,
   getExportSize,
+  restoreElement,
   restoreElements,
   restoreAppState,
   restore,
@@ -5647,7 +6375,6 @@ export {
   getFileHandleType,
   isImageFileHandleType,
   isImageFileHandle,
-  isSupportedImageFileType,
   isSupportedImageFile,
   loadSceneOrLibraryFromBlob,
   loadFromBlob,
@@ -5661,8 +6388,16 @@ export {
   resizeImageFile,
   SVGStringToFile,
   ImageURLToFile,
-  getFileFromEvent,
-  createFile,
-  normalizeFile
+  getFilesFromEvent,
+  normalizeFile,
+  renderSpreadsheet,
+  probablySupportsClipboardWriteText,
+  probablySupportsClipboardBlob,
+  createPasteEvent,
+  copyToClipboard,
+  readSystemClipboard,
+  parseClipboard,
+  copyBlobToClipboardAsPng,
+  copyTextToSystemClipboard
 };
-//# sourceMappingURL=chunk-GZYPVQVV.js.map
+//# sourceMappingURL=chunk-WQARCR2O.js.map