@mdxeditor/editor 0.0.1 → 0.0.4-development

package/dist/styles/globals.css.js

@@ -0,0 +1,4 @@
+const globals = "";
+export {
+  globals as default
+};

package/dist/styles/lexical-theme.module.css.js

@@ -0,0 +1,62 @@
+const lightTheme = "_light-theme_7hn0e_1";
+const darkTheme = "_dark-theme_7hn0e_1";
+const bold = "_bold_7hn0e_10";
+const italic = "_italic_7hn0e_14";
+const underline = "_underline_7hn0e_18";
+const strikethrough = "_strikethrough_7hn0e_34";
+const underlineStrikethrough = "_underlineStrikethrough_7hn0e_38";
+const subscript = "_subscript_7hn0e_42";
+const superscript = "_superscript_7hn0e_47";
+const code = "_code_7hn0e_52";
+const nestedListItem = "_nestedListItem_7hn0e_59";
+const listitem = "_listitem_7hn0e_69";
+const listItemChecked = "_listItemChecked_7hn0e_73";
+const listItemUnchecked = "_listItemUnchecked_7hn0e_74";
+const admonitionDanger = "_admonitionDanger_7hn0e_151";
+const admonitionInfo = "_admonitionInfo_7hn0e_151";
+const admonitionNote = "_admonitionNote_7hn0e_151";
+const admonitionTip = "_admonitionTip_7hn0e_151";
+const admonitionCaution = "_admonitionCaution_7hn0e_151";
+const styles = {
+  lightTheme,
+  darkTheme,
+  bold,
+  italic,
+  underline,
+  strikethrough,
+  underlineStrikethrough,
+  subscript,
+  superscript,
+  code,
+  nestedListItem,
+  listitem,
+  listItemChecked,
+  listItemUnchecked,
+  admonitionDanger,
+  admonitionInfo,
+  admonitionNote,
+  admonitionTip,
+  admonitionCaution
+};
+export {
+  admonitionCaution,
+  admonitionDanger,
+  admonitionInfo,
+  admonitionNote,
+  admonitionTip,
+  bold,
+  code,
+  darkTheme,
+  styles as default,
+  italic,
+  lightTheme,
+  listItemChecked,
+  listItemUnchecked,
+  listitem,
+  nestedListItem,
+  strikethrough,
+  subscript,
+  superscript,
+  underline,
+  underlineStrikethrough
+};

package/dist/styles/lexicalTheme.d.ts

@@ -0,0 +1,2 @@
+import { EditorThemeClasses } from 'lexical';
+export declare const lexicalTheme: EditorThemeClasses;

package/dist/styles/lexicalTheme.js

@@ -0,0 +1,31 @@
+import styles from "./lexical-theme.module.css.js";
+const lexicalTheme = {
+  text: {
+    bold: styles.bold,
+    italic: styles.italic,
+    underline: styles.underline,
+    code: styles.code,
+    strikethrough: styles.strikethrough,
+    subscript: styles.subscript,
+    superscript: styles.superscript,
+    underlineStrikethrough: styles.underlineStrikethrough
+  },
+  list: {
+    listitem: styles.listitem,
+    listitemChecked: styles.listItemChecked,
+    listitemUnchecked: styles.listItemUnchecked,
+    nested: {
+      listitem: styles.nestedListItem
+    }
+  },
+  admonition: {
+    danger: styles.admonitionDanger,
+    info: styles.admonitionInfo,
+    note: styles.admonitionNote,
+    tip: styles.admonitionTip,
+    caution: styles.admonitionCaution
+  }
+};
+export {
+  lexicalTheme
+};

package/dist/styles/ui.module.css.js

@@ -0,0 +1,311 @@
+const editorRoot = "_editorRoot_1qeio_37";
+const editorWrapper = "_editorWrapper_1qeio_138";
+const nestedListItem = "_nestedListItem_1qeio_141";
+const toolbarRoot = "_toolbarRoot_1qeio_145";
+const readOnlyToolbarRoot = "_readOnlyToolbarRoot_1qeio_168";
+const toolbarModeSwitch = "_toolbarModeSwitch_1qeio_176";
+const toolbarToggleItem = "_toolbarToggleItem_1qeio_186";
+const toolbarGroupOfGroups = "_toolbarGroupOfGroups_1qeio_196";
+const toolbarToggleSingleGroup = "_toolbarToggleSingleGroup_1qeio_201";
+const toolbarButton = "_toolbarButton_1qeio_215";
+const activeToolbarButton = "_activeToolbarButton_1qeio_246";
+const toolbarNodeKindSelectContainer = "_toolbarNodeKindSelectContainer_1qeio_254";
+const toolbarButtonDropdownContainer = "_toolbarButtonDropdownContainer_1qeio_255";
+const toolbarCodeBlockLanguageSelectContent = "_toolbarCodeBlockLanguageSelectContent_1qeio_256";
+const selectContainer = "_selectContainer_1qeio_257";
+const selectItem = "_selectItem_1qeio_271";
+const toolbarNodeKindSelectTrigger = "_toolbarNodeKindSelectTrigger_1qeio_276";
+const toolbarButtonSelectTrigger = "_toolbarButtonSelectTrigger_1qeio_277";
+const selectTrigger = "_selectTrigger_1qeio_278";
+const toolbarCodeBlockLanguageSelectTrigger = "_toolbarCodeBlockLanguageSelectTrigger_1qeio_312";
+const toolbarNodeKindSelectItem = "_toolbarNodeKindSelectItem_1qeio_318";
+const toolbarNodeKindSelectDropdownArrow = "_toolbarNodeKindSelectDropdownArrow_1qeio_344";
+const selectDropdownArrow = "_selectDropdownArrow_1qeio_345";
+const contentEditable = "_contentEditable_1qeio_351";
+const sandpackWrapper = "_sandpackWrapper_1qeio_361";
+const frontmatterWrapper = "_frontmatterWrapper_1qeio_365";
+const frontmatterToggleButton = "_frontmatterToggleButton_1qeio_375";
+const propertyPanelTitle = "_propertyPanelTitle_1qeio_383";
+const propertyEditorTable = "_propertyEditorTable_1qeio_391";
+const iconButton = "_iconButton_1qeio_408";
+const readOnlyColumnCell = "_readOnlyColumnCell_1qeio_413";
+const propertyEditorLabelCell = "_propertyEditorLabelCell_1qeio_418";
+const buttonsFooter = "_buttonsFooter_1qeio_426";
+const propertyEditorInput = "_propertyEditorInput_1qeio_432";
+const primaryButton = "_primaryButton_1qeio_453";
+const secondaryButton = "_secondaryButton_1qeio_453";
+const smallButton = "_smallButton_1qeio_467";
+const dialogForm = "_dialogForm_1qeio_479";
+const linkDialogEditForm = "_linkDialogEditForm_1qeio_485";
+const linkDialogInputContainer = "_linkDialogInputContainer_1qeio_493";
+const linkDialogInputWrapper = "_linkDialogInputWrapper_1qeio_499";
+const linkDialogInput = "_linkDialogInput_1qeio_493";
+const dialogInput = "_dialogInput_1qeio_519";
+const linkDialogAnchor = "_linkDialogAnchor_1qeio_529";
+const linkDialogPopoverContent = "_linkDialogPopoverContent_1qeio_543";
+const tableColumnEditorPopoverContent = "_tableColumnEditorPopoverContent_1qeio_543";
+const dialogContent = "_dialogContent_1qeio_543";
+const largeDialogContent = "_largeDialogContent_1qeio_555";
+const dialogTitle = "_dialogTitle_1qeio_565";
+const dialogCloseButton = "_dialogCloseButton_1qeio_571";
+const popoverContent = "_popoverContent_1qeio_578";
+const popoverArrow = "_popoverArrow_1qeio_590";
+const linkDialogPreviewAnchor = "_linkDialogPreviewAnchor_1qeio_594";
+const tooltipTrigger = "_tooltipTrigger_1qeio_615";
+const tooltipContent = "_tooltipContent_1qeio_619";
+const actionButton = "_actionButton_1qeio_633";
+const primaryActionButton = "_primaryActionButton_1qeio_639";
+const tableEditor = "_tableEditor_1qeio_648";
+const toolCell = "_toolCell_1qeio_659";
+const tableColumnEditorTrigger = "_tableColumnEditorTrigger_1qeio_676";
+const tableRowEditorTrigger = "_tableRowEditorTrigger_1qeio_676";
+const addRowButton = "_addRowButton_1qeio_676";
+const addColumnButton = "_addColumnButton_1qeio_676";
+const tableColumnEditorToolbar = "_tableColumnEditorToolbar_1qeio_710";
+const toggleGroupRoot = "_toggleGroupRoot_1qeio_723";
+const tableToolsColumn = "_tableToolsColumn_1qeio_740";
+const leftAlignedCell = "_leftAlignedCell_1qeio_748";
+const rightAlignedCell = "_rightAlignedCell_1qeio_752";
+const centeredCell = "_centeredCell_1qeio_756";
+const dialogOverlay = "_dialogOverlay_1qeio_787";
+const overlayShow = "_overlayShow_1qeio_1";
+const contentShow = "_contentShow_1qeio_1";
+const focusedImage = "_focusedImage_1qeio_830";
+const imageWrapper = "_imageWrapper_1qeio_834";
+const editImageButton = "_editImageButton_1qeio_846";
+const inlineEditor = "_inlineEditor_1qeio_858";
+const blockEditor = "_blockEditor_1qeio_867";
+const nestedEditor = "_nestedEditor_1qeio_876";
+const genericComponentName = "_genericComponentName_1qeio_893";
+const diffSourceToggle = "_diffSourceToggle_1qeio_899";
+const selectWithLabel = "_selectWithLabel_1qeio_912";
+const toolbarTitleMode = "_toolbarTitleMode_1qeio_926";
+const imageControlWrapperResizing = "_imageControlWrapperResizing_1qeio_932";
+const imageResizer = "_imageResizer_1qeio_936";
+const imageResizerN = "_imageResizerN_1qeio_945";
+const imageResizerNe = "_imageResizerNe_1qeio_951";
+const imageResizerE = "_imageResizerE_1qeio_957";
+const imageResizerSe = "_imageResizerSe_1qeio_963";
+const imageResizerS = "_imageResizerS_1qeio_963";
+const imageResizerSw = "_imageResizerSw_1qeio_975";
+const imageResizerW = "_imageResizerW_1qeio_981";
+const imageResizerNw = "_imageResizerNw_1qeio_987";
+const placeholder = "_placeholder_1qeio_993";
+const rootContentEditableWrapper = "_rootContentEditableWrapper_1qeio_1006";
+const downshiftContainer = "_downshiftContainer_1qeio_1012";
+const downshiftInputWrapper = "_downshiftInputWrapper_1qeio_1018";
+const downshiftInput = "_downshiftInput_1qeio_1018";
+const downshiftAutocompleteContainer = "_downshiftAutocompleteContainer_1qeio_1048";
+const textInput = "_textInput_1qeio_1093";
+const multiFieldForm = "_multiFieldForm_1qeio_1101";
+const formField = "_formField_1qeio_1107";
+const markdownParseError = "_markdownParseError_1qeio_1118";
+const styles = {
+  editorRoot,
+  editorWrapper,
+  nestedListItem,
+  toolbarRoot,
+  readOnlyToolbarRoot,
+  toolbarModeSwitch,
+  toolbarToggleItem,
+  toolbarGroupOfGroups,
+  toolbarToggleSingleGroup,
+  toolbarButton,
+  activeToolbarButton,
+  toolbarNodeKindSelectContainer,
+  toolbarButtonDropdownContainer,
+  toolbarCodeBlockLanguageSelectContent,
+  selectContainer,
+  selectItem,
+  toolbarNodeKindSelectTrigger,
+  toolbarButtonSelectTrigger,
+  selectTrigger,
+  toolbarCodeBlockLanguageSelectTrigger,
+  toolbarNodeKindSelectItem,
+  toolbarNodeKindSelectDropdownArrow,
+  selectDropdownArrow,
+  contentEditable,
+  sandpackWrapper,
+  frontmatterWrapper,
+  frontmatterToggleButton,
+  propertyPanelTitle,
+  propertyEditorTable,
+  iconButton,
+  readOnlyColumnCell,
+  propertyEditorLabelCell,
+  buttonsFooter,
+  propertyEditorInput,
+  primaryButton,
+  secondaryButton,
+  smallButton,
+  dialogForm,
+  linkDialogEditForm,
+  linkDialogInputContainer,
+  linkDialogInputWrapper,
+  linkDialogInput,
+  dialogInput,
+  linkDialogAnchor,
+  linkDialogPopoverContent,
+  tableColumnEditorPopoverContent,
+  dialogContent,
+  largeDialogContent,
+  dialogTitle,
+  dialogCloseButton,
+  popoverContent,
+  popoverArrow,
+  linkDialogPreviewAnchor,
+  tooltipTrigger,
+  tooltipContent,
+  actionButton,
+  primaryActionButton,
+  tableEditor,
+  toolCell,
+  tableColumnEditorTrigger,
+  tableRowEditorTrigger,
+  addRowButton,
+  addColumnButton,
+  tableColumnEditorToolbar,
+  toggleGroupRoot,
+  tableToolsColumn,
+  leftAlignedCell,
+  rightAlignedCell,
+  centeredCell,
+  dialogOverlay,
+  overlayShow,
+  contentShow,
+  focusedImage,
+  imageWrapper,
+  editImageButton,
+  inlineEditor,
+  blockEditor,
+  nestedEditor,
+  genericComponentName,
+  diffSourceToggle,
+  selectWithLabel,
+  toolbarTitleMode,
+  imageControlWrapperResizing,
+  imageResizer,
+  imageResizerN,
+  imageResizerNe,
+  imageResizerE,
+  imageResizerSe,
+  imageResizerS,
+  imageResizerSw,
+  imageResizerW,
+  imageResizerNw,
+  placeholder,
+  rootContentEditableWrapper,
+  downshiftContainer,
+  downshiftInputWrapper,
+  downshiftInput,
+  downshiftAutocompleteContainer,
+  textInput,
+  multiFieldForm,
+  formField,
+  markdownParseError
+};
+export {
+  actionButton,
+  activeToolbarButton,
+  addColumnButton,
+  addRowButton,
+  blockEditor,
+  buttonsFooter,
+  centeredCell,
+  contentEditable,
+  contentShow,
+  styles as default,
+  dialogCloseButton,
+  dialogContent,
+  dialogForm,
+  dialogInput,
+  dialogOverlay,
+  dialogTitle,
+  diffSourceToggle,
+  downshiftAutocompleteContainer,
+  downshiftContainer,
+  downshiftInput,
+  downshiftInputWrapper,
+  editImageButton,
+  editorRoot,
+  editorWrapper,
+  focusedImage,
+  formField,
+  frontmatterToggleButton,
+  frontmatterWrapper,
+  genericComponentName,
+  iconButton,
+  imageControlWrapperResizing,
+  imageResizer,
+  imageResizerE,
+  imageResizerN,
+  imageResizerNe,
+  imageResizerNw,
+  imageResizerS,
+  imageResizerSe,
+  imageResizerSw,
+  imageResizerW,
+  imageWrapper,
+  inlineEditor,
+  largeDialogContent,
+  leftAlignedCell,
+  linkDialogAnchor,
+  linkDialogEditForm,
+  linkDialogInput,
+  linkDialogInputContainer,
+  linkDialogInputWrapper,
+  linkDialogPopoverContent,
+  linkDialogPreviewAnchor,
+  markdownParseError,
+  multiFieldForm,
+  nestedEditor,
+  nestedListItem,
+  overlayShow,
+  placeholder,
+  popoverArrow,
+  popoverContent,
+  primaryActionButton,
+  primaryButton,
+  propertyEditorInput,
+  propertyEditorLabelCell,
+  propertyEditorTable,
+  propertyPanelTitle,
+  readOnlyColumnCell,
+  readOnlyToolbarRoot,
+  rightAlignedCell,
+  rootContentEditableWrapper,
+  sandpackWrapper,
+  secondaryButton,
+  selectContainer,
+  selectDropdownArrow,
+  selectItem,
+  selectTrigger,
+  selectWithLabel,
+  smallButton,
+  tableColumnEditorPopoverContent,
+  tableColumnEditorToolbar,
+  tableColumnEditorTrigger,
+  tableEditor,
+  tableRowEditorTrigger,
+  tableToolsColumn,
+  textInput,
+  toggleGroupRoot,
+  toolCell,
+  toolbarButton,
+  toolbarButtonDropdownContainer,
+  toolbarButtonSelectTrigger,
+  toolbarCodeBlockLanguageSelectContent,
+  toolbarCodeBlockLanguageSelectTrigger,
+  toolbarGroupOfGroups,
+  toolbarModeSwitch,
+  toolbarNodeKindSelectContainer,
+  toolbarNodeKindSelectDropdownArrow,
+  toolbarNodeKindSelectItem,
+  toolbarNodeKindSelectTrigger,
+  toolbarRoot,
+  toolbarTitleMode,
+  toolbarToggleItem,
+  toolbarToggleSingleGroup,
+  tooltipContent,
+  tooltipTrigger
+};

package/dist/utils/detectMac.d.ts

@@ -0,0 +1,3 @@
+export declare const CAN_USE_DOM: boolean;
+export declare const IS_APPLE: boolean;
+export declare function controlOrMeta(metaKey: boolean, ctrlKey: boolean): boolean;

package/dist/utils/detectMac.js

@@ -0,0 +1,13 @@
+const CAN_USE_DOM = typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined";
+const IS_APPLE = CAN_USE_DOM && /Mac|iPod|iPhone|iPad/.test(navigator.platform);
+function controlOrMeta(metaKey, ctrlKey) {
+  if (IS_APPLE) {
+    return metaKey;
+  }
+  return ctrlKey;
+}
+export {
+  CAN_USE_DOM,
+  IS_APPLE,
+  controlOrMeta
+};

package/dist/utils/fp.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Utils includes a handful of functional utilities inspired by or taken from the [Ramda library](https://ramdajs.com/);
+ * Use these for your convenience - they are here so that urx is zero-dependency package.
+ * @packageDocumentation
+ */
+/** @internal */
+export interface Proc {
+    (): unknown;
+}
+/**
+ * Performs left to right composition of two functions.
+ */
+export declare function compose<I, A, R>(a: (arg: A) => R, b: (arg: I) => A): (arg: I) => R;
+/**
+ * Takes a value and applies a function to it.
+ */
+export declare function thrush<I, K>(arg: I, proc: (arg: I) => K): K;
+/**
+ * Takes a 2 argument function and partially applies the first argument.
+ */
+export declare function curry2to1<T, K, R>(proc: (arg1: T, arg2: K) => R, arg1: T): (arg2: K) => R;
+/**
+ * Takes a 1 argument function and returns a function which when called, executes it with the provided argument.
+ */
+export declare function curry1to0<T, R>(proc: (arg: T) => R, arg: T): () => R;
+/**
+ * Returns a function which extracts the property from from the passed object.
+ */
+export declare function prop<T extends Record<string, unknown>>(property: keyof T): (object: T) => T[keyof T];
+/**
+ * Calls callback with the first argument, and returns it.
+ */
+export declare function tap<T>(arg: T, proc: (arg: T) => unknown): T;
+/**
+ * Calls the passed function.
+ */
+export declare function call(proc: Proc): void;
+/**
+ * returns a function which when called always returns the passed value
+ */
+export declare function always<T>(value: T): () => T;
+/**
+ * returns a function which calls all passed functions in the passed order.
+ * joinProc does not pass arguments or collect return values.
+ */
+export declare function joinProc(...procs: Proc[]): () => void;
+export declare function noop(): void;

package/dist/utils/fp.js

@@ -0,0 +1,44 @@
+function compose(a, b) {
+  return (arg) => a(b(arg));
+}
+function thrush(arg, proc) {
+  return proc(arg);
+}
+function curry2to1(proc, arg1) {
+  return (arg2) => proc(arg1, arg2);
+}
+function curry1to0(proc, arg) {
+  return () => proc(arg);
+}
+function prop(property) {
+  return (object) => object[property];
+}
+function tap(arg, proc) {
+  proc(arg);
+  return arg;
+}
+function call(proc) {
+  proc();
+}
+function always(value) {
+  return () => value;
+}
+function joinProc(...procs) {
+  return () => {
+    procs.map(call);
+  };
+}
+function noop() {
+}
+export {
+  always,
+  call,
+  compose,
+  curry1to0,
+  curry2to1,
+  joinProc,
+  noop,
+  prop,
+  tap,
+  thrush
+};

package/dist/utils/isPartOftheEditorUI.d.ts

@@ -0,0 +1 @@
+export declare function isPartOftheEditorUI(element: HTMLElement | null, editorRoot: HTMLElement): boolean;

package/dist/utils/isPartOftheEditorUI.js

@@ -0,0 +1,12 @@
+function isPartOftheEditorUI(element, editorRoot) {
+  if (element === null || element === editorRoot) {
+    return false;
+  }
+  if (element.dataset["editorDialog"] !== void 0 || element.dataset["toolbarItem"] !== void 0 || element.dataset["editorDropdown"]) {
+    return true;
+  }
+  return isPartOftheEditorUI(element.parentElement, editorRoot);
+}
+export {
+  isPartOftheEditorUI
+};

package/dist/utils/lexicalHelpers.d.ts

@@ -0,0 +1,11 @@
+import { ElementNode, LexicalEditor, RangeSelection, TextNode } from 'lexical';
+import { ExportMarkdownFromLexicalOptions } from '../exportMarkdownFromLexical';
+export declare function fromWithinEditorRead<T>(editor: LexicalEditor, fn: () => T): T;
+export declare function getSelectedNode(selection: RangeSelection): TextNode | ElementNode | null;
+export declare function getSelectionRectangle(editor: LexicalEditor): {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+} | null;
+export declare function getStateAsMarkdown(editor: LexicalEditor, exportParams: Omit<ExportMarkdownFromLexicalOptions, 'root'>): string;

package/dist/utils/lexicalHelpers.js

@@ -0,0 +1,80 @@
+import { $getSelection, $getRoot } from "lexical";
+import { $isAtNodeEnd } from "@lexical/selection";
+import { tap } from "./fp.js";
+import { exportMarkdownFromLexical } from "../exportMarkdownFromLexical.js";
+function fromWithinEditorRead(editor, fn) {
+  let result = null;
+  editor.getEditorState().read(() => {
+    result = fn();
+  });
+  return result;
+}
+function getSelectedNode(selection) {
+  try {
+    const anchor = selection.anchor;
+    const focus = selection.focus;
+    const anchorNode = selection.anchor.getNode();
+    const focusNode = selection.focus.getNode();
+    if (anchorNode === focusNode) {
+      return anchorNode;
+    }
+    const isBackward = selection.isBackward();
+    if (isBackward) {
+      return $isAtNodeEnd(focus) ? anchorNode : focusNode;
+    } else {
+      return $isAtNodeEnd(anchor) ? anchorNode : focusNode;
+    }
+  } catch (e) {
+    return null;
+  }
+}
+function getSelectionRectangle(editor) {
+  const selection = $getSelection();
+  const nativeSelection = window.getSelection();
+  const activeElement = document.activeElement;
+  const rootElement = editor.getRootElement();
+  if (selection !== null && nativeSelection !== null && rootElement !== null && rootElement.contains(nativeSelection.anchorNode) && editor.isEditable()) {
+    const domRange = nativeSelection.getRangeAt(0);
+    let rect;
+    if (nativeSelection.isCollapsed) {
+      let node = nativeSelection.anchorNode;
+      if ((node == null ? void 0 : node.nodeType) == 3) {
+        node = node.parentNode;
+      }
+      rect = node.getBoundingClientRect();
+      rect.width = 0;
+    } else {
+      if (nativeSelection.anchorNode === rootElement) {
+        let inner = rootElement;
+        while (inner.firstElementChild != null) {
+          inner = inner.firstElementChild;
+        }
+        rect = inner.getBoundingClientRect();
+      } else {
+        rect = domRange.getBoundingClientRect();
+      }
+    }
+    return {
+      top: Math.round(rect.top),
+      left: Math.round(rect.left),
+      width: Math.round(rect.width),
+      height: Math.round(rect.height)
+    };
+  } else if (!activeElement || activeElement.className !== "link-input") {
+    return null;
+  }
+  return null;
+}
+function getStateAsMarkdown(editor, exportParams) {
+  return tap({ markdown: "" }, (result) => {
+    editor.getEditorState().read(() => {
+      result.markdown = exportMarkdownFromLexical({ root: $getRoot(), ...exportParams });
+    });
+  }).markdown;
+}
+export {
+  fromWithinEditorRead,
+  getSelectedNode,
+  getSelectionRectangle,
+  getStateAsMarkdown
+};

package/dist/utils/makeHslTransparent.d.ts

@@ -0,0 +1 @@
+export declare function makeHslTransparent(hsl: string, alpha: number): string;

package/dist/utils/makeHslTransparent.js

@@ -0,0 +1,6 @@
+function makeHslTransparent(hsl, alpha) {
+  return hsl.replace("hsl", "hsla").replace(")", `, ${alpha})`);
+}
+export {
+  makeHslTransparent
+};

package/dist/utils/mergeStyleAttributes.d.ts

@@ -0,0 +1 @@
+export declare function mergeStyleAttributes(style1: string, style2: string): string;

package/dist/utils/mergeStyleAttributes.js

@@ -0,0 +1,22 @@
+function mergeStyleAttributes(style1, style2) {
+  const styleObject1 = styleToObject(style1);
+  const styleObject2 = styleToObject(style2);
+  const mergedStyleObject = { ...styleObject1, ...styleObject2 };
+  const mergedStyleString = objectToStyle(mergedStyleObject);
+  return mergedStyleString;
+}
+function styleToObject(style) {
+  const styleObject = {};
+  const stylePairs = style.split(";").filter((pair) => pair.trim() !== "");
+  stylePairs.forEach((pair) => {
+    const [key, value] = pair.split(":").map((part) => part.trim());
+    styleObject[key] = value;
+  });
+  return styleObject;
+}
+function objectToStyle(styleObject) {
+  return Object.entries(styleObject).map(([key, value]) => `${key}: ${value}`).join("; ");
+}
+export {
+  mergeStyleAttributes
+};

package/dist/utils/uuid4.d.ts

@@ -0,0 +1 @@
+export declare function uuidv4(): string;

package/dist/utils/uuid4.js

@@ -0,0 +1,10 @@
+function uuidv4() {
+  const hex = [...Array(256).keys()].map((index) => index.toString(16).padStart(2, "0"));
+  const r = crypto.getRandomValues(new Uint8Array(16));
+  r[6] = r[6] & 15 | 64;
+  r[8] = r[8] & 63 | 128;
+  return [...r.entries()].map(([index, int]) => [4, 6, 8, 10].includes(index) ? `-${hex[int]}` : hex[int]).join("");
+}
+export {
+  uuidv4
+};