@quadrats/react 0.6.7 → 0.7.1

package/_internal/index.cjs.js

@@ -1,57 +1,55 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
-function composeRenderElementsBase(renderDefault, renderElements) {
-    return (props) => {
-        for (const renderElement of renderElements) {
-            const element = renderElement(props);
-            if (element) {
-                return element;
-            }
-        }
-        return renderDefault(props);
-    };
+function composeRenderElementsBase(renderDefault, renderElements) {
+    return (props) => {
+        for (const renderElement of renderElements) {
+            const element = renderElement(props);
+            if (element) {
+                return element;
+            }
+        }
+        return renderDefault(props);
+    };
 }
 
-function composeRenderLeafsBase(renderDefault, renderLeafs) {
-    return (props) => {
-        props = Object.assign({}, props);
-        renderLeafs.forEach((renderLeaf) => {
-            props.children = renderLeaf(props);
-        });
-        return renderDefault(props);
-    };
+function composeRenderLeafsBase(renderDefault, renderLeafs) {
+    return (props) => {
+        props = Object.assign({}, props);
+        renderLeafs.forEach((renderLeaf) => {
+            props.children = renderLeaf(props);
+        });
+        return renderDefault(props);
+    };
 }
 
-function createRenderElementBase({ type, render, }) {
-    return (props) => {
-        if (props.element.type === type) {
-            return render(props);
-        }
-    };
+function createRenderElementBase({ type, render, }) {
+    return (props) => {
+        if (props.element.type === type) {
+            return render(props);
+        }
+    };
 }
 
-function createRenderElementsBase(options) {
-    return (props) => {
-        for (const { type, render } of options) {
-            if (props.element.type === type) {
-                return render(props);
-            }
-        }
-    };
+function createRenderElementsBase(options) {
+    return (props) => {
+        for (const { type, render } of options) {
+            if (props.element.type === type) {
+                return render(props);
+            }
+        }
+    };
 }
 
-function createRenderMarkBase(options) {
-    const { type, render } = options;
-    return (props) => {
-        const { children, leaf } = props;
-        const mark = leaf[type];
-        if (mark != null && leaf.text) {
-            return render(Object.assign(Object.assign({}, props), { mark }));
-        }
-        return children;
-    };
+function createRenderMarkBase(options) {
+    const { type, render } = options;
+    return (props) => {
+        const { children, leaf } = props;
+        const mark = leaf[type];
+        if (mark != null && leaf.text) {
+            return render(Object.assign(Object.assign({}, props), { mark }));
+        }
+        return children;
+    };
 }
 
 exports.composeRenderElementsBase = composeRenderElementsBase;

package/_internal/renderer/composeRenderElementsBase.js

@@ -1,13 +1,13 @@
-function composeRenderElementsBase(renderDefault, renderElements) {
-    return (props) => {
-        for (const renderElement of renderElements) {
-            const element = renderElement(props);
-            if (element) {
-                return element;
-            }
-        }
-        return renderDefault(props);
-    };
+function composeRenderElementsBase(renderDefault, renderElements) {
+    return (props) => {
+        for (const renderElement of renderElements) {
+            const element = renderElement(props);
+            if (element) {
+                return element;
+            }
+        }
+        return renderDefault(props);
+    };
 }
 
 export { composeRenderElementsBase };

package/_internal/renderer/composeRenderLeafsBase.js

@@ -1,11 +1,11 @@
-function composeRenderLeafsBase(renderDefault, renderLeafs) {
-    return (props) => {
-        props = Object.assign({}, props);
-        renderLeafs.forEach((renderLeaf) => {
-            props.children = renderLeaf(props);
-        });
-        return renderDefault(props);
-    };
+function composeRenderLeafsBase(renderDefault, renderLeafs) {
+    return (props) => {
+        props = Object.assign({}, props);
+        renderLeafs.forEach((renderLeaf) => {
+            props.children = renderLeaf(props);
+        });
+        return renderDefault(props);
+    };
 }
 
 export { composeRenderLeafsBase };

package/_internal/renderer/createRenderElementBase.js

@@ -1,9 +1,9 @@
-function createRenderElementBase({ type, render, }) {
-    return (props) => {
-        if (props.element.type === type) {
-            return render(props);
-        }
-    };
+function createRenderElementBase({ type, render, }) {
+    return (props) => {
+        if (props.element.type === type) {
+            return render(props);
+        }
+    };
 }
 
 export { createRenderElementBase };

package/_internal/renderer/createRenderElementsBase.js

@@ -1,11 +1,11 @@
-function createRenderElementsBase(options) {
-    return (props) => {
-        for (const { type, render } of options) {
-            if (props.element.type === type) {
-                return render(props);
-            }
-        }
-    };
+function createRenderElementsBase(options) {
+    return (props) => {
+        for (const { type, render } of options) {
+            if (props.element.type === type) {
+                return render(props);
+            }
+        }
+    };
 }
 
 export { createRenderElementsBase };

package/_internal/renderer/createRenderMarkBase.js

@@ -1,13 +1,13 @@
-function createRenderMarkBase(options) {
-    const { type, render } = options;
-    return (props) => {
-        const { children, leaf } = props;
-        const mark = leaf[type];
-        if (mark != null && leaf.text) {
-            return render(Object.assign(Object.assign({}, props), { mark }));
-        }
-        return children;
-    };
+function createRenderMarkBase(options) {
+    const { type, render } = options;
+    return (props) => {
+        const { children, leaf } = props;
+        const mark = leaf[type];
+        if (mark != null && leaf.text) {
+            return render(Object.assign(Object.assign({}, props), { mark }));
+        }
+        return children;
+    };
 }
 
 export { createRenderMarkBase };

package/blockquote/constants.js

@@ -1,8 +1,8 @@
-/**
- * Default hotkey for toggling blockquote.
- *
- * @see [is-hotkey]{@link https://www.npmjs.com/package/is-hotkey}
- */
+/**
+ * Default hotkey for toggling blockquote.
+ *
+ * @see [is-hotkey]{@link https://www.npmjs.com/package/is-hotkey}
+ */
 const BLOCKQUOTE_HOTKEY = 'ctrl+opt+q';
 
 export { BLOCKQUOTE_HOTKEY };

package/blockquote/createReactBlockquote.d.ts

@@ -1,5 +1,5 @@
 import { CreateBlockquoteOptions } from '@quadrats/common/blockquote';
 import { ReactBlockquote } from './typings';
-export declare type CreateReactBlockquoteOptions = CreateBlockquoteOptions;
+export type CreateReactBlockquoteOptions = CreateBlockquoteOptions;
 export declare const BLOCKQUOTE_EXIT_BREAK_HOTKEY = "enter";
 export declare function createReactBlockquote(options?: CreateReactBlockquoteOptions): ReactBlockquote;

package/blockquote/createReactBlockquote.js

@@ -6,64 +6,64 @@ import { BLOCKQUOTE_HOTKEY } from './constants.js';
 import { defaultRenderBlockquoteElement } from './defaultRenderBlockquoteElement.js';
 import { getNodesByTypes, PARAGRAPH_TYPE, Editor, Transforms } from '@quadrats/core';
 
-const BLOCKQUOTE_EXIT_BREAK_HOTKEY = 'enter';
-function createReactBlockquote(options = {}) {
-    const core = createBlockquote(options);
-    const { type } = core;
-    const onKeyDownBreak = createOnKeyDownBreak({
-        exitBreak: {
-            rules: [
-                {
-                    hotkey: BLOCKQUOTE_EXIT_BREAK_HOTKEY,
-                    match: {
-                        includeTypes: [type],
-                    },
-                },
-            ],
-        },
-        softBreak: {
-            rules: [
-                {
-                    hotkey: COMMON_SOFT_BREAK_HOTKEY,
-                    match: {
-                        includeTypes: [type],
-                    },
-                },
-            ],
-        },
-    });
-    return Object.assign(Object.assign({}, core), { createHandlers: ({ hotkey = BLOCKQUOTE_HOTKEY } = {}) => ({
-            onKeyDown: (event, editor, next) => {
-                if (isHotkey(hotkey, event)) {
-                    core.toggleBlockquote(editor);
-                }
-                else {
-                    if (editor.selection && isHotkey(BLOCKQUOTE_EXIT_BREAK_HOTKEY, event)) {
-                        const [highestIsQuote] = getNodesByTypes(editor, [type], { mode: 'highest' });
-                        const [selectInParagraph] = getNodesByTypes(editor, [PARAGRAPH_TYPE], { at: editor.selection });
-                        if (highestIsQuote && selectInParagraph) {
-                            const [, quotePath] = highestIsQuote;
-                            const isEnd = Editor.isEnd(editor, Editor.point(editor, editor.selection), quotePath);
-                            const [paragraphNode] = selectInParagraph;
-                            const text = paragraphNode.children[0].text;
-                            const isEmptyParagraph = text.length === 0;
-                            // move out the empty paragraph if end of the quote
-                            if (isEnd && isEmptyParagraph) {
-                                event.preventDefault();
-                                const moveto = quotePath.slice();
-                                moveto[(quotePath.length - 1)] += 1;
-                                Transforms.moveNodes(editor, {
-                                    at: editor.selection,
-                                    to: moveto,
-                                });
-                                return;
-                            }
-                        }
-                    }
-                    onKeyDownBreak(event, editor, next);
-                }
-            },
-        }), createRenderElement: ({ render = defaultRenderBlockquoteElement } = {}) => createRenderElement({ type, render }) });
+const BLOCKQUOTE_EXIT_BREAK_HOTKEY = 'enter';
+function createReactBlockquote(options = {}) {
+    const core = createBlockquote(options);
+    const { type } = core;
+    const onKeyDownBreak = createOnKeyDownBreak({
+        exitBreak: {
+            rules: [
+                {
+                    hotkey: BLOCKQUOTE_EXIT_BREAK_HOTKEY,
+                    match: {
+                        includeTypes: [type],
+                    },
+                },
+            ],
+        },
+        softBreak: {
+            rules: [
+                {
+                    hotkey: COMMON_SOFT_BREAK_HOTKEY,
+                    match: {
+                        includeTypes: [type],
+                    },
+                },
+            ],
+        },
+    });
+    return Object.assign(Object.assign({}, core), { createHandlers: ({ hotkey = BLOCKQUOTE_HOTKEY } = {}) => ({
+            onKeyDown: (event, editor, next) => {
+                if (isHotkey(hotkey, event)) {
+                    core.toggleBlockquote(editor);
+                }
+                else {
+                    if (editor.selection && isHotkey(BLOCKQUOTE_EXIT_BREAK_HOTKEY, event)) {
+                        const [highestIsQuote] = getNodesByTypes(editor, [type], { mode: 'highest' });
+                        const [selectInParagraph] = getNodesByTypes(editor, [PARAGRAPH_TYPE], { at: editor.selection });
+                        if (highestIsQuote && selectInParagraph) {
+                            const [, quotePath] = highestIsQuote;
+                            const isEnd = Editor.isEnd(editor, Editor.point(editor, editor.selection), quotePath);
+                            const [paragraphNode] = selectInParagraph;
+                            const text = paragraphNode.children[0].text;
+                            const isEmptyParagraph = text.length === 0;
+                            // move out the empty paragraph if end of the quote
+                            if (isEnd && isEmptyParagraph) {
+                                event.preventDefault();
+                                const moveto = quotePath.slice();
+                                moveto[(quotePath.length - 1)] += 1;
+                                Transforms.moveNodes(editor, {
+                                    at: editor.selection,
+                                    to: moveto,
+                                });
+                                return;
+                            }
+                        }
+                    }
+                    onKeyDownBreak(event, editor, next);
+                }
+            },
+        }), createRenderElement: ({ render = defaultRenderBlockquoteElement } = {}) => createRenderElement({ type, render }) });
 }
 
 export { BLOCKQUOTE_EXIT_BREAK_HOTKEY, createReactBlockquote };

package/blockquote/defaultRenderBlockquoteElement.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="react" />
+import React from 'react';
 import { RenderElementProps } from '@quadrats/react';
 export declare const defaultRenderBlockquoteElement: ({ attributes, children, }: {
     attributes?: {
@@ -9,4 +9,4 @@ export declare const defaultRenderBlockquoteElement: ({ attributes, children, }:
         ref: any;
     } | undefined;
     children: RenderElementProps['children'];
-}) => JSX.Element;
+}) => React.JSX.Element;

package/blockquote/index.cjs.js

@@ -1,7 +1,5 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var React = require('react');
 var isHotkey = require('is-hotkey');
 var blockquote = require('@quadrats/common/blockquote');
@@ -9,78 +7,73 @@ var react = require('@quadrats/react');
 var lineBreak = require('@quadrats/react/line-break');
 var core = require('@quadrats/core');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }
-
-var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
-var isHotkey__default = /*#__PURE__*/_interopDefaultLegacy(isHotkey);
-
-/**
- * Default hotkey for toggling blockquote.
- *
- * @see [is-hotkey]{@link https://www.npmjs.com/package/is-hotkey}
- */
+/**
+ * Default hotkey for toggling blockquote.
+ *
+ * @see [is-hotkey]{@link https://www.npmjs.com/package/is-hotkey}
+ */
 const BLOCKQUOTE_HOTKEY = 'ctrl+opt+q';
 
-const defaultRenderBlockquoteElement = ({ attributes, children, }) => React__default.createElement("blockquote", Object.assign({}, attributes, { className: "qdr-blockquote" }), children);
+const defaultRenderBlockquoteElement = ({ attributes, children, }) => React.createElement("blockquote", Object.assign({}, attributes, { className: "qdr-blockquote" }), children);
 
-const BLOCKQUOTE_EXIT_BREAK_HOTKEY = 'enter';
-function createReactBlockquote(options = {}) {
-    const core$1 = blockquote.createBlockquote(options);
-    const { type } = core$1;
-    const onKeyDownBreak = lineBreak.createOnKeyDownBreak({
-        exitBreak: {
-            rules: [
-                {
-                    hotkey: BLOCKQUOTE_EXIT_BREAK_HOTKEY,
-                    match: {
-                        includeTypes: [type],
-                    },
-                },
-            ],
-        },
-        softBreak: {
-            rules: [
-                {
-                    hotkey: lineBreak.COMMON_SOFT_BREAK_HOTKEY,
-                    match: {
-                        includeTypes: [type],
-                    },
-                },
-            ],
-        },
-    });
-    return Object.assign(Object.assign({}, core$1), { createHandlers: ({ hotkey = BLOCKQUOTE_HOTKEY } = {}) => ({
-            onKeyDown: (event, editor, next) => {
-                if (isHotkey__default(hotkey, event)) {
-                    core$1.toggleBlockquote(editor);
-                }
-                else {
-                    if (editor.selection && isHotkey__default(BLOCKQUOTE_EXIT_BREAK_HOTKEY, event)) {
-                        const [highestIsQuote] = core.getNodesByTypes(editor, [type], { mode: 'highest' });
-                        const [selectInParagraph] = core.getNodesByTypes(editor, [core.PARAGRAPH_TYPE], { at: editor.selection });
-                        if (highestIsQuote && selectInParagraph) {
-                            const [, quotePath] = highestIsQuote;
-                            const isEnd = core.Editor.isEnd(editor, core.Editor.point(editor, editor.selection), quotePath);
-                            const [paragraphNode] = selectInParagraph;
-                            const text = paragraphNode.children[0].text;
-                            const isEmptyParagraph = text.length === 0;
-                            // move out the empty paragraph if end of the quote
-                            if (isEnd && isEmptyParagraph) {
-                                event.preventDefault();
-                                const moveto = quotePath.slice();
-                                moveto[(quotePath.length - 1)] += 1;
-                                core.Transforms.moveNodes(editor, {
-                                    at: editor.selection,
-                                    to: moveto,
-                                });
-                                return;
-                            }
-                        }
-                    }
-                    onKeyDownBreak(event, editor, next);
-                }
-            },
-        }), createRenderElement: ({ render = defaultRenderBlockquoteElement } = {}) => react.createRenderElement({ type, render }) });
+const BLOCKQUOTE_EXIT_BREAK_HOTKEY = 'enter';
+function createReactBlockquote(options = {}) {
+    const core$1 = blockquote.createBlockquote(options);
+    const { type } = core$1;
+    const onKeyDownBreak = lineBreak.createOnKeyDownBreak({
+        exitBreak: {
+            rules: [
+                {
+                    hotkey: BLOCKQUOTE_EXIT_BREAK_HOTKEY,
+                    match: {
+                        includeTypes: [type],
+                    },
+                },
+            ],
+        },
+        softBreak: {
+            rules: [
+                {
+                    hotkey: lineBreak.COMMON_SOFT_BREAK_HOTKEY,
+                    match: {
+                        includeTypes: [type],
+                    },
+                },
+            ],
+        },
+    });
+    return Object.assign(Object.assign({}, core$1), { createHandlers: ({ hotkey = BLOCKQUOTE_HOTKEY } = {}) => ({
+            onKeyDown: (event, editor, next) => {
+                if (isHotkey(hotkey, event)) {
+                    core$1.toggleBlockquote(editor);
+                }
+                else {
+                    if (editor.selection && isHotkey(BLOCKQUOTE_EXIT_BREAK_HOTKEY, event)) {
+                        const [highestIsQuote] = core.getNodesByTypes(editor, [type], { mode: 'highest' });
+                        const [selectInParagraph] = core.getNodesByTypes(editor, [core.PARAGRAPH_TYPE], { at: editor.selection });
+                        if (highestIsQuote && selectInParagraph) {
+                            const [, quotePath] = highestIsQuote;
+                            const isEnd = core.Editor.isEnd(editor, core.Editor.point(editor, editor.selection), quotePath);
+                            const [paragraphNode] = selectInParagraph;
+                            const text = paragraphNode.children[0].text;
+                            const isEmptyParagraph = text.length === 0;
+                            // move out the empty paragraph if end of the quote
+                            if (isEnd && isEmptyParagraph) {
+                                event.preventDefault();
+                                const moveto = quotePath.slice();
+                                moveto[(quotePath.length - 1)] += 1;
+                                core.Transforms.moveNodes(editor, {
+                                    at: editor.selection,
+                                    to: moveto,
+                                });
+                                return;
+                            }
+                        }
+                    }
+                    onKeyDownBreak(event, editor, next);
+                }
+            },
+        }), createRenderElement: ({ render = defaultRenderBlockquoteElement } = {}) => react.createRenderElement({ type, render }) });
 }
 
 exports.BLOCKQUOTE_HOTKEY = BLOCKQUOTE_HOTKEY;

package/blockquote/jsx-serializer/createJsxSerializeBlockquote.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="react" />
 import { CreateJsxSerializeElementOptions } from '@quadrats/react/jsx-serializer';
 import { JsxSerializeBlockquoteElementProps } from './typings';
-export declare type CreateJsxSerializeBlockquoteOptions = Partial<CreateJsxSerializeElementOptions<JsxSerializeBlockquoteElementProps>>;
-export declare function createJsxSerializeBlockquote(options?: CreateJsxSerializeBlockquoteOptions): (props: import("@quadrats/react/jsx-serializer").JsxSerializeElementProps<import("@quadrats/core").QuadratsElement>) => JSX.Element | null | undefined;
+export type CreateJsxSerializeBlockquoteOptions = Partial<CreateJsxSerializeElementOptions<JsxSerializeBlockquoteElementProps>>;
+export declare function createJsxSerializeBlockquote(options?: CreateJsxSerializeBlockquoteOptions): (props: import("@quadrats/react/jsx-serializer").JsxSerializeElementProps) => JSX.Element | null | undefined;

package/blockquote/jsx-serializer/createJsxSerializeBlockquote.js

@@ -2,9 +2,9 @@ import { BLOCKQUOTE_TYPE } from '@quadrats/common/blockquote';
 import { createJsxSerializeElement } from '@quadrats/react/jsx-serializer';
 import { defaultRenderBlockquoteElement } from '@quadrats/react/blockquote';
 
-function createJsxSerializeBlockquote(options = {}) {
-    const { type = BLOCKQUOTE_TYPE, render = defaultRenderBlockquoteElement } = options;
-    return createJsxSerializeElement({ type, render });
+function createJsxSerializeBlockquote(options = {}) {
+    const { type = BLOCKQUOTE_TYPE, render = defaultRenderBlockquoteElement } = options;
+    return createJsxSerializeElement({ type, render });
 }
 
 export { createJsxSerializeBlockquote };

package/blockquote/jsx-serializer/index.cjs.js

@@ -1,14 +1,12 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var blockquote = require('@quadrats/react/blockquote');
 var blockquote$1 = require('@quadrats/common/blockquote');
 var jsxSerializer = require('@quadrats/react/jsx-serializer');
 
-function createJsxSerializeBlockquote(options = {}) {
-    const { type = blockquote$1.BLOCKQUOTE_TYPE, render = blockquote.defaultRenderBlockquoteElement } = options;
-    return jsxSerializer.createJsxSerializeElement({ type, render });
+function createJsxSerializeBlockquote(options = {}) {
+    const { type = blockquote$1.BLOCKQUOTE_TYPE, render = blockquote.defaultRenderBlockquoteElement } = options;
+    return jsxSerializer.createJsxSerializeElement({ type, render });
 }
 
 exports.defaultRenderBlockquoteElement = blockquote.defaultRenderBlockquoteElement;

package/blockquote/jsx-serializer/typings.d.ts

@@ -1,3 +1,3 @@
 import { BlockquoteElement } from '@quadrats/common/blockquote';
 import { JsxSerializeElementProps } from '@quadrats/react/jsx-serializer';
-export declare type JsxSerializeBlockquoteElementProps = JsxSerializeElementProps<BlockquoteElement>;
+export type JsxSerializeBlockquoteElementProps = JsxSerializeElementProps<BlockquoteElement>;

package/blockquote/toolbar/BlockquoteToolbarIcon.d.ts

@@ -1,8 +1,8 @@
-/// <reference types="react" />
+import React from 'react';
 import { ToolbarIconProps } from '@quadrats/react/toolbar';
 import { ReactBlockquote } from '@quadrats/react/blockquote';
 export interface BlockquoteToolbarIconProps extends Omit<ToolbarIconProps, 'active' | 'onClick'> {
     controller: ReactBlockquote;
 }
-declare function BlockquoteToolbarIcon(props: BlockquoteToolbarIconProps): JSX.Element;
+declare function BlockquoteToolbarIcon(props: BlockquoteToolbarIconProps): React.JSX.Element;
 export default BlockquoteToolbarIcon;

package/blockquote/toolbar/BlockquoteToolbarIcon.js

@@ -3,10 +3,10 @@ import React from 'react';
 import { ToolbarIcon } from '@quadrats/react/toolbar';
 import { useBlockquoteTool } from './useBlockquoteTool.js';
 
-function BlockquoteToolbarIcon(props) {
-    const { controller } = props, rest = __rest(props, ["controller"]);
-    const { active, onClick } = useBlockquoteTool(controller);
-    return React.createElement(ToolbarIcon, Object.assign({}, rest, { active: active, onClick: onClick }));
+function BlockquoteToolbarIcon(props) {
+    const { controller } = props, rest = __rest(props, ["controller"]);
+    const { active, onClick } = useBlockquoteTool(controller);
+    return React.createElement(ToolbarIcon, Object.assign({}, rest, { active: active, onClick: onClick }));
 }
 
 export { BlockquoteToolbarIcon as default };

package/blockquote/toolbar/index.cjs.js

@@ -1,28 +1,22 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var react = require('@quadrats/react');
 var tslib = require('tslib');
 var React = require('react');
 var toolbar = require('@quadrats/react/toolbar');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }
-
-var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
-
-function useBlockquoteTool(controller) {
-    const editor = react.useQuadrats();
-    return {
-        active: controller.isSelectionInBlockquote(editor),
-        onClick: () => controller.toggleBlockquote(editor),
-    };
+function useBlockquoteTool(controller) {
+    const editor = react.useQuadrats();
+    return {
+        active: controller.isSelectionInBlockquote(editor),
+        onClick: () => controller.toggleBlockquote(editor),
+    };
 }
 
-function BlockquoteToolbarIcon(props) {
-    const { controller } = props, rest = tslib.__rest(props, ["controller"]);
-    const { active, onClick } = useBlockquoteTool(controller);
-    return React__default.createElement(toolbar.ToolbarIcon, Object.assign({}, rest, { active: active, onClick: onClick }));
+function BlockquoteToolbarIcon(props) {
+    const { controller } = props, rest = tslib.__rest(props, ["controller"]);
+    const { active, onClick } = useBlockquoteTool(controller);
+    return React.createElement(toolbar.ToolbarIcon, Object.assign({}, rest, { active: active, onClick: onClick }));
 }
 
 exports.BlockquoteToolbarIcon = BlockquoteToolbarIcon;