@exmg/exm-markdown-editor 1.1.36 → 1.2.0

package/.rollup.cache/root/repo/packages/exm-markdown-editor/dist/actions.d.ts

@@ -0,0 +1,6 @@
+import { MarkdownActions } from './types.js';
+export declare const toolbarActions: {
+    name: string;
+    icon: string;
+}[];
+export declare const markdownActions: MarkdownActions;

package/.rollup.cache/root/repo/packages/exm-markdown-editor/dist/actions.js

@@ -0,0 +1,227 @@
+export const toolbarActions = [
+    {
+        name: 'undo',
+        icon: 'undo',
+    },
+    {
+        name: 'redo',
+        icon: 'redo',
+    },
+    {
+        name: 'header_one',
+        icon: 'format_h1',
+    },
+    {
+        name: 'header_two',
+        icon: 'format_h2',
+    },
+    {
+        name: 'header_three',
+        icon: 'format_h3',
+    },
+    {
+        name: 'unordered_list',
+        icon: 'format_list_bulleted',
+    },
+    {
+        name: 'ordered_list',
+        icon: 'format_list_numbered',
+    },
+    {
+        name: 'bold',
+        icon: 'format_bold',
+    },
+    {
+        name: 'italic',
+        icon: 'format_italic',
+    },
+    {
+        name: 'strikethrough',
+        icon: 'format_strikethrough',
+    },
+    {
+        name: 'quote',
+        icon: 'format_quote',
+    },
+    {
+        name: 'code',
+        icon: 'data_object',
+    },
+    {
+        name: 'link',
+        icon: 'insert_link',
+    },
+    {
+        name: 'image',
+        icon: 'insert_photo',
+    },
+    {
+        name: 'hr',
+        icon: 'horizontal_rule',
+    },
+    {
+        name: 'table',
+        icon: 'table_chart',
+    },
+];
+export const markdownActions = {
+    undo: (editor) => {
+        editor.getDoc().undo();
+        editor.focus();
+    },
+    redo: (editor) => {
+        editor.getDoc().redo();
+        editor.focus();
+    },
+    header_one: (editor) => header(editor, '#'),
+    header_two: (editor) => header(editor, '##'),
+    header_three: (editor) => header(editor, '###'),
+    bold: (editor) => emphasis(editor, ['**', '__']),
+    italic: (editor) => emphasis(editor, ['*', '_']),
+    strikethrough: (editor) => emphasis(editor, ['~~']),
+    quote: (editor) => emphasis(editor, ['`']),
+    link: (editor) => insertLink(editor),
+    image: (editor, url) => insertImage(editor, url),
+    code: (editor) => insertCode(editor),
+    hr: (editor) => insertHr(editor),
+    table: (editor) => insertTable(editor),
+    ordered_list: (editor) => insertList(editor, '#'),
+    unordered_list: (editor) => insertList(editor, '*'),
+};
+const header = (editor, symbol) => {
+    const selection = editor.getDoc().getSelection().trim();
+    let text = selection;
+    const regex = new RegExp(`(?<sa>[#]{1,3})(?<text>.*)`, 'g');
+    text = processText(text, regex, symbol);
+    if (text === selection) {
+        text = `${symbol} ${text.length > 0 ? text : 'header'}`;
+        editor.getDoc().replaceSelection(text);
+    }
+    else {
+        editor.getDoc().replaceSelection(text);
+        text.startsWith(symbol) &&
+            editor.getDoc().setCursor({
+                line: editor.getDoc().getCursor().line + 1,
+                ch: editor.getDoc().getCursor().ch,
+            });
+    }
+};
+const emphasis = (editor, symbols) => {
+    const selection = editor.getDoc().getSelection();
+    let text = selection;
+    symbols.forEach((symbol) => {
+        const regex = new RegExp(`(?<sa>[\\${symbol.slice(0, 1)}]{${symbol.length}})(?<text>.*?)(?<sb>[\\${symbol.slice(0, 1)}]{1,${symbol.length}})`, 'g');
+        text = processText(text, regex, symbol);
+    });
+    if (text === selection) {
+        text = `${symbols[0]}${text.length > 0 ? text : symbols[0] === '`' ? 'quote' : 'emphasis'}${symbols[0]}`;
+    }
+    editor.getDoc().replaceSelection(text);
+};
+const insertLink = (editor) => {
+    const selection = editor.getSelection();
+    let text = selection;
+    if (text) {
+        text = `[${text}]()`;
+    }
+    else {
+        text = `[Markdown Live Preview](Your link here)`;
+    }
+    editor.getDoc().replaceSelection(text);
+    const cursor = editor.getDoc().getCursor();
+    if (text.split('')[text.length - 2] === 'e') {
+        editor.setSelection({
+            line: cursor.line,
+            ch: cursor.ch - 15,
+        }, { ...cursor, ch: cursor.ch - 1 });
+    }
+    else {
+        editor.setCursor({ ...cursor, ch: cursor.ch - 1 });
+    }
+};
+const insertImage = (editor, url) => {
+    const selection = editor.getSelection();
+    let text = selection;
+    if (text) {
+        text = `![Alternative ${text}](${url ? url : 'Your link here'} "${text}")`;
+    }
+    else {
+        text = `![This is an alt text.](${url ? url : 'http://placekitten.com/g/200/300'} "This is a sample image.")`;
+    }
+    editor.getDoc().replaceSelection(text);
+    const cursor = editor.getDoc().getCursor();
+    if (text.startsWith('![A')) {
+        editor.setSelection({
+            line: cursor.line,
+            ch: cursor.ch - 4 - text.length,
+        }, {
+            line: cursor.line,
+            ch: cursor.ch - 18 - text.length,
+        });
+    }
+    else {
+        editor.setSelection({
+            line: cursor.line,
+            ch: cursor.ch - 25,
+        }, {
+            line: cursor.line,
+            ch: cursor.ch - 2,
+        });
+    }
+};
+const insertCode = (editor) => {
+    const selection = editor.getSelection();
+    let text = selection;
+    if (text.trim().startsWith('```')) {
+        const textArray = text.split('```');
+        textArray.pop();
+        textArray.reverse().pop();
+        text = textArray.reverse().join('');
+    }
+    else {
+        text = `\`\`\`${text}\n\`\`\``;
+    }
+    editor.replaceSelection(text);
+};
+const insertHr = (editor) => {
+    const selection = editor.getSelection();
+    editor.replaceSelection(`${selection}\n___\n`);
+};
+const insertTable = (editor) => {
+    const selection = editor.getSelection();
+    editor.replaceSelection(`${selection}
+| Left columns  | Center columns | Right columns |
+| ------------- |:-------------: |--------------:|
+| left foo      | right foo      | right foo     |
+| left bar      | right bar      | right foo     |
+| left baz      | right baz      | right foo     |
+\n`);
+};
+const insertList = (editor, symbol) => {
+    const selection = editor.getSelection();
+    let text = '';
+    for (let i = 0; i < 3; i++) {
+        const bullet = `${symbol === '*' ? symbol : `${i + 1}.`}`;
+        const item = i === 0 && selection.length > 0 ? selection : `Item ${i + 1}`;
+        text += `${bullet} ${item}\n`;
+    }
+    editor.replaceSelection(`${text}\n`);
+    editor.setSelection({
+        ch: symbol === '*' ? 2 : 3,
+        line: editor.getCursor().line - 4,
+    }, {
+        ch: selection.length > 0 ? (selection.length + symbol === '*' ? 2 : 3) : 8,
+        line: editor.getCursor().line - 4,
+    });
+};
+const processText = (text, regex, symbol) => {
+    const matchList = regex.exec(text);
+    if (matchList) {
+        text = text
+            .split(regex)
+            .filter((v) => v !== symbol)
+            .join('');
+    }
+    return text.trim();
+};
+//# sourceMappingURL=actions.js.map

package/.rollup.cache/root/repo/packages/exm-markdown-editor/dist/exm-markdown-editor-base.d.ts

@@ -0,0 +1,89 @@
+import { PropertyValueMap } from 'lit';
+import { Editor, EditorConfiguration } from 'codemirror';
+import { ExmgElement } from '@exmg/lit-base';
+import { MarkdownActions, ToolbarIcons, ToolbarItem } from './types.js';
+import { TokenizerAndRendererExtension } from 'marked';
+import { getFormValue } from '@material/web/labs/behaviors/form-associated.js';
+import { MardownEditorValidator } from './validator/exm-markdown-editor-validator.js';
+import { createValidator, getValidityAnchor } from '@material/web/labs/behaviors/constraint-validation.js';
+import './exm-markdown-editor-toolbar.js';
+declare const MarkdownBaseClass: import("@material/web/labs/behaviors/mixin.js").MixinReturn<import("@material/web/labs/behaviors/mixin.js").MixinReturn<(abstract new (...args: any[]) => import("@material/web/labs/behaviors/element-internals.js").WithElementInternals) & typeof ExmgElement & import("@material/web/labs/behaviors/form-associated.js").FormAssociatedConstructor, import("@material/web/labs/behaviors/form-associated.js").FormAssociated>, import("@material/web/labs/behaviors/constraint-validation.js").ConstraintValidation>;
+/**
+ * Markdown editor element.
+ * An out of the box customizable Markdown Editor for Exmachina
+ *
+ * ```
+ * <exm-markdown-editor markdown="# Header 1"></exm-markdown-editor>
+ * ```
+ * ### Styling
+ *
+ *  Custom property | Description | Default
+ *  ----------------|-------------|----------
+ * `--exm-markdown-editor-code-color` | Editor's text color | --md-sys-color-on-surface
+ * `--exm-markdown-editor-code-cursor-color` | Editor's cursor color | --md-sys-color-on-surface
+ * `--exm-markdown-editor-code-header-color` | H1 color in editor | #4a8fc0;
+ * `--exm-markdown-editor-code-inline-code-color` | Inline code color | #ea881f
+ * `--exm-markdown-editor-code-list-color` | Lists color | rgb(25, 165, 28)
+ * `--exm-markdown-editor-selected-code-color` | Selected text color | rgb(140, 140, 140)
+ * `--exm-markdown-editor-border-color` | Editor's border color | --md-sys-color-primary
+ * `--exm-markdown-editor-background-color` | Toolbar and default preview background | --md-sys-color-surface-container-high
+ * `--exm-markdown-editor-code-background-color` | Editor's background color when focused | --md-sys-color-surface-container-high
+ *
+ *  # Events:
+ *  - change - where detail is current markdown value
+ *  - insert-image - if the Editor is set to upload, it will trigger this event when the insert-image is clicked
+ *
+ * @customElement
+ * @element exm-markdown-editor
+ * @memberof Exmg
+ * @extends ExmgElement
+ * @summary Markdown editor element
+ */
+export declare class MarkdownEditorElementBase extends MarkdownBaseClass {
+    value: string;
+    html?: string;
+    label: string;
+    upload: boolean;
+    toolbarActions?: ToolbarItem[];
+    toolbarIcons?: ToolbarIcons;
+    markedExtension?: TokenizerAndRendererExtension[];
+    required: boolean;
+    disabled: boolean;
+    supportingText: string;
+    splitView: boolean;
+    fullScreen: boolean;
+    editorElement?: HTMLDivElement;
+    editorContainerElement?: HTMLDivElement;
+    previewElement?: Element | null;
+    isFullScreen?: boolean;
+    preview: boolean;
+    editorConfiguration: EditorConfiguration;
+    editorActions: MarkdownActions;
+    codeMirrorEditor?: Editor;
+    internalTextarea?: HTMLTextAreaElement;
+    blurHandlerBinding: any;
+    heightStyleMap?: any;
+    reset(): void;
+    protected updated(changedProps: PropertyValueMap<any> | Map<PropertyKey, unknown>): void;
+    [getFormValue](): string;
+    [createValidator](): MardownEditorValidator;
+    [getValidityAnchor](): HTMLTextAreaElement;
+    formResetCallback(): void;
+    formStateRestoreCallback(state: string): void;
+    focus(): void;
+    protected firstUpdated(): void;
+    protected disconectedCallback(): void;
+    protected getPreviewElement(): Element | null;
+    private handleEditorScroll;
+    private toggleFullscreen;
+    private handleExitFullScreen;
+    codeMirrorSetup(): void;
+    handleFocus(): void;
+    handleBlur(): void;
+    handleAction(e: CustomEvent): void;
+    handleInsertImage(url: string): void;
+    updateValue(newValue?: string): void;
+    private handleContainerClick;
+    protected render(): import("lit-html").TemplateResult<1>;
+}
+export {};

package/.rollup.cache/root/repo/packages/exm-markdown-editor/dist/exm-markdown-editor-base.js

@@ -0,0 +1,334 @@
+import { __decorate } from "tslib";
+import { html, nothing } from 'lit';
+import { query, property, state } from 'lit/decorators.js';
+import { defaultConfiguration } from './utils/configurations.js';
+import { ExmgElement, observer } from '@exmg/lit-base';
+import { markdownActions, toolbarActions } from './actions.js';
+import { marked } from 'marked';
+import { mixinElementInternals } from '@material/web/labs/behaviors/element-internals.js';
+import { getFormValue, mixinFormAssociated } from '@material/web/labs/behaviors/form-associated.js';
+import { toolbarIcons } from './icons.js';
+import { MardownEditorValidator } from './validator/exm-markdown-editor-validator.js';
+import { createValidator, getValidityAnchor, mixinConstraintValidation, } from '@material/web/labs/behaviors/constraint-validation.js';
+import './exm-markdown-editor-toolbar.js';
+import { classMap } from 'lit/directives/class-map.js';
+const MarkdownBaseClass = mixinConstraintValidation(mixinFormAssociated(mixinElementInternals(ExmgElement)));
+/**
+ * Markdown editor element.
+ * An out of the box customizable Markdown Editor for Exmachina
+ *
+ * ```
+ * <exm-markdown-editor markdown="# Header 1"></exm-markdown-editor>
+ * ```
+ * ### Styling
+ *
+ *  Custom property | Description | Default
+ *  ----------------|-------------|----------
+ * `--exm-markdown-editor-code-color` | Editor's text color | --md-sys-color-on-surface
+ * `--exm-markdown-editor-code-cursor-color` | Editor's cursor color | --md-sys-color-on-surface
+ * `--exm-markdown-editor-code-header-color` | H1 color in editor | #4a8fc0;
+ * `--exm-markdown-editor-code-inline-code-color` | Inline code color | #ea881f
+ * `--exm-markdown-editor-code-list-color` | Lists color | rgb(25, 165, 28)
+ * `--exm-markdown-editor-selected-code-color` | Selected text color | rgb(140, 140, 140)
+ * `--exm-markdown-editor-border-color` | Editor's border color | --md-sys-color-primary
+ * `--exm-markdown-editor-background-color` | Toolbar and default preview background | --md-sys-color-surface-container-high
+ * `--exm-markdown-editor-code-background-color` | Editor's background color when focused | --md-sys-color-surface-container-high
+ *
+ *  # Events:
+ *  - change - where detail is current markdown value
+ *  - insert-image - if the Editor is set to upload, it will trigger this event when the insert-image is clicked
+ *
+ * @customElement
+ * @element exm-markdown-editor
+ * @memberof Exmg
+ * @extends ExmgElement
+ * @summary Markdown editor element
+ */
+export class MarkdownEditorElementBase extends MarkdownBaseClass {
+    constructor() {
+        super(...arguments);
+        this.value = '';
+        this.label = '';
+        this.upload = false;
+        this.toolbarActions = toolbarActions;
+        this.toolbarIcons = toolbarIcons;
+        this.required = false;
+        this.disabled = false;
+        this.supportingText = '';
+        this.splitView = false;
+        this.fullScreen = false;
+        this.isFullScreen = false;
+        this.preview = true;
+        this.editorConfiguration = defaultConfiguration;
+        this.editorActions = markdownActions;
+    }
+    reset() {
+        var _a;
+        this.value = (_a = this.getAttribute('value')) !== null && _a !== void 0 ? _a : '';
+    }
+    updated(changedProps) {
+        var _a, _b;
+        if (changedProps.has('value') && ((_a = this.codeMirrorEditor) === null || _a === void 0 ? void 0 : _a.getValue()) !== this.value) {
+            (_b = this.codeMirrorEditor) === null || _b === void 0 ? void 0 : _b.setValue(this.value);
+        }
+    }
+    [getFormValue]() {
+        return this.value;
+    }
+    [createValidator]() {
+        return new MardownEditorValidator(() => this);
+    }
+    [getValidityAnchor]() {
+        return this.internalTextarea;
+    }
+    formResetCallback() {
+        this.reset();
+    }
+    formStateRestoreCallback(state) {
+        this.value = state;
+    }
+    focus() {
+        var _a;
+        (_a = this.codeMirrorEditor) === null || _a === void 0 ? void 0 : _a.focus();
+    }
+    firstUpdated() {
+        var _a;
+        if (!this.disabled) {
+            this.codeMirrorSetup();
+        }
+        this.previewElement = this.getPreviewElement();
+        /* Height */
+        if (this.previewElement.hasAttribute('slot')) {
+            (_a = this.shadowRoot.querySelector('#preview')) === null || _a === void 0 ? void 0 : _a.remove();
+        }
+        /** Blur global handling */
+        this.blurHandlerBinding = this.handleBlur.bind(this);
+        this.addEventListener('blur', this.handleBlur);
+        if (this.value) {
+            this.updateValue(this.value);
+            this.codeMirrorEditor.refresh();
+        }
+        if (this.label && this.required) {
+            this.setAttribute('aria-required', 'true');
+            this.label += ' *';
+        }
+    }
+    disconectedCallback() {
+        this.removeEventListener('blur', this.handleBlur);
+    }
+    getPreviewElement() {
+        return this.shadowRoot.querySelector('#preview');
+    }
+    // CodeMirror types is not handling the scroll event type correct
+    handleEditorScroll(event) {
+        const previewContainer = this.renderRoot.querySelector('.preview');
+        const previewArea = this.renderRoot.querySelector('.preview-content');
+        if (!previewArea || !previewContainer || (!this.splitView && !this.isFullScreen)) {
+            return;
+        }
+        // DOMRectList of CodeMirrors scroll area
+        const scroller = event.display.scroller.getClientRects()[0];
+        // DOMRectList of CodeMirrors editor/content area
+        const sizer = event.display.sizer.getClientRects()[0];
+        // DOMRectList of previewArea
+        const preview = previewArea.getClientRects()[0];
+        // Get the total distance scroller in the editor
+        const scrolledDistance = scroller.y - sizer.y;
+        // Get the maximal scroll distance for the editor
+        const maxEditorScrollDistance = sizer.height - scroller.height;
+        // Get the maximal scroll distance for the preview
+        const maxPreviewScrollDistance = preview.height - scroller.height;
+        // Calculate the scroll progress bases on the above values
+        const scrollProgress = Math.min(scrolledDistance / maxEditorScrollDistance, 1);
+        previewContainer.scrollTo({
+            top: maxPreviewScrollDistance * scrollProgress,
+        });
+    }
+    toggleFullscreen() {
+        if (!this.editorContainerElement) {
+            return;
+        }
+        this.isFullScreen = !this.isFullScreen;
+        if (!document.fullscreenElement) {
+            this.editorContainerElement.requestFullscreen();
+            document.addEventListener('fullscreenchange', this.handleExitFullScreen.bind(this));
+        }
+        else {
+            document.exitFullscreen();
+        }
+    }
+    handleExitFullScreen() {
+        if (!document.fullscreenElement) {
+            this.isFullScreen = false;
+        }
+    }
+    codeMirrorSetup() {
+        if (!this.editorElement) {
+            console.log('Error');
+            return;
+        }
+        if (this.markedExtension) {
+            marked.use({ extensions: this.markedExtension });
+        }
+        // eslint-disable-next-line
+        this.codeMirrorEditor = window.CodeMirror(this.editorElement, {
+            ...this.editorConfiguration,
+            value: this.value || '',
+        });
+        this.codeMirrorEditor.on('focus', (_) => {
+            this.handleFocus();
+        });
+        this.codeMirrorEditor.on('change', (editor) => {
+            this.updateValue(editor.getValue());
+        });
+        this.codeMirrorEditor.on('scroll', this.handleEditorScroll.bind(this));
+        this.internalTextarea = this.codeMirrorEditor.getInputField();
+    }
+    handleFocus() {
+        this.codeMirrorEditor.refresh();
+    }
+    handleBlur() {
+        this.previewElement.innerHTML = `
+      <main class="preview-content">
+        ${this.html}
+      </main>
+    `;
+        this.preview = true;
+    }
+    handleAction(e) {
+        var _a;
+        const actionName = e.detail;
+        if (!this.editorActions[actionName]) {
+            return;
+        }
+        this.editorActions[actionName](this.codeMirrorEditor);
+        this.preview = false;
+        (_a = this.codeMirrorEditor) === null || _a === void 0 ? void 0 : _a.focus();
+    }
+    handleInsertImage(url) {
+        this.editorActions['image'](this.codeMirrorEditor, url);
+    }
+    updateValue(newValue) {
+        this.html = marked.parse(newValue !== null && newValue !== void 0 ? newValue : '');
+        if (this.previewElement) {
+            this.previewElement.innerHTML = `
+      <main class="preview-content">
+        ${this.html}
+      </main>
+    `;
+        }
+        if (newValue === this.value) {
+            return;
+        }
+        this.value = newValue || '';
+        this.fire('change', this.value);
+    }
+    handleContainerClick() {
+        if (!this.disabled) {
+            this.preview = false;
+        }
+    }
+    render() {
+        const containerClasses = {
+            'has-label': !!this.label,
+            'preview-mode': this.preview,
+            'split-view': (this.splitView || !!this.isFullScreen) && !this.disabled,
+            'full-screen': this.fullScreen,
+        };
+        const labelClasses = { 'not-empty': !!this.value, 'preview-mode': this.preview };
+        return html `
+      <div
+        id="markdownEditorContainer"
+        class="container ${classMap(containerClasses)}"
+        @click=${this.handleContainerClick}
+      >
+        <div class="background"></div>
+        <div class="state-layer"></div>
+        ${this.label
+            ? html `<label class="${classMap(labelClasses)}" for="markdownEditorContainer">${this.label}</label>`
+            : nothing}
+        <exm-markdown-editor-toolbar
+          ?upload=${this.upload}
+          @action=${this.handleAction}
+          .actions=${this.toolbarActions || []}
+          .icons=${this.toolbarIcons || []}
+        ></exm-markdown-editor-toolbar>
+        <section class="label-bar">
+          <span>Editor</span>
+          <span>Preview</span>
+        </section>
+        <div class="editor" id="editor"></div>
+        <div id="preview" class="preview"></div>
+        ${this.fullScreen
+            ? html `
+              <section class="full-screen-button">
+                <md-icon-button @click=${this.toggleFullscreen} title="Toggle for a full screen editor mode"
+                  ><md-icon>${this.isFullScreen ? 'fullscreen_exit' : 'fullscreen'}</md-icon></md-icon-button
+                >
+              </section>
+            `
+            : nothing}
+        <slot name="preview"></slot>
+        ${this.supportingText ? html `<div class="supporting-text">${this.supportingText}</div>` : nothing}
+      </div>
+    `;
+    }
+}
+__decorate([
+    property({ type: String })
+], MarkdownEditorElementBase.prototype, "value", void 0);
+__decorate([
+    property()
+], MarkdownEditorElementBase.prototype, "html", void 0);
+__decorate([
+    property({ type: String })
+], MarkdownEditorElementBase.prototype, "label", void 0);
+__decorate([
+    property({ type: Boolean })
+], MarkdownEditorElementBase.prototype, "upload", void 0);
+__decorate([
+    property({ type: Array })
+], MarkdownEditorElementBase.prototype, "toolbarActions", void 0);
+__decorate([
+    property({ type: Object })
+], MarkdownEditorElementBase.prototype, "toolbarIcons", void 0);
+__decorate([
+    property({ type: Array })
+], MarkdownEditorElementBase.prototype, "markedExtension", void 0);
+__decorate([
+    property({ type: Boolean, reflect: true })
+], MarkdownEditorElementBase.prototype, "required", void 0);
+__decorate([
+    property({ type: Boolean, reflect: true })
+], MarkdownEditorElementBase.prototype, "disabled", void 0);
+__decorate([
+    property({ type: String, attribute: 'supporting-text' })
+], MarkdownEditorElementBase.prototype, "supportingText", void 0);
+__decorate([
+    property({ type: Boolean, attribute: 'split-view' })
+], MarkdownEditorElementBase.prototype, "splitView", void 0);
+__decorate([
+    property({ type: Boolean, attribute: 'full-screen' })
+], MarkdownEditorElementBase.prototype, "fullScreen", void 0);
+__decorate([
+    query('#editor')
+], MarkdownEditorElementBase.prototype, "editorElement", void 0);
+__decorate([
+    query('#markdownEditorContainer')
+], MarkdownEditorElementBase.prototype, "editorContainerElement", void 0);
+__decorate([
+    state()
+], MarkdownEditorElementBase.prototype, "previewElement", void 0);
+__decorate([
+    state()
+], MarkdownEditorElementBase.prototype, "isFullScreen", void 0);
+__decorate([
+    state(),
+    observer(function (preview) {
+        var _a;
+        if (preview === false) {
+            (_a = this.codeMirrorEditor) === null || _a === void 0 ? void 0 : _a.focus();
+        }
+    })
+], MarkdownEditorElementBase.prototype, "preview", void 0);
+//# sourceMappingURL=exm-markdown-editor-base.js.map

package/.rollup.cache/root/repo/packages/exm-markdown-editor/dist/exm-markdown-editor-toolbar-base.d.ts

@@ -0,0 +1,12 @@
+import { ToolbarIcons, ToolbarItem } from './types.js';
+import { ExmgElement } from '@exmg/lit-base/index.js';
+import '@material/web/iconbutton/icon-button.js';
+import '@material/web/icon/icon.js';
+export declare class MarkdownEditorToolbarBase extends ExmgElement {
+    upload: boolean;
+    actions: ToolbarItem[];
+    icons: ToolbarIcons;
+    renderActionButtons(): import("lit-html").TemplateResult<1>[];
+    action(action: string): void;
+    protected render(): import("lit-html").TemplateResult<1>;
+}