@vendure/admin-ui 1.7.4 → 1.8.0

package/package/esm2015/core/shared/components/rich-text-editor/prosemirror/plugins/tables-plugin.js

@@ -0,0 +1,166 @@
+import { MenuItem } from 'prosemirror-menu';
+import { Plugin, TextSelection } from 'prosemirror-state';
+import { addColumnAfter, addColumnBefore, addRowAfter, addRowBefore, deleteColumn, deleteRow, deleteTable, isInTable, mergeCells, splitCell, tableNodes, tableNodeTypes, toggleHeaderCell, toggleHeaderColumn, toggleHeaderRow, } from 'prosemirror-tables';
+import { renderClarityIcon } from '../menu/menu-common';
+export const tableContextMenuPlugin = (contextMenuService) => new Plugin({
+    view: () => {
+        return {
+            update: view => {
+                if (!view.hasFocus()) {
+                    return;
+                }
+                const { doc, selection } = view.state;
+                let tableNode;
+                let tableNodePos = 0;
+                doc.nodesBetween(selection.from, selection.to, (n, pos, parent) => {
+                    if (n.type.name === 'table') {
+                        tableNode = n;
+                        tableNodePos = pos;
+                        return false;
+                    }
+                });
+                if (tableNode) {
+                    const node = view.nodeDOM(tableNodePos);
+                    if (node instanceof Element) {
+                        function createMenuItem(label, commandFn, iconClass) {
+                            const enabled = commandFn(view.state);
+                            return {
+                                label,
+                                enabled,
+                                iconClass,
+                                onClick: () => {
+                                    contextMenuService.clearContextMenu();
+                                    view.focus();
+                                    commandFn(view.state, view.dispatch);
+                                },
+                            };
+                        }
+                        const separator = {
+                            label: '',
+                            separator: true,
+                            enabled: true,
+                            onClick: () => {
+                                /**/
+                            },
+                        };
+                        contextMenuService.setContextMenu({
+                            ref: selection,
+                            title: 'Table',
+                            iconShape: 'table',
+                            element: node,
+                            coords: view.coordsAtPos(tableNodePos),
+                            items: [
+                                createMenuItem('Insert column before', addColumnBefore, 'add-column'),
+                                createMenuItem('Insert column after', addColumnAfter, 'add-column'),
+                                createMenuItem('Insert row before', addRowBefore, 'add-row'),
+                                createMenuItem('Insert row after', addRowAfter, 'add-row'),
+                                createMenuItem('Merge cells', mergeCells),
+                                createMenuItem('Split cell', splitCell),
+                                separator,
+                                createMenuItem('Toggle header column', toggleHeaderColumn),
+                                createMenuItem('Toggle header row', toggleHeaderRow),
+                                separator,
+                                createMenuItem('Delete column', deleteColumn),
+                                createMenuItem('Delete row', deleteRow),
+                                createMenuItem('Delete table', deleteTable),
+                            ],
+                        });
+                    }
+                }
+                else {
+                    contextMenuService.clearContextMenu();
+                }
+            },
+        };
+    },
+});
+export function getTableNodes() {
+    return tableNodes({
+        tableGroup: 'block',
+        cellContent: 'block+',
+        cellAttributes: {
+            background: {
+                default: null,
+                getFromDOM(dom) {
+                    return dom.style.backgroundColor || null;
+                },
+                setDOMAttr(value, attrs) {
+                    if (value) {
+                        attrs.style = (attrs.style || '') + `background-color: ${value};`;
+                    }
+                },
+            },
+        },
+    });
+}
+export function getTableMenu(schema) {
+    function item(label, cmd, iconShape) {
+        return new MenuItem({
+            label,
+            select: cmd,
+            run: cmd,
+            render: iconShape ? renderClarityIcon({ shape: iconShape, label }) : undefined,
+        });
+    }
+    function separator() {
+        return new MenuItem({
+            select: state => isInTable(state),
+            run: state => {
+                /**/
+            },
+            render: view => {
+                const el = document.createElement('div');
+                el.classList.add('menu-separator');
+                return el;
+            },
+        });
+    }
+    return [
+        item('Insert column before', addColumnBefore),
+        item('Insert column after', addColumnAfter),
+        item('Insert row before', addRowBefore),
+        item('Insert row after', addRowAfter),
+        item('Merge cells', mergeCells),
+        item('Split cell', splitCell),
+        separator(),
+        item('Toggle header column', toggleHeaderColumn),
+        item('Toggle header row', toggleHeaderRow),
+        item('Toggle header cells', toggleHeaderCell),
+        separator(),
+        item('Delete column', deleteColumn),
+        item('Delete row', deleteRow),
+        item('Delete table', deleteTable),
+    ];
+}
+export function addTable(state, dispatch, { rowsCount, colsCount, withHeaderRow, cellContent }) {
+    const offset = state.tr.selection.anchor + 1;
+    const nodes = createTable(state, rowsCount, colsCount, withHeaderRow, cellContent);
+    const tr = state.tr.replaceSelectionWith(nodes).scrollIntoView();
+    const resolvedPos = tr.doc.resolve(offset);
+    tr.setSelection(TextSelection.near(resolvedPos));
+    dispatch(tr);
+}
+function createTable(state, rowsCount, colsCount, withHeaderRow, cellContent) {
+    const types = tableNodeTypes(state.schema);
+    const headerCells = [];
+    const cells = [];
+    const createCell = (cellType, _cellContent) => _cellContent ? cellType.createChecked(null, _cellContent) : cellType.createAndFill();
+    for (let index = 0; index < colsCount; index += 1) {
+        const cell = createCell(types.cell, cellContent);
+        if (cell) {
+            cells.push(cell);
+        }
+        if (withHeaderRow) {
+            const headerCell = createCell(types.header_cell, cellContent);
+            if (headerCell) {
+                headerCells.push(headerCell);
+            }
+        }
+    }
+    const rows = [];
+    for (let index = 0; index < rowsCount; index += 1) {
+        rows.push(types.row.createChecked(null, withHeaderRow && index === 0 ? headerCells : cells));
+    }
+    return types.table.createChecked(null, rows);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tables-plugin.js","sourceRoot":"","sources":["../../../../../../../../src/lib/core/src/shared/components/rich-text-editor/prosemirror/plugins/tables-plugin.ts"],"names":[],"mappings":"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","sourcesContent":["import { MenuElement, MenuItem } from 'prosemirror-menu';\r\nimport { Node, Schema } from 'prosemirror-model';\r\nimport { EditorState, Plugin, TextSelection, Transaction } from 'prosemirror-state';\r\nimport {\r\n    addColumnAfter,\r\n    addColumnBefore,\r\n    addRowAfter,\r\n    addRowBefore,\r\n    deleteColumn,\r\n    deleteRow,\r\n    deleteTable,\r\n    isInTable,\r\n    mergeCells,\r\n    splitCell,\r\n    tableNodes,\r\n    tableNodeTypes,\r\n    toggleHeaderCell,\r\n    toggleHeaderColumn,\r\n    toggleHeaderRow,\r\n} from 'prosemirror-tables';\r\nimport { Decoration, DecorationSet } from 'prosemirror-view';\r\n\r\nimport { ContextMenuItem, ContextMenuService } from '../context-menu/context-menu.service';\r\nimport { buildMenuItems } from '../menu/menu';\r\nimport { renderClarityIcon } from '../menu/menu-common';\r\n\r\nexport const tableContextMenuPlugin = (contextMenuService: ContextMenuService) =>\r\n    new Plugin({\r\n        view: () => {\r\n            return {\r\n                update: view => {\r\n                    if (!view.hasFocus()) {\r\n                        return;\r\n                    }\r\n                    const { doc, selection } = view.state;\r\n                    let tableNode: Node | undefined;\r\n                    let tableNodePos = 0;\r\n                    doc.nodesBetween(selection.from, selection.to, (n, pos, parent) => {\r\n                        if (n.type.name === 'table') {\r\n                            tableNode = n;\r\n                            tableNodePos = pos;\r\n                            return false;\r\n                        }\r\n                    });\r\n                    if (tableNode) {\r\n                        const node = view.nodeDOM(tableNodePos);\r\n                        if (node instanceof Element) {\r\n                            function createMenuItem(\r\n                                label: string,\r\n                                commandFn: (\r\n                                    state: EditorState,\r\n                                    dispatch?: (tr: Transaction) => void,\r\n                                ) => boolean,\r\n                                iconClass?: string,\r\n                            ): ContextMenuItem {\r\n                                const enabled = commandFn(view.state);\r\n                                return {\r\n                                    label,\r\n                                    enabled,\r\n                                    iconClass,\r\n                                    onClick: () => {\r\n                                        contextMenuService.clearContextMenu();\r\n                                        view.focus();\r\n                                        commandFn(view.state, view.dispatch);\r\n                                    },\r\n                                };\r\n                            }\r\n                            const separator: ContextMenuItem = {\r\n                                label: '',\r\n                                separator: true,\r\n                                enabled: true,\r\n                                onClick: () => {\r\n                                    /**/\r\n                                },\r\n                            };\r\n                            contextMenuService.setContextMenu({\r\n                                ref: selection,\r\n                                title: 'Table',\r\n                                iconShape: 'table',\r\n                                element: node,\r\n                                coords: view.coordsAtPos(tableNodePos),\r\n                                items: [\r\n                                    createMenuItem('Insert column before', addColumnBefore, 'add-column'),\r\n                                    createMenuItem('Insert column after', addColumnAfter, 'add-column'),\r\n                                    createMenuItem('Insert row before', addRowBefore, 'add-row'),\r\n                                    createMenuItem('Insert row after', addRowAfter, 'add-row'),\r\n                                    createMenuItem('Merge cells', mergeCells),\r\n                                    createMenuItem('Split cell', splitCell),\r\n                                    separator,\r\n                                    createMenuItem('Toggle header column', toggleHeaderColumn),\r\n                                    createMenuItem('Toggle header row', toggleHeaderRow),\r\n                                    separator,\r\n                                    createMenuItem('Delete column', deleteColumn),\r\n                                    createMenuItem('Delete row', deleteRow),\r\n                                    createMenuItem('Delete table', deleteTable),\r\n                                ],\r\n                            });\r\n                        }\r\n                    } else {\r\n                        contextMenuService.clearContextMenu();\r\n                    }\r\n                },\r\n            };\r\n        },\r\n    });\r\n\r\nexport function getTableNodes() {\r\n    return tableNodes({\r\n        tableGroup: 'block',\r\n        cellContent: 'block+',\r\n        cellAttributes: {\r\n            background: {\r\n                default: null,\r\n                getFromDOM(dom) {\r\n                    return (dom as HTMLElement).style.backgroundColor || null;\r\n                },\r\n                setDOMAttr(value, attrs) {\r\n                    if (value) {\r\n                        attrs.style = (attrs.style || '') + `background-color: ${value};`;\r\n                    }\r\n                },\r\n            },\r\n        },\r\n    });\r\n}\r\n\r\nexport function getTableMenu(schema: Schema) {\r\n    function item(\r\n        label: string,\r\n        cmd: (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean,\r\n        iconShape?: string,\r\n    ) {\r\n        return new MenuItem({\r\n            label,\r\n            select: cmd,\r\n            run: cmd,\r\n            render: iconShape ? renderClarityIcon({ shape: iconShape, label }) : undefined,\r\n        });\r\n    }\r\n\r\n    function separator(): MenuElement {\r\n        return new MenuItem({\r\n            select: state => isInTable(state),\r\n            run: state => {\r\n                /**/\r\n            },\r\n            render: view => {\r\n                const el = document.createElement('div');\r\n                el.classList.add('menu-separator');\r\n                return el;\r\n            },\r\n        });\r\n    }\r\n\r\n    return [\r\n        item('Insert column before', addColumnBefore),\r\n        item('Insert column after', addColumnAfter),\r\n        item('Insert row before', addRowBefore),\r\n        item('Insert row after', addRowAfter),\r\n        item('Merge cells', mergeCells),\r\n        item('Split cell', splitCell),\r\n        separator(),\r\n        item('Toggle header column', toggleHeaderColumn),\r\n        item('Toggle header row', toggleHeaderRow),\r\n        item('Toggle header cells', toggleHeaderCell),\r\n        separator(),\r\n        item('Delete column', deleteColumn),\r\n        item('Delete row', deleteRow),\r\n        item('Delete table', deleteTable),\r\n    ];\r\n}\r\n\r\nexport function addTable(state, dispatch, { rowsCount, colsCount, withHeaderRow, cellContent }) {\r\n    const offset = state.tr.selection.anchor + 1;\r\n\r\n    const nodes = createTable(state, rowsCount, colsCount, withHeaderRow, cellContent);\r\n    const tr = state.tr.replaceSelectionWith(nodes).scrollIntoView();\r\n    const resolvedPos = tr.doc.resolve(offset);\r\n\r\n    tr.setSelection(TextSelection.near(resolvedPos));\r\n\r\n    dispatch(tr);\r\n}\r\n\r\nfunction createTable(state, rowsCount, colsCount, withHeaderRow, cellContent) {\r\n    const types = tableNodeTypes(state.schema);\r\n    const headerCells: Node[] = [];\r\n    const cells: Node[] = [];\r\n    const createCell = (cellType, _cellContent) =>\r\n        _cellContent ? cellType.createChecked(null, _cellContent) : cellType.createAndFill();\r\n\r\n    for (let index = 0; index < colsCount; index += 1) {\r\n        const cell = createCell(types.cell, cellContent);\r\n\r\n        if (cell) {\r\n            cells.push(cell);\r\n        }\r\n\r\n        if (withHeaderRow) {\r\n            const headerCell = createCell(types.header_cell, cellContent);\r\n\r\n            if (headerCell) {\r\n                headerCells.push(headerCell);\r\n            }\r\n        }\r\n    }\r\n\r\n    const rows: Node[] = [];\r\n\r\n    for (let index = 0; index < rowsCount; index += 1) {\r\n        rows.push(types.row.createChecked(null, withHeaderRow && index === 0 ? headerCells : cells));\r\n    }\r\n\r\n    return types.table.createChecked(null, rows);\r\n}\r\n"]}

package/package/esm2015/core/shared/components/rich-text-editor/prosemirror/prosemirror.service.js

@@ -0,0 +1,142 @@
+import { Injectable, Injector } from '@angular/core';
+import { baseKeymap } from 'prosemirror-commands';
+import { dropCursor } from 'prosemirror-dropcursor';
+import { gapCursor } from 'prosemirror-gapcursor';
+import { history } from 'prosemirror-history';
+import { keymap } from 'prosemirror-keymap';
+import { DOMParser, DOMSerializer, Schema } from 'prosemirror-model';
+import { schema } from 'prosemirror-schema-basic';
+import { addListNodes } from 'prosemirror-schema-list';
+import { EditorState, Plugin } from 'prosemirror-state';
+import { columnResizing, fixTables, tableEditing } from 'prosemirror-tables';
+import { EditorView } from 'prosemirror-view';
+import { ModalService } from '../../../../providers/modal/modal.service';
+import { ContextMenuService } from './context-menu/context-menu.service';
+import { iframeNode, iframeNodeView } from './custom-nodes';
+import { buildInputRules } from './inputrules';
+import { buildKeymap } from './keymap';
+import { customMenuPlugin } from './menu/menu-plugin';
+import { imageContextMenuPlugin } from './plugins/image-plugin';
+import { linkSelectPlugin } from './plugins/link-select-plugin';
+import { rawEditorPlugin } from './plugins/raw-editor-plugin';
+import { getTableNodes, tableContextMenuPlugin } from './plugins/tables-plugin';
+export class ProsemirrorService {
+    constructor(injector, contextMenuService) {
+        this.injector = injector;
+        this.contextMenuService = contextMenuService;
+        // Mix the nodes from prosemirror-schema-list into the basic schema to
+        // create a schema with list support.
+        this.mySchema = new Schema({
+            nodes: addListNodes(schema.spec.nodes, 'paragraph block*', 'block')
+                .append(getTableNodes())
+                .addToEnd('iframe', iframeNode),
+            marks: schema.spec.marks,
+        });
+        this.enabled = true;
+    }
+    createEditorView(options) {
+        this.editorView = new EditorView(options.element, {
+            state: this.getStateFromText(''),
+            dispatchTransaction: tr => {
+                if (!this.enabled) {
+                    return;
+                }
+                this.editorView.updateState(this.editorView.state.apply(tr));
+                if (tr.docChanged) {
+                    const content = this.getTextFromState(this.editorView.state);
+                    options.onTextInput(content);
+                }
+            },
+            editable: () => options.isReadOnly(),
+            handleDOMEvents: {
+                focus: view => {
+                    this.contextMenuService.setVisibility(true);
+                },
+                blur: view => {
+                    this.contextMenuService.setVisibility(false);
+                },
+            },
+            nodeViews: {
+                iframe: iframeNodeView,
+            },
+        });
+    }
+    update(text) {
+        if (this.editorView) {
+            const currentText = this.getTextFromState(this.editorView.state);
+            if (text !== currentText) {
+                let state = this.getStateFromText(text);
+                if (document.body.contains(this.editorView.dom)) {
+                    const fix = fixTables(state);
+                    if (fix)
+                        state = state.apply(fix.setMeta('addToHistory', false));
+                    this.editorView.updateState(state);
+                }
+            }
+        }
+    }
+    destroy() {
+        if (this.editorView) {
+            this.editorView.destroy();
+        }
+    }
+    setEnabled(enabled) {
+        if (this.editorView) {
+            this.enabled = enabled;
+            // Updating the state causes ProseMirror to check the
+            // `editable()` function from the contructor config object
+            // newly.
+            this.editorView.updateState(this.editorView.state);
+        }
+    }
+    getStateFromText(text) {
+        const div = document.createElement('div');
+        div.innerHTML = text !== null && text !== void 0 ? text : '';
+        return EditorState.create({
+            doc: DOMParser.fromSchema(this.mySchema).parse(div),
+            plugins: this.configurePlugins({ schema: this.mySchema, floatingMenu: false }),
+        });
+    }
+    getTextFromState(state) {
+        const div = document.createElement('div');
+        const fragment = DOMSerializer.fromSchema(this.mySchema).serializeFragment(state.doc.content);
+        div.appendChild(fragment);
+        return div.innerHTML;
+    }
+    configurePlugins(options) {
+        const plugins = [
+            buildInputRules(options.schema),
+            keymap(buildKeymap(options.schema, options.mapKeys)),
+            keymap(baseKeymap),
+            dropCursor(),
+            gapCursor(),
+            linkSelectPlugin,
+            columnResizing({}),
+            tableEditing({ allowTableNodeSelection: true }),
+            tableContextMenuPlugin(this.contextMenuService),
+            imageContextMenuPlugin(this.contextMenuService, this.injector.get(ModalService)),
+            rawEditorPlugin(this.contextMenuService, this.injector.get(ModalService)),
+            customMenuPlugin({
+                floatingMenu: options.floatingMenu,
+                injector: this.injector,
+                schema: options.schema,
+            }),
+        ];
+        if (options.history !== false) {
+            plugins.push(history());
+        }
+        return plugins.concat(new Plugin({
+            props: {
+                attributes: { class: 'vdr-prosemirror' },
+            },
+        }));
+    }
+}
+ProsemirrorService.decorators = [
+    { type: Injectable }
+];
+ProsemirrorService.ctorParameters = () => [
+    { type: Injector },
+    { type: ContextMenuService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"prosemirror.service.js","sourceRoot":"","sources":["../../../../../../../src/lib/core/src/shared/components/rich-text-editor/prosemirror/prosemirror.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Injector } from '@angular/core';\r\nimport { baseKeymap } from 'prosemirror-commands';\r\nimport { dropCursor } from 'prosemirror-dropcursor';\r\nimport { gapCursor } from 'prosemirror-gapcursor';\r\nimport { history } from 'prosemirror-history';\r\nimport { keymap } from 'prosemirror-keymap';\r\nimport { DOMParser, DOMSerializer, Schema } from 'prosemirror-model';\r\nimport { schema } from 'prosemirror-schema-basic';\r\nimport { addListNodes } from 'prosemirror-schema-list';\r\nimport { EditorState, Plugin } from 'prosemirror-state';\r\nimport { columnResizing, fixTables, tableEditing } from 'prosemirror-tables';\r\nimport { EditorView } from 'prosemirror-view';\r\nimport { Observable } from 'rxjs';\r\n\r\nimport { ModalService } from '../../../../providers/modal/modal.service';\r\n\r\nimport { ContextMenuService } from './context-menu/context-menu.service';\r\nimport { iframeNode, iframeNodeView } from './custom-nodes';\r\nimport { buildInputRules } from './inputrules';\r\nimport { buildKeymap } from './keymap';\r\nimport { customMenuPlugin } from './menu/menu-plugin';\r\nimport { imageContextMenuPlugin } from './plugins/image-plugin';\r\nimport { linkSelectPlugin } from './plugins/link-select-plugin';\r\nimport { rawEditorPlugin } from './plugins/raw-editor-plugin';\r\nimport { getTableNodes, tableContextMenuPlugin } from './plugins/tables-plugin';\r\nimport { SetupOptions } from './types';\r\n\r\nexport interface CreateEditorViewOptions {\r\n    onTextInput: (content: string) => void;\r\n    element: HTMLElement;\r\n    isReadOnly: () => boolean;\r\n}\r\n\r\n@Injectable()\r\nexport class ProsemirrorService {\r\n    editorView: EditorView;\r\n\r\n    // Mix the nodes from prosemirror-schema-list into the basic schema to\r\n    // create a schema with list support.\r\n    private mySchema = new Schema({\r\n        nodes: addListNodes(schema.spec.nodes, 'paragraph block*', 'block')\r\n            .append(getTableNodes() as any)\r\n            .addToEnd('iframe', iframeNode),\r\n        marks: schema.spec.marks,\r\n    });\r\n    private enabled = true;\r\n\r\n    constructor(private injector: Injector, private contextMenuService: ContextMenuService) {}\r\n\r\n    contextMenuItems$: Observable<string>;\r\n\r\n    createEditorView(options: CreateEditorViewOptions) {\r\n        this.editorView = new EditorView(options.element, {\r\n            state: this.getStateFromText(''),\r\n            dispatchTransaction: tr => {\r\n                if (!this.enabled) {\r\n                    return;\r\n                }\r\n                this.editorView.updateState(this.editorView.state.apply(tr));\r\n                if (tr.docChanged) {\r\n                    const content = this.getTextFromState(this.editorView.state);\r\n                    options.onTextInput(content);\r\n                }\r\n            },\r\n            editable: () => options.isReadOnly(),\r\n            handleDOMEvents: {\r\n                focus: view => {\r\n                    this.contextMenuService.setVisibility(true);\r\n                },\r\n                blur: view => {\r\n                    this.contextMenuService.setVisibility(false);\r\n                },\r\n            },\r\n            nodeViews: {\r\n                iframe: iframeNodeView,\r\n            },\r\n        });\r\n    }\r\n\r\n    update(text: string) {\r\n        if (this.editorView) {\r\n            const currentText = this.getTextFromState(this.editorView.state);\r\n            if (text !== currentText) {\r\n                let state = this.getStateFromText(text);\r\n                if (document.body.contains(this.editorView.dom)) {\r\n                    const fix = fixTables(state);\r\n                    if (fix) state = state.apply(fix.setMeta('addToHistory', false));\r\n                    this.editorView.updateState(state);\r\n                }\r\n            }\r\n        }\r\n    }\r\n\r\n    destroy() {\r\n        if (this.editorView) {\r\n            this.editorView.destroy();\r\n        }\r\n    }\r\n\r\n    setEnabled(enabled: boolean) {\r\n        if (this.editorView) {\r\n            this.enabled = enabled;\r\n            // Updating the state causes ProseMirror to check the\r\n            // `editable()` function from the contructor config object\r\n            // newly.\r\n            this.editorView.updateState(this.editorView.state);\r\n        }\r\n    }\r\n\r\n    private getStateFromText(text: string | null | undefined): EditorState {\r\n        const div = document.createElement('div');\r\n        div.innerHTML = text ?? '';\r\n        return EditorState.create({\r\n            doc: DOMParser.fromSchema(this.mySchema).parse(div),\r\n            plugins: this.configurePlugins({ schema: this.mySchema, floatingMenu: false }),\r\n        });\r\n    }\r\n\r\n    private getTextFromState(state: EditorState): string {\r\n        const div = document.createElement('div');\r\n        const fragment = DOMSerializer.fromSchema(this.mySchema).serializeFragment(state.doc.content);\r\n\r\n        div.appendChild(fragment);\r\n\r\n        return div.innerHTML;\r\n    }\r\n\r\n    private configurePlugins(options: SetupOptions) {\r\n        const plugins = [\r\n            buildInputRules(options.schema),\r\n            keymap(buildKeymap(options.schema, options.mapKeys)),\r\n            keymap(baseKeymap),\r\n            dropCursor(),\r\n            gapCursor(),\r\n            linkSelectPlugin,\r\n            columnResizing({}),\r\n            tableEditing({ allowTableNodeSelection: true }),\r\n            tableContextMenuPlugin(this.contextMenuService),\r\n            imageContextMenuPlugin(this.contextMenuService, this.injector.get(ModalService)),\r\n            rawEditorPlugin(this.contextMenuService, this.injector.get(ModalService)),\r\n            customMenuPlugin({\r\n                floatingMenu: options.floatingMenu,\r\n                injector: this.injector,\r\n                schema: options.schema,\r\n            }),\r\n        ];\r\n        if (options.history !== false) {\r\n            plugins.push(history());\r\n        }\r\n\r\n        return plugins.concat(\r\n            new Plugin({\r\n                props: {\r\n                    attributes: { class: 'vdr-prosemirror' },\r\n                },\r\n            }),\r\n        );\r\n    }\r\n}\r\n"]}

package/package/esm2015/core/shared/components/rich-text-editor/prosemirror/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvcmUvc3JjL3NoYXJlZC9jb21wb25lbnRzL3JpY2gtdGV4dC1lZGl0b3IvcHJvc2VtaXJyb3IvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE1lbnVJdGVtIH0gZnJvbSAncHJvc2VtaXJyb3ItbWVudSc7XHJcbmltcG9ydCB7IFNjaGVtYSB9IGZyb20gJ3Byb3NlbWlycm9yLW1vZGVsJztcclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgU2V0dXBPcHRpb25zIHtcclxuICAgIHNjaGVtYTogU2NoZW1hO1xyXG4gICAgbWFwS2V5cz86IEtleW1hcDtcclxuICAgIG1lbnVCYXI/OiBib29sZWFuO1xyXG4gICAgaGlzdG9yeT86IGJvb2xlYW47XHJcbiAgICBmbG9hdGluZ01lbnU/OiBib29sZWFuO1xyXG59XHJcblxyXG5leHBvcnQgdHlwZSBLZXltYXAgPSBSZWNvcmQ8c3RyaW5nLCBzdHJpbmcgfCBmYWxzZT47XHJcbiJdfQ==

package/package/esm2015/core/shared/components/rich-text-editor/raw-html-dialog/raw-html-dialog.component.js

@@ -0,0 +1,57 @@
+import { ChangeDetectionStrategy, Component } from '@angular/core';
+import { FormControl } from '@angular/forms';
+import { HtmlEditorFormInputComponent } from '../../../dynamic-form-inputs/code-editor-form-input/html-editor-form-input.component';
+export class RawHtmlDialogComponent {
+    constructor() {
+        this.formControl = new FormControl();
+        this.config = {
+            name: '',
+            type: '',
+            list: false,
+            required: true,
+            ui: { component: HtmlEditorFormInputComponent.id },
+        };
+    }
+    ngOnInit() {
+        this.formControl.setValue(this.process(this.html));
+    }
+    process(str) {
+        const div = document.createElement('div');
+        div.innerHTML = str.trim();
+        return this.format(div, 0).innerHTML.trim();
+    }
+    /**
+     * Taken from https://stackoverflow.com/a/26361620/772859
+     */
+    format(node, level = 0) {
+        const indentBefore = new Array(level++ + 1).join('\t');
+        const indentAfter = new Array(level - 1).join('\t');
+        let textNode;
+        // tslint:disable-next-line:prefer-for-of
+        for (let i = 0; i < node.children.length; i++) {
+            textNode = document.createTextNode('\n' + indentBefore);
+            node.insertBefore(textNode, node.children[i]);
+            this.format(node.children[i], level);
+            if (node.lastElementChild === node.children[i]) {
+                textNode = document.createTextNode('\n' + indentAfter);
+                node.appendChild(textNode);
+            }
+        }
+        return node;
+    }
+    cancel() {
+        this.resolveWith(undefined);
+    }
+    select() {
+        this.resolveWith(this.formControl.value);
+    }
+}
+RawHtmlDialogComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'vdr-raw-html-dialog',
+                template: "<vdr-dynamic-form-input\r\n                      [def]=\"config\"\r\n                      [control]=\"formControl\"\r\n                  ></vdr-dynamic-form-input>\r\n<ng-template vdrDialogButtons>\r\n    <button type=\"button\" class=\"btn btn-secondary\" (click)=\"cancel()\">\r\n       {{ 'common.cancel' | translate }}\r\n    </button>\r\n    <button type=\"submit\" (click)=\"select()\" class=\"btn btn-primary\" [disabled]=\"formControl.invalid\">\r\n        {{ 'common.update' | translate }}\r\n    </button>\r\n</ng-template>\r\n",
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                styles: [""]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/package/esm2015/core/shared/components/rich-text-editor/rich-text-editor.component.js

@@ -0,0 +1,97 @@
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, HostBinding, Input, ViewChild, ViewContainerRef, } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { ContextMenuService } from './prosemirror/context-menu/context-menu.service';
+import { ProsemirrorService } from './prosemirror/prosemirror.service';
+/**
+ * @description
+ * A rich text (HTML) editor based on Prosemirror (https://prosemirror.net/)
+ *
+ * @example
+ * ```HTML
+ * <vdr-rich-text-editor
+ *     [(ngModel)]="description"
+ *     label="Description"
+ * ></vdr-rich-text-editor>
+ * ```
+ *
+ * @docsCategory components
+ */
+export class RichTextEditorComponent {
+    constructor(changeDetector, prosemirrorService, viewContainerRef, contextMenuService) {
+        this.changeDetector = changeDetector;
+        this.prosemirrorService = prosemirrorService;
+        this.viewContainerRef = viewContainerRef;
+        this.contextMenuService = contextMenuService;
+        this._readonly = false;
+    }
+    set readonly(value) {
+        this._readonly = !!value;
+        this.prosemirrorService.setEnabled(!this._readonly);
+    }
+    get menuElement() {
+        return this.viewContainerRef.element.nativeElement.querySelector('.ProseMirror-menubar');
+    }
+    ngAfterViewInit() {
+        this.prosemirrorService.createEditorView({
+            element: this.editorEl.nativeElement,
+            onTextInput: content => {
+                this.onChange(content);
+                this.changeDetector.markForCheck();
+            },
+            isReadOnly: () => !this._readonly,
+        });
+        if (this.value) {
+            this.prosemirrorService.update(this.value);
+        }
+    }
+    ngOnDestroy() {
+        this.prosemirrorService.destroy();
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouch = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.prosemirrorService.setEnabled(!isDisabled);
+    }
+    writeValue(value) {
+        if (value !== this.value) {
+            this.value = value;
+            if (this.prosemirrorService) {
+                this.prosemirrorService.update(value);
+            }
+        }
+    }
+}
+RichTextEditorComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'vdr-rich-text-editor',
+                template: "<label class=\"clr-control-label\">{{ label }}</label>\r\n<div #editor></div>\r\n<vdr-context-menu [editorMenuElement]=\"menuElement\"></vdr-context-menu>\r\n",
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                providers: [
+                    {
+                        provide: NG_VALUE_ACCESSOR,
+                        useExisting: RichTextEditorComponent,
+                        multi: true,
+                    },
+                    ProsemirrorService,
+                    ContextMenuService,
+                ],
+                styles: ["@charset \"UTF-8\";::ng-deep .ProseMirror{position:relative}::ng-deep .ProseMirror{word-wrap:break-word;white-space:pre-wrap;-webkit-font-variant-ligatures:none;font-feature-settings:none;font-variant-ligatures:none}::ng-deep .ProseMirror pre{white-space:pre-wrap}::ng-deep .ProseMirror li{position:relative}::ng-deep .ProseMirror-hideselection *::selection{background:transparent}::ng-deep .ProseMirror-hideselection *::-moz-selection{background:transparent}::ng-deep .ProseMirror-hideselection{caret-color:transparent}::ng-deep .ProseMirror-selectednode{outline:2px solid var(--color-primary-500)}::ng-deep li.ProseMirror-selectednode{outline:none}::ng-deep li.ProseMirror-selectednode:after{content:\"\";position:absolute;left:-32px;right:-2px;top:-2px;bottom:-2px;border:2px solid var(--color-primary-500);pointer-events:none}::ng-deep .ProseMirror-textblock-dropdown{min-width:3em}::ng-deep .ProseMirror-menu{margin:0 -4px;line-height:1}::ng-deep .ProseMirror-tooltip .ProseMirror-menu{width:-webkit-fit-content;width:-moz-fit-content;width:fit-content;white-space:pre}::ng-deep .ProseMirror-menuitem{margin-right:3px;display:inline-block}::ng-deep .ProseMirror-menuseparator{border-right:1px solid var(--color-component-border-200);margin:0 12px 0 8px;height:18px}::ng-deep .ProseMirror-menu-dropdown,::ng-deep .ProseMirror-menu-dropdown-menu{font-size:90%;white-space:nowrap;border-radius:var(--border-radius-input)}::ng-deep .ProseMirror-menu-dropdown{vertical-align:1px;cursor:pointer;position:relative;padding-right:15px}::ng-deep .ProseMirror-menu-dropdown-wrap{padding:1px 3px 1px 6px;display:inline-block;position:relative}::ng-deep .ProseMirror-menu-dropdown:after{content:\"\";border-left:4px solid transparent;border-right:4px solid transparent;border-top:4px solid currentColor;opacity:.6;position:absolute;right:4px;top:calc(50% - 2px)}::ng-deep .ProseMirror-menu-dropdown-menu,::ng-deep .ProseMirror-menu-submenu{position:absolute;background:var(--color-component-bg-100);border:1px solid var(--color-component-border-200);padding:2px}::ng-deep .ProseMirror-menu-dropdown-menu{z-index:15;min-width:6em;color:var(--color-text-200)}::ng-deep .ProseMirror-menu-dropdown-item{cursor:pointer;padding:2px 8px 2px 4px}::ng-deep .ProseMirror-menu-dropdown-item:hover{background:var(--color-component-bg-200)}::ng-deep .ProseMirror-menu-submenu-wrap{position:relative;margin-right:4px}::ng-deep .ProseMirror-menu-submenu-label:after{content:\"\";border-top:4px solid transparent;border-bottom:4px solid transparent;border-left:4px solid currentColor;opacity:.6;position:absolute;right:-8px;top:calc(50% - 4px)}::ng-deep .ProseMirror-menu-submenu{display:none;min-width:4em;left:100%;top:-3px}::ng-deep .ProseMirror-menu-active{background:var(--color-component-bg-100);border-radius:4px}::ng-deep .ProseMirror-menu-disabled{opacity:.3}::ng-deep .ProseMirror-menu-submenu-wrap:hover .ProseMirror-menu-submenu,::ng-deep .ProseMirror-menu-submenu-wrap-active .ProseMirror-menu-submenu{display:block}::ng-deep .ProseMirror-menubar{border-top-left-radius:inherit;border-top-right-radius:inherit;position:relative;min-height:1em;color:var(--color-grey-600);padding:1px 6px;top:0;left:0;right:0;background:var(--color-component-bg-100);z-index:10;box-sizing:border-box;overflow:visible;align-items:center}::ng-deep .ProseMirror-icon{display:inline-block;line-height:.8;vertical-align:-2px;padding:2px 8px;cursor:pointer}::ng-deep .ProseMirror-menu-disabled.ProseMirror-icon{cursor:default}::ng-deep .ProseMirror-icon svg{fill:currentColor;height:1em}::ng-deep .ProseMirror-icon span{vertical-align:text-top}::ng-deep .ProseMirror-gapcursor{display:none;pointer-events:none;position:absolute}::ng-deep .ProseMirror-gapcursor:after{content:\"\";display:block;position:absolute;top:-2px;width:20px;border-top:1px solid black;animation:ProseMirror-cursor-blink 1.1s steps(2,start) infinite}@keyframes ProseMirror-cursor-blink{to{visibility:hidden}}::ng-deep .ProseMirror-focused .ProseMirror-gapcursor{display:block}::ng-deep .ProseMirror ul,::ng-deep .ProseMirror ol{padding-left:30px;list-style-position:initial}::ng-deep .ProseMirror blockquote{padding-left:1em;border-left:3px solid var(--color-grey-100);margin-left:0;margin-right:0}::ng-deep .ProseMirror-prompt{background:white;padding:5px 10px 5px 15px;border:1px solid silver;position:fixed;border-radius:3px;z-index:11;box-shadow:-.5px 2px 5px #0003}::ng-deep .ProseMirror-prompt h5{margin:0;font-weight:normal;font-size:100%;color:var(--color-grey-500)}::ng-deep .ProseMirror-prompt input[type=text],::ng-deep .ProseMirror-prompt textarea{background:var(--color-component-bg-100);border:none;outline:none}::ng-deep .ProseMirror-prompt input[type=text]{padding:0 4px}::ng-deep .ProseMirror-prompt-close{position:absolute;left:2px;top:1px;color:var(--color-grey-400);border:none;background:transparent;padding:0}::ng-deep .ProseMirror-prompt-close:after{content:\"\\e2\\153\\2022\";font-size:12px}::ng-deep .ProseMirror-invalid{background:var(--color-warning-200);border:1px solid var(--color-warning-300);border-radius:4px;padding:5px 10px;position:absolute;min-width:10em}::ng-deep .ProseMirror-prompt-buttons{margin-top:5px;display:none}::ng-deep #editor,::ng-deep .editor{background:var(--color-form-input-bg);color:#000;background-clip:padding-box;border-radius:4px;border:2px solid rgba(0,0,0,.2);padding:5px 0;margin-bottom:23px}::ng-deep .ProseMirror p:first-child,::ng-deep .ProseMirror h1:first-child,::ng-deep .ProseMirror h2:first-child,::ng-deep .ProseMirror h3:first-child,::ng-deep .ProseMirror h4:first-child,::ng-deep .ProseMirror h5:first-child,::ng-deep .ProseMirror h6:first-child{margin-top:10px}::ng-deep .ProseMirror{padding:4px 8px 4px 14px;line-height:1.2;outline:none}::ng-deep .ProseMirror p{margin-bottom:.5rem;color:var(--color-grey-800)!important}::ng-deep .ProseMirror .tableWrapper td,::ng-deep .ProseMirror .tableWrapper th{border:1px solid var(--color-grey-300);padding:3px 6px}::ng-deep .ProseMirror .tableWrapper td p,::ng-deep .ProseMirror .tableWrapper th p{margin-top:0}::ng-deep .ProseMirror .tableWrapper th,::ng-deep .ProseMirror .tableWrapper th p{font-weight:bold}::ng-deep .ProseMirror table{border-collapse:collapse;table-layout:fixed;width:100%;overflow:hidden}::ng-deep .ProseMirror td,::ng-deep .ProseMirror th{vertical-align:top;box-sizing:border-box;position:relative}::ng-deep .ProseMirror .column-resize-handle{position:absolute;right:-2px;top:0;bottom:0;width:4px;z-index:20;background-color:#adf;pointer-events:none}::ng-deep .ProseMirror.resize-cursor{cursor:ew-resize;cursor:col-resize}::ng-deep .ProseMirror .selectedCell:after{z-index:2;position:absolute;content:\"\";left:0;right:0;top:0;bottom:0;background:#afdaf355;pointer-events:none}::ng-deep .menu-separator{border-bottom:1px solid var(--color-grey-400);height:0;margin:6px 0;pointer-events:none}::ng-deep .menu-item-with-icon{display:flex;align-items:center}::ng-deep .menu-item-with-icon clr-icon,::ng-deep .menu-item-with-icon .custom-icon{margin-right:4px;color:var(--color-text-200)}::ng-deep .menu-item-with-icon .hr-icon{width:13px;height:8px;border-bottom:2px solid var(--color-text-100);margin:-8px 5px 0 2px}::ng-deep .menu-item-with-icon .h-icon{width:16px;text-align:center;font-weight:bold;font-size:12px}.context-menu{position:fixed}:host{display:block;max-width:710px;margin-bottom:.5rem}:host.readonly ::ng-deep .ProseMirror-menubar{display:none}::ng-deep .ProseMirror-menubar{position:sticky;top:24px;margin-top:6px;border:1px solid var(--color-component-border-200);border-bottom:none;background-color:var(--color-component-bg-200);color:var(--color-icon-button);border-radius:var(--border-radius-input) var(--border-radius-input) 0 0;padding:6px 12px;display:flex;flex-wrap:wrap}::ng-deep .vdr-prosemirror{background:var(--color-form-input-bg);min-height:128px;min-width:200px;border:1px solid var(--color-component-border-200);border-radius:0 0 var(--border-radius-input) var(--border-radius-input);transition:border-color .2s;overflow:auto;text-align:initial}::ng-deep .vdr-prosemirror:focus{border-color:var(--color-primary-500)!important;box-shadow:0 0 1px 1px var(--color-primary-100)}::ng-deep .vdr-prosemirror hr{padding:2px 10px;border:none;margin:1em 0}::ng-deep .vdr-prosemirror hr:after{content:\"\";display:block;height:1px;background-color:silver;line-height:2px}::ng-deep .vdr-prosemirror img{cursor:default;max-width:100%}::ng-deep .vdr-prosemirror .iframe-wrapper{width:100%;text-align:center;padding:6px;transition:background-color .3s}::ng-deep .vdr-prosemirror .iframe-wrapper:hover{background-color:var(--color-primary-100)}\n"]
+            },] }
+];
+RichTextEditorComponent.ctorParameters = () => [
+    { type: ChangeDetectorRef },
+    { type: ProsemirrorService },
+    { type: ViewContainerRef },
+    { type: ContextMenuService }
+];
+RichTextEditorComponent.propDecorators = {
+    label: [{ type: Input }],
+    readonly: [{ type: Input }],
+    _readonly: [{ type: HostBinding, args: ['class.readonly',] }],
+    editorEl: [{ type: ViewChild, args: ['editor', { static: true },] }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/package/esm2015/core/shared/components/simple-dialog/simple-dialog.component.js

@@ -0,0 +1,21 @@
+import { ChangeDetectionStrategy, Component } from '@angular/core';
+/**
+ * Used by ModalService.dialog() to host a generic configurable modal dialog.
+ */
+export class SimpleDialogComponent {
+    constructor() {
+        this.title = '';
+        this.body = '';
+        this.translationVars = {};
+        this.buttons = [];
+    }
+}
+SimpleDialogComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'vdr-simple-dialog',
+                template: "<ng-template vdrDialogTitle>{{ title | translate:translationVars }}</ng-template>\r\n<div style=\"white-space: pre-wrap;\">{{ body | translate:translationVars }}</div>\r\n<ng-template vdrDialogButtons>\r\n    <ng-container *ngFor=\"let button of buttons\">\r\n        <button\r\n            class=\"btn\"\r\n            [class.btn-primary]=\"button.type === 'primary'\"\r\n            [class.btn-danger]=\"button.type === 'danger'\"\r\n            (click)=\"resolveWith(button.returnValue)\"\r\n        >\r\n            {{ button.label | translate: (button.translationVars || {}) }}\r\n        </button>\r\n    </ng-container>\r\n</ng-template>\r\n",
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                styles: [""]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2ltcGxlLWRpYWxvZy5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvcmUvc3JjL3NoYXJlZC9jb21wb25lbnRzL3NpbXBsZS1kaWFsb2cvc2ltcGxlLWRpYWxvZy5jb21wb25lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLHVCQUF1QixFQUFFLFNBQVMsRUFBVSxNQUFNLGVBQWUsQ0FBQztBQUkzRTs7R0FFRztBQU9ILE1BQU0sT0FBTyxxQkFBcUI7SUFObEM7UUFRSSxVQUFLLEdBQUcsRUFBRSxDQUFDO1FBQ1gsU0FBSSxHQUFHLEVBQUUsQ0FBQztRQUNWLG9CQUFlLEdBQUcsRUFBRSxDQUFDO1FBQ3JCLFlBQU8sR0FBbUMsRUFBRSxDQUFDO0lBQ2pELENBQUM7OztZQVpBLFNBQVMsU0FBQztnQkFDUCxRQUFRLEVBQUUsbUJBQW1CO2dCQUM3QixvcEJBQTZDO2dCQUU3QyxlQUFlLEVBQUUsdUJBQXVCLENBQUMsTUFBTTs7YUFDbEQiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDaGFuZ2VEZXRlY3Rpb25TdHJhdGVneSwgQ29tcG9uZW50LCBPbkluaXQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuXHJcbmltcG9ydCB7IERpYWxvZywgRGlhbG9nQnV0dG9uQ29uZmlnIH0gZnJvbSAnLi4vLi4vLi4vcHJvdmlkZXJzL21vZGFsL21vZGFsLnNlcnZpY2UnO1xyXG5cclxuLyoqXHJcbiAqIFVzZWQgYnkgTW9kYWxTZXJ2aWNlLmRpYWxvZygpIHRvIGhvc3QgYSBnZW5lcmljIGNvbmZpZ3VyYWJsZSBtb2RhbCBkaWFsb2cuXHJcbiAqL1xyXG5AQ29tcG9uZW50KHtcclxuICAgIHNlbGVjdG9yOiAndmRyLXNpbXBsZS1kaWFsb2cnLFxyXG4gICAgdGVtcGxhdGVVcmw6ICcuL3NpbXBsZS1kaWFsb2cuY29tcG9uZW50Lmh0bWwnLFxyXG4gICAgc3R5bGVVcmxzOiBbJy4vc2ltcGxlLWRpYWxvZy5jb21wb25lbnQuc2NzcyddLFxyXG4gICAgY2hhbmdlRGV0ZWN0aW9uOiBDaGFuZ2VEZXRlY3Rpb25TdHJhdGVneS5PblB1c2gsXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBTaW1wbGVEaWFsb2dDb21wb25lbnQgaW1wbGVtZW50cyBEaWFsb2c8YW55PiB7XHJcbiAgICByZXNvbHZlV2l0aDogKHJlc3VsdD86IGFueSkgPT4gdm9pZDtcclxuICAgIHRpdGxlID0gJyc7XHJcbiAgICBib2R5ID0gJyc7XHJcbiAgICB0cmFuc2xhdGlvblZhcnMgPSB7fTtcclxuICAgIGJ1dHRvbnM6IEFycmF5PERpYWxvZ0J1dHRvbkNvbmZpZzxhbnk+PiA9IFtdO1xyXG59XHJcbiJdfQ==