@vuu-ui/vuu-utils 0.8.8-debug → 0.8.9-debug

package/cjs/index.js

@@ -48,6 +48,7 @@ __export(src_exports, {
   Home: () => Home,
   KeySet: () => KeySet,
   MEASURES: () => MEASURES,
+  NULL_RANGE: () => NULL_RANGE,
   PageDown: () => PageDown,
   PageUp: () => PageUp,
   RangeMonitor: () => RangeMonitor,
@@ -58,18 +59,21 @@ __export(src_exports, {
   UP2: () => UP2,
   WindowRange: () => WindowRange,
   actualRowPositioning: () => actualRowPositioning,
+  addColumnToSubscribedColumns: () => addColumnToSubscribedColumns,
   addGroupColumn: () => addGroupColumn,
   addSortColumn: () => addSortColumn,
   applyFilterToColumns: () => applyFilterToColumns,
   applyGroupByToColumns: () => applyGroupByToColumns,
   applySort: () => applySort,
   applySortToColumns: () => applySortToColumns,
+  boxContainsPoint: () => boxContainsPoint,
   buildColumnMap: () => buildColumnMap,
   createEl: () => createEl,
   dateFormatter: () => dateFormatter,
   debounce: () => debounce,
   defaultValueFormatter: () => defaultValueFormatter,
   deselectItem: () => deselectItem,
+  dispatchMouseEvent: () => dispatchMouseEvent,
   expandSelection: () => expandSelection,
   extractFilterForColumn: () => extractFilterForColumn,
   extractGroupColumn: () => extractGroupColumn,
@@ -79,12 +83,23 @@ __export(src_exports, {
   focusFirstFocusableElement: () => focusFirstFocusableElement,
   formatDate: () => formatDate,
   fromServerDataType: () => fromServerDataType,
+  getCalculatedColumnDetails: () => getCalculatedColumnDetails,
+  getCalculatedColumnExpression: () => getCalculatedColumnExpression,
+  getCalculatedColumnName: () => getCalculatedColumnName,
+  getCalculatedColumnType: () => getCalculatedColumnType,
   getCellConfigPanelRenderer: () => getCellConfigPanelRenderer,
   getCellRenderer: () => getCellRenderer,
+  getClosest: () => getClosest,
+  getClosestIndexItem: () => getClosestIndexItem,
   getColumnName: () => getColumnName,
   getColumnStyle: () => getColumnStyle,
   getColumnsInViewport: () => getColumnsInViewport,
   getCookieValue: () => getCookieValue,
+  getDefaultAlignment: () => getDefaultAlignment,
+  getDefaultColumnType: () => getDefaultColumnType,
+  getEditRuleValidator: () => getEditRuleValidator,
+  getElementByDataIndex: () => getElementByDataIndex,
+  getElementDataIndex: () => getElementDataIndex,
   getFocusableElement: () => getFocusableElement,
   getFullRange: () => getFullRange,
   getGroupValueAndOffset: () => getGroupValueAndOffset,
@@ -92,17 +107,22 @@ __export(src_exports, {
   getMovingValueDirection: () => getMovingValueDirection,
   getRegisteredCellRenderers: () => getRegisteredCellRenderers,
   getRowRecord: () => getRowRecord,
+  getScrollbarSize: () => getScrollbarSize,
   getSelectionStatus: () => getSelectionStatus,
   getTableHeadings: () => getTableHeadings,
+  getTypeSettingsFromColumn: () => getTypeSettingsFromColumn,
   getUniqueId: () => getUniqueId,
   getUrlParameter: () => getUrlParameter,
   getValueFormatter: () => getValueFormatter,
   hasHeadings: () => hasHeadings,
   hasUrlParameter: () => hasUrlParameter,
+  hasValidationRules: () => hasValidationRules,
   invariant: () => invariant,
   isAndFilter: () => isAndFilter,
+  isCalculatedColumn: () => isCalculatedColumn,
   isCharacterKey: () => isCharacterKey,
   isColumnTypeRenderer: () => isColumnTypeRenderer,
+  isCompleteFilter: () => isCompleteFilter,
   isDataLoading: () => isDataLoading,
   isDateColumn: () => isDateColumn,
   isDatePattern: () => isDatePattern,
@@ -127,6 +147,7 @@ __export(src_exports, {
   isQuoteKey: () => isQuoteKey,
   isResizing: () => isResizing,
   isRowSelected: () => isRowSelected,
+  isSelectableElement: () => isSelectableElement,
   isSelected: () => isSelected,
   isSimpleColumnType: () => isSimpleColumnType,
   isSingleValueFilter: () => isSingleValueFilter,
@@ -134,8 +155,10 @@ __export(src_exports, {
   isTimeColumn: () => isTimeColumn,
   isTimePattern: () => isTimePattern,
   isTypeDescriptor: () => isTypeDescriptor,
+  isValidColumnAlignment: () => isValidColumnAlignment,
   isValidFilterClauseOp: () => isValidFilterClauseOp,
   isValidNumber: () => isValidNumber,
+  isValidPinLocation: () => isValidPinLocation,
   itemToString: () => itemToString,
   itemsChanged: () => itemsChanged,
   itemsOrOrderChanged: () => itemsOrOrderChanged,
@@ -145,6 +168,7 @@ __export(src_exports, {
   mapSortCriteria: () => mapSortCriteria,
   metadataKeys: () => metadataKeys,
   moveItem: () => moveItem,
+  moveItemDeprecated: () => moveItemDeprecated,
   notHidden: () => notHidden,
   numericFormatter: () => numericFormatter,
   partition: () => partition,
@@ -156,18 +180,26 @@ __export(src_exports, {
   roundDecimal: () => roundDecimal,
   selectItem: () => selectItem,
   setAggregations: () => setAggregations,
+  setCalculatedColumnExpression: () => setCalculatedColumnExpression,
+  setCalculatedColumnName: () => setCalculatedColumnName,
+  setCalculatedColumnType: () => setCalculatedColumnType,
   setSortColumn: () => setSortColumn,
   shallowEquals: () => shallowEquals,
   sortPinnedColumns: () => sortPinnedColumns,
   stripFilterFromColumns: () => stripFilterFromColumns,
+  subscribedOnly: () => subscribedOnly,
+  takeScreenshot: () => takeScreenshot,
   throttle: () => throttle,
   toColumnDescriptor: () => toColumnDescriptor,
   toDataSourceColumns: () => toDataSourceColumns,
   updateColumn: () => updateColumn,
+  updateColumnRenderer: () => updateColumnRenderer,
+  updateColumnType: () => updateColumnType,
   uuid: () => uuid,
   virtualRowPositioning: () => virtualRowPositioning,
   visibleColumnAtIndex: () => visibleColumnAtIndex,
-  withinRange: () => withinRange
+  withinRange: () => withinRange,
+  wordify: () => wordify
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -204,7 +236,7 @@ function itemsOrOrderChanged(currentItems, newItems, identityProperty) {
     );
   }
 }
-var moveItem = (items, item, moveTo) => {
+var moveItemDeprecated = (items, item, moveTo) => {
   const fromIndex = items.indexOf(item);
   if (fromIndex === moveTo) {
     return items;
@@ -222,6 +254,28 @@ var moveItem = (items, item, moveTo) => {
   }
   return newItems;
 };
+var moveItem = (items, fromIndex, toIndex) => {
+  if (fromIndex === toIndex) {
+    return items;
+  } else {
+    const newItems = items.slice();
+    const [item] = newItems.splice(fromIndex, 1);
+    if (toIndex === -1) {
+      return newItems.concat(item);
+    } else {
+      const offset = toIndex > fromIndex ? 0 : 0;
+      newItems.splice(toIndex + offset, 0, item);
+      return newItems;
+    }
+  }
+};
+
+// src/box-utils.ts
+function boxContainsPoint(rect, x, y) {
+  if (rect) {
+    return x >= rect.left && x < rect.right && y >= rect.top && y < rect.bottom;
+  }
+}
 
 // src/filter-utils.ts
 var singleValueFilterOps = /* @__PURE__ */ new Set([
@@ -242,6 +296,7 @@ var isMultiValueFilter = (f) => f !== void 0 && f.op === "in";
 var isInFilter = (f) => f.op === "in";
 var isAndFilter = (f) => f.op === "and";
 var isOrFilter = (f) => f.op === "or";
+var isCompleteFilter = (filter) => isSingleValueFilter(filter) && filter.column !== void 0 && filter.op !== void 0 && filter.value !== void 0;
 function isMultiClauseFilter(f) {
   return f !== void 0 && (f.op === "and" || f.op === "or");
 }
@@ -291,6 +346,10 @@ function mapSortCriteria(sortCriteria, columnMap, metadataOffset = 0) {
     }
   });
 }
+var numericTypes = ["int", "long", "double"];
+var getDefaultAlignment = (serverDataType) => serverDataType === void 0 ? "left" : numericTypes.includes(serverDataType) ? "right" : "left";
+var isValidColumnAlignment = (v) => v === "left" || v === "right";
+var isValidPinLocation = (v) => isValidColumnAlignment(v) || v === "floating";
 var isKeyedColumn = (column) => {
   return typeof column.key === "number";
 };
@@ -335,6 +394,7 @@ var isSimpleColumnType = (value) => typeof value === "string" && ["string", "num
 var isTypeDescriptor = (type) => typeof type !== "undefined" && typeof type !== "string";
 var EMPTY_COLUMN_MAP = {};
 var isColumnTypeRenderer = (renderer) => typeof (renderer == null ? void 0 : renderer.name) !== "undefined";
+var hasValidationRules = (type) => isTypeDescriptor(type) && isColumnTypeRenderer(type.renderer) && Array.isArray(type.renderer.rules) && type.renderer.rules.length > 0;
 var isMappedValueTypeRenderer = (renderer) => renderer !== void 0 && typeof (renderer == null ? void 0 : renderer.map) !== "undefined";
 function buildColumnMap(columns) {
   const start = metadataKeys.count;
@@ -342,7 +402,7 @@ function buildColumnMap(columns) {
     return columns.reduce((map, column, i) => {
       if (typeof column === "string") {
         map[column] = start + i;
-      } else if (typeof column.key === "number") {
+      } else if (isKeyedColumn(column)) {
         map[column.name] = column.key;
       } else {
         map[column.name] = start + i;
@@ -548,7 +608,7 @@ var getColumnStyle = ({
 }) => pin === "left" ? {
   left: pinnedOffset,
   width,
-  "--pin-width": `${pinnedOffset + width - 5}px`
+  "--pin-width": `${pinnedOffset + width - 3}px`
 } : pin === "right" ? {
   right: pinnedOffset,
   width,
@@ -736,6 +796,155 @@ var getGroupValueAndOffset = (columns, row) => {
     return [value, depth - 1];
   }
 };
+var getDefaultColumnType = (serverDataType) => {
+  switch (serverDataType) {
+    case "int":
+    case "long":
+    case "double":
+      return "number";
+    case "boolean":
+      return "boolean";
+    default:
+      return "string";
+  }
+};
+var updateColumnType = (column, formatting) => {
+  const { serverDataType, type = getDefaultColumnType(serverDataType) } = column;
+  if (typeof type === "string" || type === void 0) {
+    return {
+      ...column,
+      type: {
+        name: type,
+        formatting
+      }
+    };
+  } else {
+    return {
+      ...column,
+      type: {
+        ...type,
+        formatting
+      }
+    };
+  }
+};
+var updateColumnRenderer = (column, cellRenderer) => {
+  const { serverDataType, type } = column;
+  if (type === void 0) {
+    return {
+      ...column,
+      type: {
+        name: getDefaultColumnType(serverDataType),
+        renderer: {
+          name: cellRenderer.name
+        }
+      }
+    };
+  } else if (isSimpleColumnType(type)) {
+    return {
+      ...column,
+      type: {
+        name: type,
+        renderer: {
+          name: cellRenderer.name
+        }
+      }
+    };
+  } else {
+    return {
+      ...column,
+      type: {
+        ...type,
+        renderer: {
+          name: cellRenderer.name
+        }
+      }
+    };
+  }
+};
+var NO_TYPE_SETTINGS = {};
+var getTypeSettingsFromColumn = (column) => {
+  var _a;
+  if (isTypeDescriptor(column.type)) {
+    return (_a = column.type.formatting) != null ? _a : NO_TYPE_SETTINGS;
+  } else {
+    return NO_TYPE_SETTINGS;
+  }
+};
+var subscribedOnly = (columnNames) => (column) => columnNames == null ? void 0 : columnNames.includes(column.name);
+var addColumnToSubscribedColumns = (subscribedColumns, availableColumns, columnName) => {
+  const byColName = (n = columnName) => (column) => column.name === n;
+  if (subscribedColumns.findIndex(byColName()) !== -1) {
+    throw Error(
+      `column-utils, addColumnToSubscribedColumns column ${columnName} is already subscribed`
+    );
+  }
+  const indexOfAvailableColumn = availableColumns.findIndex(byColName());
+  if (indexOfAvailableColumn === -1) {
+    throw Error(
+      `column-utils, addColumnToSubscribedColumns column ${columnName} is not available`
+    );
+  }
+  const newColumn = {
+    ...availableColumns[indexOfAvailableColumn]
+  };
+  let index = -1;
+  for (let i = indexOfAvailableColumn - 1; i >= 0; i--) {
+    const { name } = availableColumns[i];
+    index = subscribedColumns.findIndex(byColName(name));
+    if (index !== -1) {
+      break;
+    }
+  }
+  if (index === -1) {
+    return [newColumn].concat(subscribedColumns);
+  } else {
+    const results = [];
+    for (let i = 0; i < subscribedColumns.length; i++) {
+      results.push(subscribedColumns[i]);
+      if (i === index) {
+        results.push(newColumn);
+        index = Number.MAX_SAFE_INTEGER;
+      }
+    }
+    return results;
+  }
+};
+var CalculatedColumnPattern = /.*:.*:.*/;
+var isCalculatedColumn = (columnName) => columnName !== void 0 && CalculatedColumnPattern.test(columnName);
+var getCalculatedColumnDetails = (column) => {
+  if (isCalculatedColumn(column.name)) {
+    return column.name.split(":");
+  } else {
+    throw Error(
+      `column-utils, getCalculatedColumnDetails column name ${column.name} is not valid calculated column`
+    );
+  }
+};
+var getCalculatedColumnName = (column) => getCalculatedColumnDetails(column)[0];
+var getCalculatedColumnExpression = (column) => getCalculatedColumnDetails(column)[1];
+var getCalculatedColumnType = (column) => getCalculatedColumnDetails(column)[2];
+var setCalculatedColumnName = (column, name) => {
+  const [, expression, type] = column.name.split(":");
+  return {
+    ...column,
+    name: `${name}:${expression}:${type}`
+  };
+};
+var setCalculatedColumnExpression = (column, expression) => {
+  const [name, , type] = column.name.split(":");
+  return {
+    ...column,
+    name: `${name}:${expression}:${type}`
+  };
+};
+var setCalculatedColumnType = (column, type) => {
+  const [name, expression] = column.name.split(":");
+  return {
+    ...column,
+    name: `${name}:${expression}:${type}`
+  };
+};
 
 // src/cookie-utils.ts
 var getCookieValue = (name) => {
@@ -748,9 +957,10 @@ var getCookieValue = (name) => {
 // src/component-registry.ts
 var cellRenderersMap = /* @__PURE__ */ new Map();
 var cellConfigPanelsMap = /* @__PURE__ */ new Map();
+var editRuleValidatorsMap = /* @__PURE__ */ new Map();
 var optionsMap = /* @__PURE__ */ new Map();
 var isTypeCompatible = (rendererType, serverDataType) => {
-  if (rendererType === void 0) {
+  if (rendererType === void 0 || rendererType === "private") {
     return true;
   } else if (Array.isArray(rendererType)) {
     return rendererType.includes(serverDataType);
@@ -760,11 +970,14 @@ var isTypeCompatible = (rendererType, serverDataType) => {
 };
 var isCellRenderer = (type, component) => type === "cell-renderer";
 var isCellConfigPanel = (type, component) => type === "cell-config-panel";
+var isEditRuleValidator = (type, component) => type === "data-edit-validator";
 function registerComponent(componentName, component, type = "cell-renderer", options) {
   if (isCellRenderer(type, component)) {
     cellRenderersMap.set(componentName, component);
   } else if (isCellConfigPanel(type, component)) {
     cellConfigPanelsMap.set(componentName, component);
+  } else if (isEditRuleValidator(type, component)) {
+    editRuleValidatorsMap.set(componentName, component);
   }
   if (options) {
     optionsMap.set(componentName, options);
@@ -792,8 +1005,12 @@ function getCellRenderer(renderer) {
 function getCellConfigPanelRenderer(name) {
   return cellConfigPanelsMap.get(name);
 }
+function getEditRuleValidator(name) {
+  return editRuleValidatorsMap.get(name);
+}
 
 // src/range-utils.ts
+var NULL_RANGE = { from: 0, to: 0 };
 function getFullRange({ from, to }, bufferSize = 0, rowCount = Number.MAX_SAFE_INTEGER) {
   if (bufferSize === 0) {
     if (rowCount < from) {
@@ -945,6 +1162,9 @@ var shallowEquals = (o1 = EMPTY, o2 = EMPTY) => {
   return props1.length === props2.length && props1.every((key) => o1[key] === o2[key]);
 };
 function getMovingValueDirection(newValue, direction, prevValue, decimalPlaces) {
+  if (newValue === void 0) {
+    return "";
+  }
   if (!isFinite(newValue) || prevValue === void 0 || direction === void 0) {
     return "";
   } else {
@@ -1107,6 +1327,34 @@ var getFocusableElement = (el, tabIndex) => {
     }
   }
 };
+var getElementDataIndex = (el) => {
+  if (el) {
+    const index = parseInt(el.dataset.index || "");
+    if (!isNaN(index)) {
+      return index;
+    }
+  }
+  return -1;
+};
+var getClosest = (el, dataProperty) => el.closest(`[data-${dataProperty}]`);
+var getClosestIndexItem = (el) => getClosest(el, "index");
+function getElementByDataIndex(container, index, throwIfNotFound = false) {
+  if (container === null && throwIfNotFound) {
+    throw Error("html-utils getElementByDataIndex, container is null");
+  }
+  const element = container == null ? void 0 : container.querySelector(
+    `[data-index="${index}"]`
+  );
+  if (element) {
+    return element;
+  } else if (throwIfNotFound) {
+    throw Error(
+      "html-utils getElementByDataIndex, Item not found with data-index='${index}'"
+    );
+  } else {
+    return void 0;
+  }
+}
 var focusFirstFocusableElement = (el, tabIndex) => {
   requestAnimationFrame(() => {
     const focusableElement = getFocusableElement(el, tabIndex);
@@ -1115,6 +1363,46 @@ var focusFirstFocusableElement = (el, tabIndex) => {
     }
   });
 };
+var isSelectableElement = (el) => {
+  const item = el == null ? void 0 : el.closest("[data-index]");
+  if (!item || item.ariaDisabled || item.dataset.selectable === "false" || item.querySelector('[data-selectable="false"],[aria-disabled="true"]')) {
+    return false;
+  } else {
+    return true;
+  }
+};
+var size;
+function getScrollbarSize() {
+  if (size === void 0) {
+    let outer = document.createElement("div");
+    outer.className = "scrollable-content";
+    outer.style.width = "50px";
+    outer.style.height = "50px";
+    outer.style.overflowY = "scroll";
+    outer.style.position = "absolute";
+    outer.style.top = "-200px";
+    outer.style.left = "-200px";
+    const inner = document.createElement("div");
+    inner.style.height = "100px";
+    inner.style.width = "100%";
+    outer.appendChild(inner);
+    document.body.appendChild(outer);
+    const outerWidth = outer.offsetWidth;
+    const innerWidth = inner.offsetWidth;
+    document.body.removeChild(outer);
+    size = outerWidth - innerWidth;
+    outer = null;
+  }
+  return size;
+}
+var dispatchMouseEvent = (el, type) => {
+  const evt = new MouseEvent(type, {
+    view: window,
+    bubbles: true,
+    cancelable: true
+  });
+  el.dispatchEvent(evt);
+};
 
 // src/event-emitter.ts
 function isArrayOfListeners(listeners) {
@@ -1369,47 +1657,7 @@ function addGroupColumn(groupBy, column) {
 }
 
 // src/input-utils.ts
-var actionKeys = {
-  Enter: "Enter",
-  Delete: "Delete"
-};
-var navigationKeys = {
-  Home: "Home",
-  End: "End",
-  ArrowRight: "ArrowRight",
-  ArrowLeft: "ArrowLeft",
-  ArrowDown: "ArrowDown",
-  ArrowUp: "ArrowUp",
-  Tab: "Tab"
-};
-var functionKeys = {
-  F1: "F1",
-  F2: "F2",
-  F3: "F3",
-  F4: "F4",
-  F5: "F5",
-  F6: "F6",
-  F7: "F7",
-  F8: "F8",
-  F9: "F9",
-  F10: "F10",
-  F11: "F11",
-  F12: "F12"
-};
-var specialKeys = {
-  ...actionKeys,
-  ...navigationKeys,
-  ...functionKeys
-};
-var isSpecialKey = (key) => key in specialKeys;
-var isCharacterKey = (evt) => {
-  if (isSpecialKey(evt.key)) {
-    return false;
-  }
-  if (typeof evt.which === "number" && evt.which > 0) {
-    return !evt.ctrlKey && !evt.metaKey && !evt.altKey && evt.which !== 8;
-  }
-};
+var isCharacterKey = (key) => key.length === 1;
 var isQuoteKey = (evt) => {
   return evt.key === '"' || evt.key === "'";
 };
@@ -1561,9 +1809,9 @@ var KeySet = class {
         this.keys.delete(rowIndex);
       }
     });
-    const size = to - from;
-    if (this.keys.size + this.free.length > size) {
-      this.free.length = Math.max(0, size - this.keys.size);
+    const size2 = to - from;
+    if (this.keys.size + this.free.length > size2) {
+      this.free.length = Math.max(0, size2 - this.keys.size);
     }
     for (let rowIndex = from; rowIndex < to; rowIndex++) {
       if (!this.keys.has(rowIndex)) {
@@ -1595,11 +1843,11 @@ var KeySet = class {
 var isGroupMenuItemDescriptor = (menuItem) => menuItem !== void 0 && "children" in menuItem;
 
 // src/nanoid/index.ts
-var uuid = (size = 21) => {
+var uuid = (size2 = 21) => {
   let id = "";
-  let bytes = crypto.getRandomValues(new Uint8Array(size));
-  while (size--) {
-    let byte = bytes[size] & 63;
+  let bytes = crypto.getRandomValues(new Uint8Array(size2));
+  while (size2--) {
+    let byte = bytes[size2] & 63;
     if (byte < 36) {
       id += byte.toString(36);
     } else if (byte < 62) {
@@ -1939,6 +2187,12 @@ var lastWord = (text) => {
     return trimmedText.slice(pos + 1);
   }
 };
+var capitalize = (text) => text.length === 0 ? "" : text[0].toUpperCase() + text.slice(1);
+var regexp_worfify = /(?<!(^|[A-Z]))(?=[A-Z])|(?<!^)(?=[A-Z][a-z])/;
+var wordify = (text) => {
+  const [firstWord, ...rest] = text.split(regexp_worfify);
+  return `${capitalize(firstWord)} ${rest.join(" ")}`;
+};
 
 // src/url-utils.ts
 var getUrlParameter = (paramName, defaultValue) => {
@@ -1946,4 +2200,771 @@ var getUrlParameter = (paramName, defaultValue) => {
   return (_a = new URL(document.location.href).searchParams.get(paramName)) != null ? _a : defaultValue;
 };
 var hasUrlParameter = (paramName) => new URL(document.location.href).searchParams.has(paramName);
+
+// ../../node_modules/html-to-image/es/util.js
+function resolveUrl(url, baseUrl) {
+  if (url.match(/^[a-z]+:\/\//i)) {
+    return url;
+  }
+  if (url.match(/^\/\//)) {
+    return window.location.protocol + url;
+  }
+  if (url.match(/^[a-z]+:/i)) {
+    return url;
+  }
+  const doc = document.implementation.createHTMLDocument();
+  const base = doc.createElement("base");
+  const a = doc.createElement("a");
+  doc.head.appendChild(base);
+  doc.body.appendChild(a);
+  if (baseUrl) {
+    base.href = baseUrl;
+  }
+  a.href = url;
+  return a.href;
+}
+var uuid2 = (() => {
+  let counter = 0;
+  const random = () => (
+    // eslint-disable-next-line no-bitwise
+    `0000${(Math.random() * 36 ** 4 << 0).toString(36)}`.slice(-4)
+  );
+  return () => {
+    counter += 1;
+    return `u${random()}${counter}`;
+  };
+})();
+function toArray(arrayLike) {
+  const arr = [];
+  for (let i = 0, l = arrayLike.length; i < l; i++) {
+    arr.push(arrayLike[i]);
+  }
+  return arr;
+}
+function px(node, styleProperty) {
+  const win = node.ownerDocument.defaultView || window;
+  const val = win.getComputedStyle(node).getPropertyValue(styleProperty);
+  return val ? parseFloat(val.replace("px", "")) : 0;
+}
+function getNodeWidth(node) {
+  const leftBorder = px(node, "border-left-width");
+  const rightBorder = px(node, "border-right-width");
+  return node.clientWidth + leftBorder + rightBorder;
+}
+function getNodeHeight(node) {
+  const topBorder = px(node, "border-top-width");
+  const bottomBorder = px(node, "border-bottom-width");
+  return node.clientHeight + topBorder + bottomBorder;
+}
+function getImageSize(targetNode, options = {}) {
+  const width = options.width || getNodeWidth(targetNode);
+  const height = options.height || getNodeHeight(targetNode);
+  return { width, height };
+}
+function getPixelRatio() {
+  let ratio;
+  let FINAL_PROCESS;
+  try {
+    FINAL_PROCESS = process;
+  } catch (e) {
+  }
+  const val = FINAL_PROCESS && FINAL_PROCESS.env ? FINAL_PROCESS.env.devicePixelRatio : null;
+  if (val) {
+    ratio = parseInt(val, 10);
+    if (Number.isNaN(ratio)) {
+      ratio = 1;
+    }
+  }
+  return ratio || window.devicePixelRatio || 1;
+}
+var canvasDimensionLimit = 16384;
+function checkCanvasDimensions(canvas) {
+  if (canvas.width > canvasDimensionLimit || canvas.height > canvasDimensionLimit) {
+    if (canvas.width > canvasDimensionLimit && canvas.height > canvasDimensionLimit) {
+      if (canvas.width > canvas.height) {
+        canvas.height *= canvasDimensionLimit / canvas.width;
+        canvas.width = canvasDimensionLimit;
+      } else {
+        canvas.width *= canvasDimensionLimit / canvas.height;
+        canvas.height = canvasDimensionLimit;
+      }
+    } else if (canvas.width > canvasDimensionLimit) {
+      canvas.height *= canvasDimensionLimit / canvas.width;
+      canvas.width = canvasDimensionLimit;
+    } else {
+      canvas.width *= canvasDimensionLimit / canvas.height;
+      canvas.height = canvasDimensionLimit;
+    }
+  }
+}
+function createImage(url) {
+  return new Promise((resolve, reject) => {
+    const img = new Image();
+    img.decode = () => resolve(img);
+    img.onload = () => resolve(img);
+    img.onerror = reject;
+    img.crossOrigin = "anonymous";
+    img.decoding = "async";
+    img.src = url;
+  });
+}
+async function svgToDataURL(svg) {
+  return Promise.resolve().then(() => new XMLSerializer().serializeToString(svg)).then(encodeURIComponent).then((html) => `data:image/svg+xml;charset=utf-8,${html}`);
+}
+async function nodeToDataURL(node, width, height) {
+  const xmlns = "http://www.w3.org/2000/svg";
+  const svg = document.createElementNS(xmlns, "svg");
+  const foreignObject = document.createElementNS(xmlns, "foreignObject");
+  svg.setAttribute("width", `${width}`);
+  svg.setAttribute("height", `${height}`);
+  svg.setAttribute("viewBox", `0 0 ${width} ${height}`);
+  foreignObject.setAttribute("width", "100%");
+  foreignObject.setAttribute("height", "100%");
+  foreignObject.setAttribute("x", "0");
+  foreignObject.setAttribute("y", "0");
+  foreignObject.setAttribute("externalResourcesRequired", "true");
+  svg.appendChild(foreignObject);
+  foreignObject.appendChild(node);
+  return svgToDataURL(svg);
+}
+var isInstanceOfElement = (node, instance) => {
+  if (node instanceof instance)
+    return true;
+  const nodePrototype = Object.getPrototypeOf(node);
+  if (nodePrototype === null)
+    return false;
+  return nodePrototype.constructor.name === instance.name || isInstanceOfElement(nodePrototype, instance);
+};
+
+// ../../node_modules/html-to-image/es/clone-pseudos.js
+function formatCSSText(style) {
+  const content = style.getPropertyValue("content");
+  return `${style.cssText} content: '${content.replace(/'|"/g, "")}';`;
+}
+function formatCSSProperties(style) {
+  return toArray(style).map((name) => {
+    const value = style.getPropertyValue(name);
+    const priority = style.getPropertyPriority(name);
+    return `${name}: ${value}${priority ? " !important" : ""};`;
+  }).join(" ");
+}
+function getPseudoElementStyle(className, pseudo, style) {
+  const selector = `.${className}:${pseudo}`;
+  const cssText = style.cssText ? formatCSSText(style) : formatCSSProperties(style);
+  return document.createTextNode(`${selector}{${cssText}}`);
+}
+function clonePseudoElement(nativeNode, clonedNode, pseudo) {
+  const style = window.getComputedStyle(nativeNode, pseudo);
+  const content = style.getPropertyValue("content");
+  if (content === "" || content === "none") {
+    return;
+  }
+  const className = uuid2();
+  try {
+    clonedNode.className = `${clonedNode.className} ${className}`;
+  } catch (err) {
+    return;
+  }
+  const styleElement = document.createElement("style");
+  styleElement.appendChild(getPseudoElementStyle(className, pseudo, style));
+  clonedNode.appendChild(styleElement);
+}
+function clonePseudoElements(nativeNode, clonedNode) {
+  clonePseudoElement(nativeNode, clonedNode, ":before");
+  clonePseudoElement(nativeNode, clonedNode, ":after");
+}
+
+// ../../node_modules/html-to-image/es/mimes.js
+var WOFF = "application/font-woff";
+var JPEG = "image/jpeg";
+var mimes = {
+  woff: WOFF,
+  woff2: WOFF,
+  ttf: "application/font-truetype",
+  eot: "application/vnd.ms-fontobject",
+  png: "image/png",
+  jpg: JPEG,
+  jpeg: JPEG,
+  gif: "image/gif",
+  tiff: "image/tiff",
+  svg: "image/svg+xml",
+  webp: "image/webp"
+};
+function getExtension(url) {
+  const match = /\.([^./]*?)$/g.exec(url);
+  return match ? match[1] : "";
+}
+function getMimeType(url) {
+  const extension = getExtension(url).toLowerCase();
+  return mimes[extension] || "";
+}
+
+// ../../node_modules/html-to-image/es/dataurl.js
+function getContentFromDataUrl(dataURL) {
+  return dataURL.split(/,/)[1];
+}
+function isDataUrl(url) {
+  return url.search(/^(data:)/) !== -1;
+}
+function makeDataUrl(content, mimeType) {
+  return `data:${mimeType};base64,${content}`;
+}
+async function fetchAsDataURL(url, init, process2) {
+  const res = await fetch(url, init);
+  if (res.status === 404) {
+    throw new Error(`Resource "${res.url}" not found`);
+  }
+  const blob = await res.blob();
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onerror = reject;
+    reader.onloadend = () => {
+      try {
+        resolve(process2({ res, result: reader.result }));
+      } catch (error) {
+        reject(error);
+      }
+    };
+    reader.readAsDataURL(blob);
+  });
+}
+var cache = {};
+function getCacheKey(url, contentType, includeQueryParams) {
+  let key = url.replace(/\?.*/, "");
+  if (includeQueryParams) {
+    key = url;
+  }
+  if (/ttf|otf|eot|woff2?/i.test(key)) {
+    key = key.replace(/.*\//, "");
+  }
+  return contentType ? `[${contentType}]${key}` : key;
+}
+async function resourceToDataURL(resourceUrl, contentType, options) {
+  const cacheKey = getCacheKey(resourceUrl, contentType, options.includeQueryParams);
+  if (cache[cacheKey] != null) {
+    return cache[cacheKey];
+  }
+  if (options.cacheBust) {
+    resourceUrl += (/\?/.test(resourceUrl) ? "&" : "?") + (/* @__PURE__ */ new Date()).getTime();
+  }
+  let dataURL;
+  try {
+    const content = await fetchAsDataURL(resourceUrl, options.fetchRequestInit, ({ res, result }) => {
+      if (!contentType) {
+        contentType = res.headers.get("Content-Type") || "";
+      }
+      return getContentFromDataUrl(result);
+    });
+    dataURL = makeDataUrl(content, contentType);
+  } catch (error) {
+    dataURL = options.imagePlaceholder || "";
+    let msg = `Failed to fetch resource: ${resourceUrl}`;
+    if (error) {
+      msg = typeof error === "string" ? error : error.message;
+    }
+    if (msg) {
+      console.warn(msg);
+    }
+  }
+  cache[cacheKey] = dataURL;
+  return dataURL;
+}
+
+// ../../node_modules/html-to-image/es/clone-node.js
+async function cloneCanvasElement(canvas) {
+  const dataURL = canvas.toDataURL();
+  if (dataURL === "data:,") {
+    return canvas.cloneNode(false);
+  }
+  return createImage(dataURL);
+}
+async function cloneVideoElement(video, options) {
+  if (video.currentSrc) {
+    const canvas = document.createElement("canvas");
+    const ctx = canvas.getContext("2d");
+    canvas.width = video.clientWidth;
+    canvas.height = video.clientHeight;
+    ctx === null || ctx === void 0 ? void 0 : ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
+    const dataURL2 = canvas.toDataURL();
+    return createImage(dataURL2);
+  }
+  const poster = video.poster;
+  const contentType = getMimeType(poster);
+  const dataURL = await resourceToDataURL(poster, contentType, options);
+  return createImage(dataURL);
+}
+async function cloneIFrameElement(iframe) {
+  var _a;
+  try {
+    if ((_a = iframe === null || iframe === void 0 ? void 0 : iframe.contentDocument) === null || _a === void 0 ? void 0 : _a.body) {
+      return await cloneNode(iframe.contentDocument.body, {}, true);
+    }
+  } catch (_b) {
+  }
+  return iframe.cloneNode(false);
+}
+async function cloneSingleNode(node, options) {
+  if (isInstanceOfElement(node, HTMLCanvasElement)) {
+    return cloneCanvasElement(node);
+  }
+  if (isInstanceOfElement(node, HTMLVideoElement)) {
+    return cloneVideoElement(node, options);
+  }
+  if (isInstanceOfElement(node, HTMLIFrameElement)) {
+    return cloneIFrameElement(node);
+  }
+  return node.cloneNode(false);
+}
+var isSlotElement = (node) => node.tagName != null && node.tagName.toUpperCase() === "SLOT";
+async function cloneChildren(nativeNode, clonedNode, options) {
+  var _a, _b;
+  let children = [];
+  if (isSlotElement(nativeNode) && nativeNode.assignedNodes) {
+    children = toArray(nativeNode.assignedNodes());
+  } else if (isInstanceOfElement(nativeNode, HTMLIFrameElement) && ((_a = nativeNode.contentDocument) === null || _a === void 0 ? void 0 : _a.body)) {
+    children = toArray(nativeNode.contentDocument.body.childNodes);
+  } else {
+    children = toArray(((_b = nativeNode.shadowRoot) !== null && _b !== void 0 ? _b : nativeNode).childNodes);
+  }
+  if (children.length === 0 || isInstanceOfElement(nativeNode, HTMLVideoElement)) {
+    return clonedNode;
+  }
+  await children.reduce((deferred, child) => deferred.then(() => cloneNode(child, options)).then((clonedChild) => {
+    if (clonedChild) {
+      clonedNode.appendChild(clonedChild);
+    }
+  }), Promise.resolve());
+  return clonedNode;
+}
+function cloneCSSStyle(nativeNode, clonedNode) {
+  const targetStyle = clonedNode.style;
+  if (!targetStyle) {
+    return;
+  }
+  const sourceStyle = window.getComputedStyle(nativeNode);
+  if (sourceStyle.cssText) {
+    targetStyle.cssText = sourceStyle.cssText;
+    targetStyle.transformOrigin = sourceStyle.transformOrigin;
+  } else {
+    toArray(sourceStyle).forEach((name) => {
+      let value = sourceStyle.getPropertyValue(name);
+      if (name === "font-size" && value.endsWith("px")) {
+        const reducedFont = Math.floor(parseFloat(value.substring(0, value.length - 2))) - 0.1;
+        value = `${reducedFont}px`;
+      }
+      if (isInstanceOfElement(nativeNode, HTMLIFrameElement) && name === "display" && value === "inline") {
+        value = "block";
+      }
+      if (name === "d" && clonedNode.getAttribute("d")) {
+        value = `path(${clonedNode.getAttribute("d")})`;
+      }
+      targetStyle.setProperty(name, value, sourceStyle.getPropertyPriority(name));
+    });
+  }
+}
+function cloneInputValue(nativeNode, clonedNode) {
+  if (isInstanceOfElement(nativeNode, HTMLTextAreaElement)) {
+    clonedNode.innerHTML = nativeNode.value;
+  }
+  if (isInstanceOfElement(nativeNode, HTMLInputElement)) {
+    clonedNode.setAttribute("value", nativeNode.value);
+  }
+}
+function cloneSelectValue(nativeNode, clonedNode) {
+  if (isInstanceOfElement(nativeNode, HTMLSelectElement)) {
+    const clonedSelect = clonedNode;
+    const selectedOption = Array.from(clonedSelect.children).find((child) => nativeNode.value === child.getAttribute("value"));
+    if (selectedOption) {
+      selectedOption.setAttribute("selected", "");
+    }
+  }
+}
+function decorate(nativeNode, clonedNode) {
+  if (isInstanceOfElement(clonedNode, Element)) {
+    cloneCSSStyle(nativeNode, clonedNode);
+    clonePseudoElements(nativeNode, clonedNode);
+    cloneInputValue(nativeNode, clonedNode);
+    cloneSelectValue(nativeNode, clonedNode);
+  }
+  return clonedNode;
+}
+async function ensureSVGSymbols(clone, options) {
+  const uses = clone.querySelectorAll ? clone.querySelectorAll("use") : [];
+  if (uses.length === 0) {
+    return clone;
+  }
+  const processedDefs = {};
+  for (let i = 0; i < uses.length; i++) {
+    const use = uses[i];
+    const id = use.getAttribute("xlink:href");
+    if (id) {
+      const exist = clone.querySelector(id);
+      const definition = document.querySelector(id);
+      if (!exist && definition && !processedDefs[id]) {
+        processedDefs[id] = await cloneNode(definition, options, true);
+      }
+    }
+  }
+  const nodes = Object.values(processedDefs);
+  if (nodes.length) {
+    const ns = "http://www.w3.org/1999/xhtml";
+    const svg = document.createElementNS(ns, "svg");
+    svg.setAttribute("xmlns", ns);
+    svg.style.position = "absolute";
+    svg.style.width = "0";
+    svg.style.height = "0";
+    svg.style.overflow = "hidden";
+    svg.style.display = "none";
+    const defs = document.createElementNS(ns, "defs");
+    svg.appendChild(defs);
+    for (let i = 0; i < nodes.length; i++) {
+      defs.appendChild(nodes[i]);
+    }
+    clone.appendChild(svg);
+  }
+  return clone;
+}
+async function cloneNode(node, options, isRoot) {
+  if (!isRoot && options.filter && !options.filter(node)) {
+    return null;
+  }
+  return Promise.resolve(node).then((clonedNode) => cloneSingleNode(clonedNode, options)).then((clonedNode) => cloneChildren(node, clonedNode, options)).then((clonedNode) => decorate(node, clonedNode)).then((clonedNode) => ensureSVGSymbols(clonedNode, options));
+}
+
+// ../../node_modules/html-to-image/es/embed-resources.js
+var URL_REGEX = /url\((['"]?)([^'"]+?)\1\)/g;
+var URL_WITH_FORMAT_REGEX = /url\([^)]+\)\s*format\((["']?)([^"']+)\1\)/g;
+var FONT_SRC_REGEX = /src:\s*(?:url\([^)]+\)\s*format\([^)]+\)[,;]\s*)+/g;
+function toRegex(url) {
+  const escaped = url.replace(/([.*+?^${}()|\[\]\/\\])/g, "\\$1");
+  return new RegExp(`(url\\(['"]?)(${escaped})(['"]?\\))`, "g");
+}
+function parseURLs(cssText) {
+  const urls = [];
+  cssText.replace(URL_REGEX, (raw, quotation, url) => {
+    urls.push(url);
+    return raw;
+  });
+  return urls.filter((url) => !isDataUrl(url));
+}
+async function embed(cssText, resourceURL, baseURL, options, getContentFromUrl) {
+  try {
+    const resolvedURL = baseURL ? resolveUrl(resourceURL, baseURL) : resourceURL;
+    const contentType = getMimeType(resourceURL);
+    let dataURL;
+    if (getContentFromUrl) {
+      const content = await getContentFromUrl(resolvedURL);
+      dataURL = makeDataUrl(content, contentType);
+    } else {
+      dataURL = await resourceToDataURL(resolvedURL, contentType, options);
+    }
+    return cssText.replace(toRegex(resourceURL), `$1${dataURL}$3`);
+  } catch (error) {
+  }
+  return cssText;
+}
+function filterPreferredFontFormat(str, { preferredFontFormat }) {
+  return !preferredFontFormat ? str : str.replace(FONT_SRC_REGEX, (match) => {
+    while (true) {
+      const [src, , format] = URL_WITH_FORMAT_REGEX.exec(match) || [];
+      if (!format) {
+        return "";
+      }
+      if (format === preferredFontFormat) {
+        return `src: ${src};`;
+      }
+    }
+  });
+}
+function shouldEmbed(url) {
+  return url.search(URL_REGEX) !== -1;
+}
+async function embedResources(cssText, baseUrl, options) {
+  if (!shouldEmbed(cssText)) {
+    return cssText;
+  }
+  const filteredCSSText = filterPreferredFontFormat(cssText, options);
+  const urls = parseURLs(filteredCSSText);
+  return urls.reduce((deferred, url) => deferred.then((css) => embed(css, url, baseUrl, options)), Promise.resolve(filteredCSSText));
+}
+
+// ../../node_modules/html-to-image/es/embed-images.js
+async function embedProp(propName, node, options) {
+  var _a;
+  const propValue = (_a = node.style) === null || _a === void 0 ? void 0 : _a.getPropertyValue(propName);
+  if (propValue) {
+    const cssString = await embedResources(propValue, null, options);
+    node.style.setProperty(propName, cssString, node.style.getPropertyPriority(propName));
+    return true;
+  }
+  return false;
+}
+async function embedBackground(clonedNode, options) {
+  if (!await embedProp("background", clonedNode, options)) {
+    await embedProp("background-image", clonedNode, options);
+  }
+  if (!await embedProp("mask", clonedNode, options)) {
+    await embedProp("mask-image", clonedNode, options);
+  }
+}
+async function embedImageNode(clonedNode, options) {
+  const isImageElement = isInstanceOfElement(clonedNode, HTMLImageElement);
+  if (!(isImageElement && !isDataUrl(clonedNode.src)) && !(isInstanceOfElement(clonedNode, SVGImageElement) && !isDataUrl(clonedNode.href.baseVal))) {
+    return;
+  }
+  const url = isImageElement ? clonedNode.src : clonedNode.href.baseVal;
+  const dataURL = await resourceToDataURL(url, getMimeType(url), options);
+  await new Promise((resolve, reject) => {
+    clonedNode.onload = resolve;
+    clonedNode.onerror = reject;
+    const image = clonedNode;
+    if (image.decode) {
+      image.decode = resolve;
+    }
+    if (image.loading === "lazy") {
+      image.loading = "eager";
+    }
+    if (isImageElement) {
+      clonedNode.srcset = "";
+      clonedNode.src = dataURL;
+    } else {
+      clonedNode.href.baseVal = dataURL;
+    }
+  });
+}
+async function embedChildren(clonedNode, options) {
+  const children = toArray(clonedNode.childNodes);
+  const deferreds = children.map((child) => embedImages(child, options));
+  await Promise.all(deferreds).then(() => clonedNode);
+}
+async function embedImages(clonedNode, options) {
+  if (isInstanceOfElement(clonedNode, Element)) {
+    await embedBackground(clonedNode, options);
+    await embedImageNode(clonedNode, options);
+    await embedChildren(clonedNode, options);
+  }
+}
+
+// ../../node_modules/html-to-image/es/apply-style.js
+function applyStyle(node, options) {
+  const { style } = node;
+  if (options.backgroundColor) {
+    style.backgroundColor = options.backgroundColor;
+  }
+  if (options.width) {
+    style.width = `${options.width}px`;
+  }
+  if (options.height) {
+    style.height = `${options.height}px`;
+  }
+  const manual = options.style;
+  if (manual != null) {
+    Object.keys(manual).forEach((key) => {
+      style[key] = manual[key];
+    });
+  }
+  return node;
+}
+
+// ../../node_modules/html-to-image/es/embed-webfonts.js
+var cssFetchCache = {};
+async function fetchCSS(url) {
+  let cache2 = cssFetchCache[url];
+  if (cache2 != null) {
+    return cache2;
+  }
+  const res = await fetch(url);
+  const cssText = await res.text();
+  cache2 = { url, cssText };
+  cssFetchCache[url] = cache2;
+  return cache2;
+}
+async function embedFonts(data, options) {
+  let cssText = data.cssText;
+  const regexUrl = /url\(["']?([^"')]+)["']?\)/g;
+  const fontLocs = cssText.match(/url\([^)]+\)/g) || [];
+  const loadFonts = fontLocs.map(async (loc) => {
+    let url = loc.replace(regexUrl, "$1");
+    if (!url.startsWith("https://")) {
+      url = new URL(url, data.url).href;
+    }
+    return fetchAsDataURL(url, options.fetchRequestInit, ({ result }) => {
+      cssText = cssText.replace(loc, `url(${result})`);
+      return [loc, result];
+    });
+  });
+  return Promise.all(loadFonts).then(() => cssText);
+}
+function parseCSS(source) {
+  if (source == null) {
+    return [];
+  }
+  const result = [];
+  const commentsRegex = /(\/\*[\s\S]*?\*\/)/gi;
+  let cssText = source.replace(commentsRegex, "");
+  const keyframesRegex = new RegExp("((@.*?keyframes [\\s\\S]*?){([\\s\\S]*?}\\s*?)})", "gi");
+  while (true) {
+    const matches = keyframesRegex.exec(cssText);
+    if (matches === null) {
+      break;
+    }
+    result.push(matches[0]);
+  }
+  cssText = cssText.replace(keyframesRegex, "");
+  const importRegex = /@import[\s\S]*?url\([^)]*\)[\s\S]*?;/gi;
+  const combinedCSSRegex = "((\\s*?(?:\\/\\*[\\s\\S]*?\\*\\/)?\\s*?@media[\\s\\S]*?){([\\s\\S]*?)}\\s*?})|(([\\s\\S]*?){([\\s\\S]*?)})";
+  const unifiedRegex = new RegExp(combinedCSSRegex, "gi");
+  while (true) {
+    let matches = importRegex.exec(cssText);
+    if (matches === null) {
+      matches = unifiedRegex.exec(cssText);
+      if (matches === null) {
+        break;
+      } else {
+        importRegex.lastIndex = unifiedRegex.lastIndex;
+      }
+    } else {
+      unifiedRegex.lastIndex = importRegex.lastIndex;
+    }
+    result.push(matches[0]);
+  }
+  return result;
+}
+async function getCSSRules(styleSheets, options) {
+  const ret = [];
+  const deferreds = [];
+  styleSheets.forEach((sheet) => {
+    if ("cssRules" in sheet) {
+      try {
+        toArray(sheet.cssRules || []).forEach((item, index) => {
+          if (item.type === CSSRule.IMPORT_RULE) {
+            let importIndex = index + 1;
+            const url = item.href;
+            const deferred = fetchCSS(url).then((metadata) => embedFonts(metadata, options)).then((cssText) => parseCSS(cssText).forEach((rule) => {
+              try {
+                sheet.insertRule(rule, rule.startsWith("@import") ? importIndex += 1 : sheet.cssRules.length);
+              } catch (error) {
+                console.error("Error inserting rule from remote css", {
+                  rule,
+                  error
+                });
+              }
+            })).catch((e) => {
+              console.error("Error loading remote css", e.toString());
+            });
+            deferreds.push(deferred);
+          }
+        });
+      } catch (e) {
+        const inline = styleSheets.find((a) => a.href == null) || document.styleSheets[0];
+        if (sheet.href != null) {
+          deferreds.push(fetchCSS(sheet.href).then((metadata) => embedFonts(metadata, options)).then((cssText) => parseCSS(cssText).forEach((rule) => {
+            inline.insertRule(rule, sheet.cssRules.length);
+          })).catch((err) => {
+            console.error("Error loading remote stylesheet", err);
+          }));
+        }
+        console.error("Error inlining remote css file", e);
+      }
+    }
+  });
+  return Promise.all(deferreds).then(() => {
+    styleSheets.forEach((sheet) => {
+      if ("cssRules" in sheet) {
+        try {
+          toArray(sheet.cssRules || []).forEach((item) => {
+            ret.push(item);
+          });
+        } catch (e) {
+          console.error(`Error while reading CSS rules from ${sheet.href}`, e);
+        }
+      }
+    });
+    return ret;
+  });
+}
+function getWebFontRules(cssRules) {
+  return cssRules.filter((rule) => rule.type === CSSRule.FONT_FACE_RULE).filter((rule) => shouldEmbed(rule.style.getPropertyValue("src")));
+}
+async function parseWebFontRules(node, options) {
+  if (node.ownerDocument == null) {
+    throw new Error("Provided element is not within a Document");
+  }
+  const styleSheets = toArray(node.ownerDocument.styleSheets);
+  const cssRules = await getCSSRules(styleSheets, options);
+  return getWebFontRules(cssRules);
+}
+async function getWebFontCSS(node, options) {
+  const rules = await parseWebFontRules(node, options);
+  const cssTexts = await Promise.all(rules.map((rule) => {
+    const baseUrl = rule.parentStyleSheet ? rule.parentStyleSheet.href : null;
+    return embedResources(rule.cssText, baseUrl, options);
+  }));
+  return cssTexts.join("\n");
+}
+async function embedWebFonts(clonedNode, options) {
+  const cssText = options.fontEmbedCSS != null ? options.fontEmbedCSS : options.skipFonts ? null : await getWebFontCSS(clonedNode, options);
+  if (cssText) {
+    const styleNode = document.createElement("style");
+    const sytleContent = document.createTextNode(cssText);
+    styleNode.appendChild(sytleContent);
+    if (clonedNode.firstChild) {
+      clonedNode.insertBefore(styleNode, clonedNode.firstChild);
+    } else {
+      clonedNode.appendChild(styleNode);
+    }
+  }
+}
+
+// ../../node_modules/html-to-image/es/index.js
+async function toSvg(node, options = {}) {
+  const { width, height } = getImageSize(node, options);
+  const clonedNode = await cloneNode(node, options, true);
+  await embedWebFonts(clonedNode, options);
+  await embedImages(clonedNode, options);
+  applyStyle(clonedNode, options);
+  const datauri = await nodeToDataURL(clonedNode, width, height);
+  return datauri;
+}
+async function toCanvas(node, options = {}) {
+  const { width, height } = getImageSize(node, options);
+  const svg = await toSvg(node, options);
+  const img = await createImage(svg);
+  const canvas = document.createElement("canvas");
+  const context = canvas.getContext("2d");
+  const ratio = options.pixelRatio || getPixelRatio();
+  const canvasWidth = options.canvasWidth || width;
+  const canvasHeight = options.canvasHeight || height;
+  canvas.width = canvasWidth * ratio;
+  canvas.height = canvasHeight * ratio;
+  if (!options.skipAutoScale) {
+    checkCanvasDimensions(canvas);
+  }
+  canvas.style.width = `${canvasWidth}`;
+  canvas.style.height = `${canvasHeight}`;
+  if (options.backgroundColor) {
+    context.fillStyle = options.backgroundColor;
+    context.fillRect(0, 0, canvas.width, canvas.height);
+  }
+  context.drawImage(img, 0, 0, canvas.width, canvas.height);
+  return canvas;
+}
+async function toPng(node, options = {}) {
+  const canvas = await toCanvas(node, options);
+  return canvas.toDataURL();
+}
+
+// src/screenshot-utils.ts
+async function takeScreenshot(node) {
+  const screenshot = await toPng(node, { cacheBust: true }).then((dataUrl) => {
+    return dataUrl;
+  }).catch((err) => {
+    console.error("Error taking screenshot", err);
+    return void 0;
+  });
+  if (!screenshot) {
+    return void 0;
+  }
+  return screenshot;
+}
 //# sourceMappingURL=index.js.map