@contember/react-slate-editor-base 2.1.0-alpha.3 → 2.1.0-alpha.35

package/src/plugins/element/paragraphs/withParagraphs.ts

@@ -12,7 +12,6 @@ export const withParagraphs = ({ render }: { render: ElementRenderer<ParagraphEl
 
 	editor.registerElement(paragraphElementPlugin({ render }))
 
-
 	editor.canToggleElement = (elementType, suchThat) => {
 		// This only allows numbered paragraphs at the top level.
 		// TODO this is pretty bad but in order to fix this, we'd also have to fix toggleElement and there's no time now.
@@ -35,7 +34,7 @@ export const withParagraphs = ({ render }: { render: ElementRenderer<ParagraphEl
 		}
 		const [closestBlockElement, closestBlockPath] = closestBlockEntry
 
-		return closestBlockPath.length === 1 &&  SlateElement.isElement(closestBlockElement) && closestBlockElement.type === paragraphElementType
+		return closestBlockPath.length === 1 && SlateElement.isElement(closestBlockElement) && closestBlockElement.type === paragraphElementType
 	}
 
 	editor.deleteBackward = unit => {

package/src/plugins/element/scrollTargets/ScrollTargetElement.ts

@@ -1,4 +1,4 @@
-import { Editor as SlateEditor, Editor, Element as SlateElement, Node as SlateNode, Range as SlateRange, Transforms } from 'slate'
+import { Editor, Editor as SlateEditor, Element as SlateElement, Node as SlateNode, Range as SlateRange, Transforms } from 'slate'
 import { EditorElementPlugin, ElementRenderer } from '../../../types'
 
 export const scrollTargetElementType = 'scrollTarget' as const
@@ -17,7 +17,9 @@ export const isScrollTargetElementActive = (editor: Editor) => {
 	return !!link
 }
 
-export const scrollTargetElementPlugin = ({ render }: { render: ElementRenderer<ScrollTargetElement> }): EditorElementPlugin<ScrollTargetElement> => ({
+export const scrollTargetElementPlugin = (
+	{ render }: { render: ElementRenderer<ScrollTargetElement> },
+): EditorElementPlugin<ScrollTargetElement> => ({
 	type: scrollTargetElementType,
 	render,
 	isActive: ({ editor }) => isScrollTargetElementActive(editor),
@@ -27,9 +29,8 @@ export const scrollTargetElementPlugin = ({ render }: { render: ElementRenderer<
 		if (isScrollTargetElementActive(editor)) {
 			unwrapScrollTarget(editor)
 		} else {
-			let identifier =
-				suchThat?.identifier ??
-				prompt('Insert the identifier:')
+			let identifier = suchThat?.identifier
+				?? prompt('Insert the identifier:')
 
 			if (!identifier) {
 				return

package/src/plugins/element/tables/TableCellElement.ts

@@ -19,8 +19,7 @@ export const createEmptyTableCellElement = () => ({
 	children: [{ text: '' }],
 })
 
-
-export const tableCellElementPlugin = ({ render }: {render: ElementRenderer<TableCellElement>}): EditorElementPlugin<TableCellElement> => ({
+export const tableCellElementPlugin = ({ render }: { render: ElementRenderer<TableCellElement> }): EditorElementPlugin<TableCellElement> => ({
 	type: tableCellElementType,
 	render,
 	normalizeNode: ({ element, editor, path, preventDefault }) => {

package/src/plugins/element/tables/TableElement.ts

@@ -1,4 +1,15 @@
-import { Editor as SlateEditor, Editor, Element as SlateElement, Element, Node as SlateNode, Node, NodeEntry, Path as SlatePath, Range as SlateRange, Transforms } from 'slate'
+import {
+	Editor,
+	Editor as SlateEditor,
+	Element,
+	Element as SlateElement,
+	Node,
+	Node as SlateNode,
+	NodeEntry,
+	Path as SlatePath,
+	Range as SlateRange,
+	Transforms,
+} from 'slate'
 import { createEmptyTableRowElement, isTableRowElement, TableRowElement, tableRowElementType } from './TableRowElement'
 import { ContemberEditor } from '../../../editor'
 import { gaugeTableColumnCount } from './gaugeTableColumnCount'
@@ -28,7 +39,7 @@ export const getTableElementColumnCount = (element: TableElement): number => {
 	return firstRow?.children.length ?? 0
 }
 
-export const tableElementPlugin = ({ render }: {render: ElementRenderer<TableElement>}): EditorElementPlugin<TableElement> => ({
+export const tableElementPlugin = ({ render }: { render: ElementRenderer<TableElement> }): EditorElementPlugin<TableElement> => ({
 	type: tableElementType,
 	render,
 	normalizeNode: ({ editor, element, path, preventDefault }) => {

package/src/plugins/element/tables/TableModifications.ts

@@ -3,12 +3,7 @@ import { ReactEditor } from 'slate-react'
 import { getTableElementColumnCount, getTableElementRowCount, TableElement } from './TableElement'
 import { createEmptyTableRowElement, isTableRowElement, TableRowElement, tableRowElementType } from './TableRowElement'
 import { ContemberEditor } from '../../../editor'
-import {
-	createEmptyTableCellElement,
-	isTableCellElement,
-	TableCellElement,
-	tableCellElementType,
-} from './TableCellElement'
+import { createEmptyTableCellElement, isTableCellElement, TableCellElement, tableCellElementType } from './TableCellElement'
 
 export class TableModifications {
 	public static deleteTableColumn(editor: Editor, element: TableElement, index: number) {
@@ -122,8 +117,7 @@ export class TableModifications {
 		})
 
 		// If none have it or the majority does but not all.
-		const shouldSetScope =
-			-currentStatusScore === rowCount || (currentStatusScore > 0 && currentStatusScore !== rowCount)
+		const shouldSetScope = -currentStatusScore === rowCount || (currentStatusScore > 0 && currentStatusScore !== rowCount)
 
 		forEachCellInColumn(editor, element, columnIndex, ([, cellPath]) => {
 			Transforms.setNodes(
@@ -162,4 +156,3 @@ const copyTableCell = (tableCellElement: TableCellElement): TableCellElement =>
 	type: tableCellElementType,
 	children: [{ text: '' }],
 })
-

package/src/plugins/element/tables/TableRowElement.ts

@@ -1,4 +1,4 @@
-import { Editor as SlateEditor, Element as SlateElement, Element, Node, Node as SlateNode, Transforms } from 'slate'
+import { Editor as SlateEditor, Element, Element as SlateElement, Node, Node as SlateNode, Transforms } from 'slate'
 import { createEmptyTableCellElement, isTableCellElement, tableCellElementType } from './TableCellElement'
 import { ContemberEditor } from '../../../editor'
 import { tableElementType } from './TableElement'
@@ -19,7 +19,7 @@ export const createEmptyTableRowElement = (columnCount = 2) => ({
 	children: Array.from({ length: columnCount }, () => createEmptyTableCellElement()),
 })
 
-export const tableRowElementPlugin = ({ render }: {render: ElementRenderer<TableRowElement>}): EditorElementPlugin<TableRowElement> => ({
+export const tableRowElementPlugin = ({ render }: { render: ElementRenderer<TableRowElement> }): EditorElementPlugin<TableRowElement> => ({
 	type: tableRowElementType,
 	render,
 	normalizeNode: ({ editor, path, element, preventDefault }) => {

package/src/plugins/element/tables/withTables.ts

@@ -12,7 +12,8 @@ export const withTables = ({ renderTable, renderTableCell, renderTableRow }: {
 	renderTable: ElementRenderer<TableElement>
 	renderTableCell: ElementRenderer<TableCellElement>
 	renderTableRow: ElementRenderer<TableRowElement>
-}) => <E extends Editor>(editor: E): E => {
+}) =>
+<E extends Editor>(editor: E): E => {
 	const {
 		deleteForward,
 		deleteBackward,
@@ -66,9 +67,9 @@ export const withTables = ({ renderTable, renderTableCell, renderTableRow }: {
 			if (selection && SlateRange.isCollapsed(selection)) {
 				const closestBlockEntry = ContemberEditor.closestBlockEntry(editor)
 				if (
-					closestBlockEntry &&
-					isTableCellElement(closestBlockEntry[0]) &&
-					Point.equals(selection.focus, Editor.start(editor, closestBlockEntry[1]))
+					closestBlockEntry
+					&& isTableCellElement(closestBlockEntry[0])
+					&& Point.equals(selection.focus, Editor.start(editor, closestBlockEntry[1]))
 				) {
 					return
 				}
@@ -80,9 +81,9 @@ export const withTables = ({ renderTable, renderTableCell, renderTableRow }: {
 			if (selection && SlateRange.isCollapsed(selection)) {
 				const closestBlockEntry = ContemberEditor.closestBlockEntry(editor)
 				if (
-					closestBlockEntry &&
-					isTableCellElement(closestBlockEntry[0]) &&
-					Point.equals(selection.focus, Editor.end(editor, closestBlockEntry[1]))
+					closestBlockEntry
+					&& isTableCellElement(closestBlockEntry[0])
+					&& Point.equals(selection.focus, Editor.end(editor, closestBlockEntry[1]))
 				) {
 					return
 				}
@@ -105,15 +106,15 @@ export const withTables = ({ renderTable, renderTableCell, renderTableRow }: {
 		onKeyDown: event => {
 			const selection = editor.selection
 			if (
-				!selection ||
-				!(
-					event.key === 'Tab' ||
-					event.key === 'ArrowUp' ||
-					event.key === 'ArrowRight' ||
-					event.key === 'ArrowDown' ||
-					event.key === 'ArrowLeft' ||
-					event.key === 'Enter' ||
-					event.key === 'Backspace'
+				!selection
+				|| !(
+					event.key === 'Tab'
+					|| event.key === 'ArrowUp'
+					|| event.key === 'ArrowRight'
+					|| event.key === 'ArrowDown'
+					|| event.key === 'ArrowLeft'
+					|| event.key === 'Enter'
+					|| event.key === 'Backspace'
 				)
 			) {
 				return onKeyDown(event)
@@ -135,7 +136,7 @@ export const withTables = ({ renderTable, renderTableCell, renderTableRow }: {
 					return onKeyDown(event)
 				}
 			} else {
-				[cellElement, cellPath] = closestBlockEntry
+				;[cellElement, cellPath] = closestBlockEntry
 			}
 			if (cellPath.length < 3) {
 				return onKeyDown(event)
@@ -236,8 +237,8 @@ export const withTables = ({ renderTable, renderTableCell, renderTableRow }: {
 					const relative = SlatePath.relative(closestBlockEntry[1], cellPath)
 					const defaultIndex = relative[0]
 					if (
-						(event.key === 'ArrowUp' && defaultIndex !== 0) ||
-						(event.key === 'ArrowDown' && defaultIndex !== cellElement.children.length - 1)
+						(event.key === 'ArrowUp' && defaultIndex !== 0)
+						|| (event.key === 'ArrowDown' && defaultIndex !== cellElement.children.length - 1)
 					) {
 						return onKeyDown(event)
 					}
@@ -331,7 +332,6 @@ export const withTables = ({ renderTable, renderTableCell, renderTableRow }: {
 			}
 			onKeyDown(event)
 		},
-
 	})
 
 	return editor

package/src/plugins/text/bold/withBold.ts

@@ -2,7 +2,6 @@ import { boldMark, boldMarkPlugin } from './boldMark'
 import { EditorPlugin } from '../../../types'
 import { createMarkHtmlDeserializer } from '../../behaviour'
 
-
 export const withBold = (): EditorPlugin => editor => {
 	editor.registerMark(boldMarkPlugin)
 	editor.htmlDeserializer.registerPlugin(

package/src/plugins/text/code/withCode.ts

@@ -2,7 +2,6 @@ import { Editor as SlateEditor } from 'slate'
 import { codeMarkPlugin } from './codeMark'
 import { EditorPlugin } from '../../../types'
 
-
 export const withCode = (): EditorPlugin => editor => {
 	editor.registerMark(codeMarkPlugin)
 

package/src/plugins/text/highlight/withHighlight.ts

@@ -2,7 +2,6 @@ import { Editor as SlateEditor } from 'slate'
 import { highlightMarkPlugin } from './highlightMark'
 import { EditorPlugin } from '../../../types'
 
-
 export const withHighlight = (): EditorPlugin => editor => {
 	editor.registerMark(highlightMarkPlugin)
 

package/src/plugins/text/italic/withItalic.ts

@@ -2,7 +2,6 @@ import { italicMark, italicMarkPlugin } from './italicMark'
 import { EditorPlugin } from '../../../types'
 import { createMarkHtmlDeserializer } from '../../behaviour'
 
-
 export const withItalic = (): EditorPlugin => editor => {
 	editor.registerMark(italicMarkPlugin)
 	editor.htmlDeserializer.registerPlugin(

package/src/plugins/text/strikeThrough/withStrikeThrough.ts

@@ -3,7 +3,6 @@ import { strikeThroughMark, strikeThroughPlugin } from './strikeThroughMark'
 import { EditorPlugin } from '../../../types'
 import { createMarkHtmlDeserializer } from '../../behaviour'
 
-
 export const withStrikeThrough = (): EditorPlugin => editor => {
 	editor.registerMark(strikeThroughPlugin)
 	editor.htmlDeserializer.registerPlugin(

package/src/plugins/text/underline/withUnderline.ts

@@ -2,7 +2,6 @@ import { underlineMark, underlineMarkPlugin } from './underlineMark'
 import { createMarkHtmlDeserializer } from '../../behaviour'
 import { EditorPlugin } from '../../../types'
 
-
 export const withUnderline = (): EditorPlugin => editor => {
 	editor.registerMark(underlineMarkPlugin)
 	editor.htmlDeserializer.registerPlugin(

package/src/slate-types.ts

@@ -1,20 +1,24 @@
-import { BaseEditor, Descendant, Selection, Point, Range, Ancestor, Path } from 'slate'
+import { Ancestor, BaseEditor, Descendant, Path, Point, Range, Selection } from 'slate'
 import { ReactEditor, RenderElementProps } from 'slate-react'
 import { HistoryEditor } from 'slate-history'
 import { EditorWithEssentials } from './types/editor'
 
 export type Editor = EditorWithEssentials<ReactEditor & HistoryEditor & BaseEditor>
-export type EditorElement = {
-	[K in string]: unknown
-} & {
-	type: string
-	children: Array<Descendant>
-}
-export type EditorText = {
-	[K in string]: unknown
-} & {
-	text: string
-}
+export type EditorElement =
+	& {
+		[K in string]: unknown
+	}
+	& {
+		type: string
+		children: Array<Descendant>
+	}
+export type EditorText =
+	& {
+		[K in string]: unknown
+	}
+	& {
+		text: string
+	}
 
 export type EditorDescendant = Descendant
 export type EditorAncestor = Ancestor

package/src/types/htmlDeserializer.ts

@@ -19,7 +19,7 @@ export interface HtmlDeserializerPlugin {
 			element: HTMLElement
 			next: HtmlDeserializerNextCallback
 			cumulativeTextAttrs: HtmlDeserializerTextAttrs
-		}
+		},
 	) => SlateElement[] | SlateElement | null
 	processInlinePaste?: (
 		args: {
@@ -27,7 +27,7 @@ export interface HtmlDeserializerPlugin {
 			element: HTMLElement
 			next: HtmlDeserializerNextCallback
 			cumulativeTextAttrs: HtmlDeserializerTextAttrs
-		}
+		},
 	) => Descendant[] | Descendant | null
 	processAttributesPaste?: (args: {
 		deserializer: HtmlDeserializer

package/src/types/plugins.ts

@@ -11,7 +11,6 @@ export type EditorPlugin = ((editor: Editor) => void) | {
 	staticRender?: (props: { children?: ReactNode }, environment: Environment) => ReactNode
 }
 
-
 export type ElementRenderer<T extends Element> = FunctionComponent<RenderElementProps & { element: T }>
 
 export interface EditorElementPlugin<T extends Element> {
@@ -26,7 +25,6 @@ export interface EditorElementPlugin<T extends Element> {
 	acceptsAttributes?: (args: { editor: Editor; suchThat: Partial<T> }) => boolean
 }
 
-
 export interface EditorMarkPlugin {
 	type: string
 	isHotKey: (e: KeyboardEvent) => boolean

package/dist/development/index.cjs

@@ -1,139 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const index = require("./src/editor/index.cjs");
-const slateReexport = require("./src/slate-reexport.cjs");
-const createEditor = require("./src/editor/createEditor.cjs");
-const EditorElementTrigger = require("./src/components/triggers/EditorElementTrigger.cjs");
-const EditorGenericTrigger = require("./src/components/triggers/EditorGenericTrigger.cjs");
-const EditorMarkTrigger = require("./src/components/triggers/EditorMarkTrigger.cjs");
-const EditorWrapNodeTrigger = require("./src/components/triggers/EditorWrapNodeTrigger.cjs");
-const RichTextEditor = require("./src/components/RichTextEditor.cjs");
-const Slate = require("slate");
-const AnchorElement = require("./src/plugins/element/anchors/AnchorElement.cjs");
-const AnchorHtmlDeserializer = require("./src/plugins/element/anchors/AnchorHtmlDeserializer.cjs");
-const withAnchors = require("./src/plugins/element/anchors/withAnchors.cjs");
-const HeadingElement = require("./src/plugins/element/headings/HeadingElement.cjs");
-const HeadingHtmlDeserializer = require("./src/plugins/element/headings/HeadingHtmlDeserializer.cjs");
-const withHeadings = require("./src/plugins/element/headings/withHeadings.cjs");
-const HorizontalRuleElement = require("./src/plugins/element/horizonalRules/HorizontalRuleElement.cjs");
-const withHorizontalRules = require("./src/plugins/element/horizonalRules/withHorizontalRules.cjs");
-const ListItemElement = require("./src/plugins/element/lists/ListItemElement.cjs");
-const ListHtmlDeserializer = require("./src/plugins/element/lists/ListHtmlDeserializer.cjs");
-const OrderedListElement = require("./src/plugins/element/lists/OrderedListElement.cjs");
-const UnorderedListElement = require("./src/plugins/element/lists/UnorderedListElement.cjs");
-const withLists = require("./src/plugins/element/lists/withLists.cjs");
-const ParagraphElement = require("./src/plugins/element/paragraphs/ParagraphElement.cjs");
-const ParagraphHtmlDeserializer = require("./src/plugins/element/paragraphs/ParagraphHtmlDeserializer.cjs");
-const withParagraphs = require("./src/plugins/element/paragraphs/withParagraphs.cjs");
-const ScrollTargetElement = require("./src/plugins/element/scrollTargets/ScrollTargetElement.cjs");
-const withScrollTargets = require("./src/plugins/element/scrollTargets/withScrollTargets.cjs");
-const TableCellElement = require("./src/plugins/element/tables/TableCellElement.cjs");
-const TableElement = require("./src/plugins/element/tables/TableElement.cjs");
-const TableRowElement = require("./src/plugins/element/tables/TableRowElement.cjs");
-const withTables = require("./src/plugins/element/tables/withTables.cjs");
-const TableModifications = require("./src/plugins/element/tables/TableModifications.cjs");
-const alignButton = require("./src/plugins/attributes/alignment/alignButton.cjs");
-const withBold = require("./src/plugins/text/bold/withBold.cjs");
-const boldMark = require("./src/plugins/text/bold/boldMark.cjs");
-const withCode = require("./src/plugins/text/code/withCode.cjs");
-const codeMark = require("./src/plugins/text/code/codeMark.cjs");
-const withHighlight = require("./src/plugins/text/highlight/withHighlight.cjs");
-const highlightMark = require("./src/plugins/text/highlight/highlightMark.cjs");
-const withItalic = require("./src/plugins/text/italic/withItalic.cjs");
-const italicMark = require("./src/plugins/text/italic/italicMark.cjs");
-const withNewline = require("./src/plugins/text/newline/withNewline.cjs");
-const withStrikeThrough = require("./src/plugins/text/strikeThrough/withStrikeThrough.cjs");
-const strikeThroughMark = require("./src/plugins/text/strikeThrough/strikeThroughMark.cjs");
-const withUnderline = require("./src/plugins/text/underline/withUnderline.cjs");
-const underlineMark = require("./src/plugins/text/underline/underlineMark.cjs");
-const createMarkHtmlDeserializer = require("./src/plugins/behaviour/paste/createMarkHtmlDeserializer.cjs");
-const withPaste = require("./src/plugins/behaviour/paste/withPaste.cjs");
-exports.ContemberEditor = index.ContemberEditor;
-exports.EditorUtils = slateReexport.EditorUtils;
-exports.createEditor = createEditor.createEditor;
-exports.EditorElementTrigger = EditorElementTrigger.EditorElementTrigger;
-exports.EditorGenericTrigger = EditorGenericTrigger.EditorGenericTrigger;
-exports.EditorMarkTrigger = EditorMarkTrigger.EditorMarkTrigger;
-exports.EditorWrapNodeTrigger = EditorWrapNodeTrigger.EditorWrapNodeTrigger;
-exports.RichTextEditor = RichTextEditor.RichTextEditor;
-Object.defineProperty(exports, "EditorTransforms", {
-  enumerable: true,
-  get: () => Slate.Transforms
-});
-exports.anchorElementPlugin = AnchorElement.anchorElementPlugin;
-exports.anchorElementType = AnchorElement.anchorElementType;
-exports.isAnchorElement = AnchorElement.isAnchorElement;
-exports.isAnchorElementActive = AnchorElement.isAnchorElementActive;
-exports.anchorHtmlDeserializer = AnchorHtmlDeserializer.anchorHtmlDeserializer;
-exports.withAnchors = withAnchors.withAnchors;
-exports.ejectHeadingElement = HeadingElement.ejectHeadingElement;
-exports.headingElementPlugin = HeadingElement.headingElementPlugin;
-exports.headingElementType = HeadingElement.headingElementType;
-exports.isHeadingElement = HeadingElement.isHeadingElement;
-exports.headingHtmlDeserializer = HeadingHtmlDeserializer.headingHtmlDeserializer;
-exports.withHeadings = withHeadings.withHeadings;
-exports.horizontalRuleElementPlugin = HorizontalRuleElement.horizontalRuleElementPlugin;
-exports.horizontalRuleElementType = HorizontalRuleElement.horizontalRuleElementType;
-exports.isHorizontalRuleElement = HorizontalRuleElement.isHorizontalRuleElement;
-exports.isHorizontalRuleElementActive = HorizontalRuleElement.isHorizontalRuleElementActive;
-exports.withHorizontalRules = withHorizontalRules.withHorizontalRules;
-exports.isListItemElement = ListItemElement.isListItemElement;
-exports.listItemElementPlugin = ListItemElement.listItemElementPlugin;
-exports.listItemElementType = ListItemElement.listItemElementType;
-exports.listHtmlDeserializerFactory = ListHtmlDeserializer.listHtmlDeserializerFactory;
-exports.isOrderedListElement = OrderedListElement.isOrderedListElement;
-exports.orderedListElementPlugin = OrderedListElement.orderedListElementPlugin;
-exports.orderedListElementType = OrderedListElement.orderedListElementType;
-exports.isUnorderedListElement = UnorderedListElement.isUnorderedListElement;
-exports.unorderedListElementPlugin = UnorderedListElement.unorderedListElementPlugin;
-exports.unorderedListElementType = UnorderedListElement.unorderedListElementType;
-exports.withLists = withLists.withLists;
-exports.isParagraphElement = ParagraphElement.isParagraphElement;
-exports.paragraphElementPlugin = ParagraphElement.paragraphElementPlugin;
-exports.paragraphElementType = ParagraphElement.paragraphElementType;
-exports.paragraphHtmlDeserializer = ParagraphHtmlDeserializer.paragraphHtmlDeserializer;
-exports.withParagraphs = withParagraphs.withParagraphs;
-exports.isScrollTargetElement = ScrollTargetElement.isScrollTargetElement;
-exports.isScrollTargetElementActive = ScrollTargetElement.isScrollTargetElementActive;
-exports.scrollTargetElementPlugin = ScrollTargetElement.scrollTargetElementPlugin;
-exports.scrollTargetElementType = ScrollTargetElement.scrollTargetElementType;
-exports.withScrollTargets = withScrollTargets.withScrollTargets;
-exports.createEmptyTableCellElement = TableCellElement.createEmptyTableCellElement;
-exports.isTableCellElement = TableCellElement.isTableCellElement;
-exports.tableCellElementPlugin = TableCellElement.tableCellElementPlugin;
-exports.tableCellElementType = TableCellElement.tableCellElementType;
-exports.createEmptyTableElement = TableElement.createEmptyTableElement;
-exports.getTableElementColumnCount = TableElement.getTableElementColumnCount;
-exports.getTableElementRowCount = TableElement.getTableElementRowCount;
-exports.isTableElement = TableElement.isTableElement;
-exports.tableElementPlugin = TableElement.tableElementPlugin;
-exports.tableElementType = TableElement.tableElementType;
-exports.createEmptyTableRowElement = TableRowElement.createEmptyTableRowElement;
-exports.isTableRowElement = TableRowElement.isTableRowElement;
-exports.tableRowElementPlugin = TableRowElement.tableRowElementPlugin;
-exports.tableRowElementType = TableRowElement.tableRowElementType;
-exports.withTables = withTables.withTables;
-exports.TableModifications = TableModifications.TableModifications;
-exports.createAlignHandler = alignButton.createAlignHandler;
-exports.withBold = withBold.withBold;
-exports.boldMark = boldMark.boldMark;
-exports.boldMarkPlugin = boldMark.boldMarkPlugin;
-exports.withCode = withCode.withCode;
-exports.codeMark = codeMark.codeMark;
-exports.codeMarkPlugin = codeMark.codeMarkPlugin;
-exports.withHighlight = withHighlight.withHighlight;
-exports.highlightMark = highlightMark.highlightMark;
-exports.highlightMarkPlugin = highlightMark.highlightMarkPlugin;
-exports.withItalic = withItalic.withItalic;
-exports.italicMark = italicMark.italicMark;
-exports.italicMarkPlugin = italicMark.italicMarkPlugin;
-exports.withNewline = withNewline.withNewline;
-exports.withStrikeThrough = withStrikeThrough.withStrikeThrough;
-exports.strikeThroughMark = strikeThroughMark.strikeThroughMark;
-exports.strikeThroughPlugin = strikeThroughMark.strikeThroughPlugin;
-exports.withUnderline = withUnderline.withUnderline;
-exports.underlineMark = underlineMark.underlineMark;
-exports.underlineMarkPlugin = underlineMark.underlineMarkPlugin;
-exports.createMarkHtmlDeserializer = createMarkHtmlDeserializer.createMarkHtmlDeserializer;
-exports.withPaste = withPaste.withPaste;
-//# sourceMappingURL=index.cjs.map

package/dist/development/index.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/development/index.js

@@ -1,136 +0,0 @@
-import { ContemberEditor } from "./src/editor/index.js";
-import { EditorUtils } from "./src/slate-reexport.js";
-import { createEditor } from "./src/editor/createEditor.js";
-import { EditorElementTrigger } from "./src/components/triggers/EditorElementTrigger.js";
-import { EditorGenericTrigger } from "./src/components/triggers/EditorGenericTrigger.js";
-import { EditorMarkTrigger } from "./src/components/triggers/EditorMarkTrigger.js";
-import { EditorWrapNodeTrigger } from "./src/components/triggers/EditorWrapNodeTrigger.js";
-import { RichTextEditor } from "./src/components/RichTextEditor.js";
-import { Transforms } from "slate";
-import { anchorElementPlugin, anchorElementType, isAnchorElement, isAnchorElementActive } from "./src/plugins/element/anchors/AnchorElement.js";
-import { anchorHtmlDeserializer } from "./src/plugins/element/anchors/AnchorHtmlDeserializer.js";
-import { withAnchors } from "./src/plugins/element/anchors/withAnchors.js";
-import { ejectHeadingElement, headingElementPlugin, headingElementType, isHeadingElement } from "./src/plugins/element/headings/HeadingElement.js";
-import { headingHtmlDeserializer } from "./src/plugins/element/headings/HeadingHtmlDeserializer.js";
-import { withHeadings } from "./src/plugins/element/headings/withHeadings.js";
-import { horizontalRuleElementPlugin, horizontalRuleElementType, isHorizontalRuleElement, isHorizontalRuleElementActive } from "./src/plugins/element/horizonalRules/HorizontalRuleElement.js";
-import { withHorizontalRules } from "./src/plugins/element/horizonalRules/withHorizontalRules.js";
-import { isListItemElement, listItemElementPlugin, listItemElementType } from "./src/plugins/element/lists/ListItemElement.js";
-import { listHtmlDeserializerFactory } from "./src/plugins/element/lists/ListHtmlDeserializer.js";
-import { isOrderedListElement, orderedListElementPlugin, orderedListElementType } from "./src/plugins/element/lists/OrderedListElement.js";
-import { isUnorderedListElement, unorderedListElementPlugin, unorderedListElementType } from "./src/plugins/element/lists/UnorderedListElement.js";
-import { withLists } from "./src/plugins/element/lists/withLists.js";
-import { isParagraphElement, paragraphElementPlugin, paragraphElementType } from "./src/plugins/element/paragraphs/ParagraphElement.js";
-import { paragraphHtmlDeserializer } from "./src/plugins/element/paragraphs/ParagraphHtmlDeserializer.js";
-import { withParagraphs } from "./src/plugins/element/paragraphs/withParagraphs.js";
-import { isScrollTargetElement, isScrollTargetElementActive, scrollTargetElementPlugin, scrollTargetElementType } from "./src/plugins/element/scrollTargets/ScrollTargetElement.js";
-import { withScrollTargets } from "./src/plugins/element/scrollTargets/withScrollTargets.js";
-import { createEmptyTableCellElement, isTableCellElement, tableCellElementPlugin, tableCellElementType } from "./src/plugins/element/tables/TableCellElement.js";
-import { createEmptyTableElement, getTableElementColumnCount, getTableElementRowCount, isTableElement, tableElementPlugin, tableElementType } from "./src/plugins/element/tables/TableElement.js";
-import { createEmptyTableRowElement, isTableRowElement, tableRowElementPlugin, tableRowElementType } from "./src/plugins/element/tables/TableRowElement.js";
-import { withTables } from "./src/plugins/element/tables/withTables.js";
-import { TableModifications } from "./src/plugins/element/tables/TableModifications.js";
-import { createAlignHandler } from "./src/plugins/attributes/alignment/alignButton.js";
-import { withBold } from "./src/plugins/text/bold/withBold.js";
-import { boldMark, boldMarkPlugin } from "./src/plugins/text/bold/boldMark.js";
-import { withCode } from "./src/plugins/text/code/withCode.js";
-import { codeMark, codeMarkPlugin } from "./src/plugins/text/code/codeMark.js";
-import { withHighlight } from "./src/plugins/text/highlight/withHighlight.js";
-import { highlightMark, highlightMarkPlugin } from "./src/plugins/text/highlight/highlightMark.js";
-import { withItalic } from "./src/plugins/text/italic/withItalic.js";
-import { italicMark, italicMarkPlugin } from "./src/plugins/text/italic/italicMark.js";
-import { withNewline } from "./src/plugins/text/newline/withNewline.js";
-import { withStrikeThrough } from "./src/plugins/text/strikeThrough/withStrikeThrough.js";
-import { strikeThroughMark, strikeThroughPlugin } from "./src/plugins/text/strikeThrough/strikeThroughMark.js";
-import { withUnderline } from "./src/plugins/text/underline/withUnderline.js";
-import { underlineMark, underlineMarkPlugin } from "./src/plugins/text/underline/underlineMark.js";
-import { createMarkHtmlDeserializer } from "./src/plugins/behaviour/paste/createMarkHtmlDeserializer.js";
-import { withPaste } from "./src/plugins/behaviour/paste/withPaste.js";
-export {
-  ContemberEditor,
-  EditorElementTrigger,
-  EditorGenericTrigger,
-  EditorMarkTrigger,
-  Transforms as EditorTransforms,
-  EditorUtils,
-  EditorWrapNodeTrigger,
-  RichTextEditor,
-  TableModifications,
-  anchorElementPlugin,
-  anchorElementType,
-  anchorHtmlDeserializer,
-  boldMark,
-  boldMarkPlugin,
-  codeMark,
-  codeMarkPlugin,
-  createAlignHandler,
-  createEditor,
-  createEmptyTableCellElement,
-  createEmptyTableElement,
-  createEmptyTableRowElement,
-  createMarkHtmlDeserializer,
-  ejectHeadingElement,
-  getTableElementColumnCount,
-  getTableElementRowCount,
-  headingElementPlugin,
-  headingElementType,
-  headingHtmlDeserializer,
-  highlightMark,
-  highlightMarkPlugin,
-  horizontalRuleElementPlugin,
-  horizontalRuleElementType,
-  isAnchorElement,
-  isAnchorElementActive,
-  isHeadingElement,
-  isHorizontalRuleElement,
-  isHorizontalRuleElementActive,
-  isListItemElement,
-  isOrderedListElement,
-  isParagraphElement,
-  isScrollTargetElement,
-  isScrollTargetElementActive,
-  isTableCellElement,
-  isTableElement,
-  isTableRowElement,
-  isUnorderedListElement,
-  italicMark,
-  italicMarkPlugin,
-  listHtmlDeserializerFactory,
-  listItemElementPlugin,
-  listItemElementType,
-  orderedListElementPlugin,
-  orderedListElementType,
-  paragraphElementPlugin,
-  paragraphElementType,
-  paragraphHtmlDeserializer,
-  scrollTargetElementPlugin,
-  scrollTargetElementType,
-  strikeThroughMark,
-  strikeThroughPlugin,
-  tableCellElementPlugin,
-  tableCellElementType,
-  tableElementPlugin,
-  tableElementType,
-  tableRowElementPlugin,
-  tableRowElementType,
-  underlineMark,
-  underlineMarkPlugin,
-  unorderedListElementPlugin,
-  unorderedListElementType,
-  withAnchors,
-  withBold,
-  withCode,
-  withHeadings,
-  withHighlight,
-  withHorizontalRules,
-  withItalic,
-  withLists,
-  withNewline,
-  withParagraphs,
-  withPaste,
-  withScrollTargets,
-  withStrikeThrough,
-  withTables,
-  withUnderline
-};
-//# sourceMappingURL=index.js.map

package/dist/development/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}