@eugenemahota/angular-editor 2.0.0

package/esm2020/lib/angular-editor.module.mjs

@@ -0,0 +1,25 @@
+import { NgModule } from '@angular/core';
+import { AngularEditorComponent } from './angular-editor.component';
+import { AngularEditorToolbarComponent } from './angular-editor-toolbar.component';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { CommonModule } from '@angular/common';
+import { AeSelectComponent } from './ae-select/ae-select.component';
+import * as i0 from "@angular/core";
+export class AngularEditorModule {
+}
+AngularEditorModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: AngularEditorModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AngularEditorModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: AngularEditorModule, declarations: [AngularEditorComponent, AngularEditorToolbarComponent, AeSelectComponent], imports: [CommonModule, FormsModule, ReactiveFormsModule], exports: [AngularEditorComponent, AngularEditorToolbarComponent] });
+AngularEditorModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: AngularEditorModule, imports: [[
+            CommonModule, FormsModule, ReactiveFormsModule
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: AngularEditorModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule, FormsModule, ReactiveFormsModule
+                    ],
+                    declarations: [AngularEditorComponent, AngularEditorToolbarComponent, AeSelectComponent],
+                    exports: [AngularEditorComponent, AngularEditorToolbarComponent]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/angular-editor.service.mjs

@@ -0,0 +1,274 @@
+import { Inject, Injectable } from '@angular/core';
+import { DOCUMENT } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class AngularEditorService {
+    constructor(http, doc) {
+        this.http = http;
+        this.doc = doc;
+        /**
+         * save selection when the editor is focussed out
+         */
+        this.saveSelection = () => {
+            if (this.doc.getSelection) {
+                const sel = this.doc.getSelection();
+                if (sel.getRangeAt && sel.rangeCount) {
+                    this.savedSelection = sel.getRangeAt(0);
+                    this.selectedText = sel.toString();
+                }
+            }
+            else if (this.doc.getSelection && this.doc.createRange) {
+                this.savedSelection = document.createRange();
+            }
+            else {
+                this.savedSelection = null;
+            }
+        };
+    }
+    /**
+     * Executed command from editor header buttons exclude toggleEditorMode
+     * @param command string from triggerCommand
+     */
+    executeCommand(command) {
+        const commands = ['h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'p', 'pre'];
+        if (commands.includes(command)) {
+            this.doc.execCommand('formatBlock', false, command);
+            return;
+        }
+        this.doc.execCommand(command, false, null);
+    }
+    /**
+     * Create URL link
+     * @param url string from UI prompt
+     */
+    createLink(url) {
+        if (!url.includes('http')) {
+            this.doc.execCommand('createlink', false, url);
+        }
+        else {
+            const newUrl = '<a href="' + url + '" target="_blank">' + this.selectedText + '</a>';
+            this.insertHtml(newUrl);
+        }
+    }
+    /**
+     * insert color either font or background
+     *
+     * @param color color to be inserted
+     * @param where where the color has to be inserted either text/background
+     */
+    insertColor(color, where) {
+        const restored = this.restoreSelection();
+        if (restored) {
+            if (where === 'textColor') {
+                this.doc.execCommand('foreColor', false, color);
+            }
+            else {
+                this.doc.execCommand('hiliteColor', false, color);
+            }
+        }
+    }
+    /**
+     * Set font name
+     * @param fontName string
+     */
+    setFontName(fontName) {
+        this.doc.execCommand('fontName', false, fontName);
+    }
+    /**
+     * Set font size
+     * @param fontSize string
+     */
+    setFontSize(fontSize) {
+        this.doc.execCommand('fontSize', false, fontSize);
+    }
+    /**
+     * Create raw HTML
+     * @param html HTML string
+     */
+    insertHtml(html) {
+        const isHTMLInserted = this.doc.execCommand('insertHTML', false, html);
+        if (!isHTMLInserted) {
+            throw new Error('Unable to perform the operation');
+        }
+    }
+    /**
+     * restore selection when the editor is focused in
+     *
+     * saved selection when the editor is focused out
+     */
+    restoreSelection() {
+        if (this.savedSelection) {
+            if (this.doc.getSelection) {
+                const sel = this.doc.getSelection();
+                sel.removeAllRanges();
+                sel.addRange(this.savedSelection);
+                return true;
+            }
+            else if (this.doc.getSelection /*&& this.savedSelection.select*/) {
+                // this.savedSelection.select();
+                return true;
+            }
+        }
+        else {
+            return false;
+        }
+    }
+    /**
+     * setTimeout used for execute 'saveSelection' method in next event loop iteration
+     */
+    executeInNextQueueIteration(callbackFn, timeout = 1e2) {
+        setTimeout(callbackFn, timeout);
+    }
+    /** check any selection is made or not */
+    checkSelection() {
+        const selectedText = this.savedSelection.toString();
+        if (selectedText.length === 0) {
+            throw new Error('No Selection Made');
+        }
+        return true;
+    }
+    /**
+     * Upload file to uploadUrl
+     * @param file The file
+     */
+    uploadImage(file) {
+        const uploadData = new FormData();
+        uploadData.append('file', file, file.name);
+        return this.http.post(this.uploadUrl, uploadData, {
+            reportProgress: true,
+            observe: 'events',
+            withCredentials: this.uploadWithCredentials,
+        });
+    }
+    /**
+     * Insert image with Url
+     * @param imageUrl The imageUrl.
+     */
+    insertImage(imageUrl) {
+        this.doc.execCommand('insertImage', false, imageUrl);
+    }
+    setDefaultParagraphSeparator(separator) {
+        this.doc.execCommand('defaultParagraphSeparator', false, separator);
+    }
+    createCustomClass(customClass) {
+        let newTag = this.selectedText;
+        if (customClass) {
+            const tagName = customClass.tag ? customClass.tag : 'span';
+            newTag = '<' + tagName + ' class="' + customClass.class + '">' + this.selectedText + '</' + tagName + '>';
+        }
+        this.insertHtml(newTag);
+    }
+    insertVideo(videoUrl) {
+        if (videoUrl.match('www.youtube.com')) {
+            this.insertYouTubeVideoTag(videoUrl);
+        }
+        if (videoUrl.match('vimeo.com')) {
+            this.insertVimeoVideoTag(videoUrl);
+        }
+    }
+    insertYouTubeVideoTag(videoUrl) {
+        const id = videoUrl.split('v=')[1];
+        const imageUrl = `https://img.youtube.com/vi/${id}/0.jpg`;
+        const thumbnail = `
+      <div style='position: relative'>
+        <a href='${videoUrl}' target='_blank'>
+          <img src="${imageUrl}" alt="click to watch"/>
+          <img style='position: absolute; left:200px; top:140px'
+          src="https://img.icons8.com/color/96/000000/youtube-play.png"/>
+        </a>
+      </div>`;
+        this.insertHtml(thumbnail);
+    }
+    insertVimeoVideoTag(videoUrl) {
+        const sub = this.http.get(`https://vimeo.com/api/oembed.json?url=${videoUrl}`).subscribe(data => {
+            const imageUrl = data.thumbnail_url_with_play_button;
+            const thumbnail = `<div>
+        <a href='${videoUrl}' target='_blank'>
+          <img src="${imageUrl}" alt="${data.title}"/>
+        </a>
+      </div>`;
+            this.insertHtml(thumbnail);
+            sub.unsubscribe();
+        });
+    }
+    nextNode(node) {
+        if (node.hasChildNodes()) {
+            return node.firstChild;
+        }
+        else {
+            while (node && !node.nextSibling) {
+                node = node.parentNode;
+            }
+            if (!node) {
+                return null;
+            }
+            return node.nextSibling;
+        }
+    }
+    getRangeSelectedNodes(range, includePartiallySelectedContainers) {
+        let node = range.startContainer;
+        const endNode = range.endContainer;
+        let rangeNodes = [];
+        // Special case for a range that is contained within a single node
+        if (node === endNode) {
+            rangeNodes = [node];
+        }
+        else {
+            // Iterate nodes until we hit the end container
+            while (node && node !== endNode) {
+                rangeNodes.push(node = this.nextNode(node));
+            }
+            // Add partially selected nodes at the start of the range
+            node = range.startContainer;
+            while (node && node !== range.commonAncestorContainer) {
+                rangeNodes.unshift(node);
+                node = node.parentNode;
+            }
+        }
+        // Add ancestors of the range container, if required
+        if (includePartiallySelectedContainers) {
+            node = range.commonAncestorContainer;
+            while (node) {
+                rangeNodes.push(node);
+                node = node.parentNode;
+            }
+        }
+        return rangeNodes;
+    }
+    getSelectedNodes() {
+        const nodes = [];
+        if (this.doc.getSelection) {
+            const sel = this.doc.getSelection();
+            for (let i = 0, len = sel.rangeCount; i < len; ++i) {
+                nodes.push.apply(nodes, this.getRangeSelectedNodes(sel.getRangeAt(i), true));
+            }
+        }
+        return nodes;
+    }
+    replaceWithOwnChildren(el) {
+        const parent = el.parentNode;
+        while (el.hasChildNodes()) {
+            parent.insertBefore(el.firstChild, el);
+        }
+        parent.removeChild(el);
+    }
+    removeSelectedElements(tagNames) {
+        const tagNamesArray = tagNames.toLowerCase().split(',');
+        this.getSelectedNodes().forEach((node) => {
+            if (node.nodeType === 1 &&
+                tagNamesArray.indexOf(node.tagName.toLowerCase()) > -1) {
+                // Remove the node and replace it with its children
+                this.replaceWithOwnChildren(node);
+            }
+        });
+    }
+}
+AngularEditorService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: AngularEditorService, deps: [{ token: i1.HttpClient }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
+AngularEditorService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: AngularEditorService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: AngularEditorService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"angular-editor.service.js","sourceRoot":"","sources":["../../../../projects/angular-editor/src/lib/angular-editor.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Inject, Injectable} from '@angular/core';\nimport {HttpClient, HttpEvent} from '@angular/common/http';\nimport {Observable} from 'rxjs';\nimport {DOCUMENT} from '@angular/common';\nimport {CustomClass} from './config';\n\nexport interface UploadResponse {\n  imageUrl: string;\n}\n\n@Injectable()\nexport class AngularEditorService {\n\n  savedSelection: Range | null;\n  selectedText: string;\n  uploadUrl: string;\n  uploadWithCredentials: boolean;\n\n  constructor(\n    private http: HttpClient,\n    @Inject(DOCUMENT) private doc: any\n  ) { }\n\n  /**\n   * Executed command from editor header buttons exclude toggleEditorMode\n   * @param command string from triggerCommand\n   */\n  executeCommand(command: string) {\n    const commands = ['h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'p', 'pre'];\n    if (commands.includes(command)) {\n      this.doc.execCommand('formatBlock', false, command);\n      return;\n    }\n    this.doc.execCommand(command, false, null);\n  }\n\n  /**\n   * Create URL link\n   * @param url string from UI prompt\n   */\n  createLink(url: string) {\n    if (!url.includes('http')) {\n      this.doc.execCommand('createlink', false, url);\n    } else {\n      const newUrl = '<a href=\"' + url + '\" target=\"_blank\">' + this.selectedText + '</a>';\n      this.insertHtml(newUrl);\n    }\n  }\n\n  /**\n   * insert color either font or background\n   *\n   * @param color color to be inserted\n   * @param where where the color has to be inserted either text/background\n   */\n  insertColor(color: string, where: string): void {\n    const restored = this.restoreSelection();\n    if (restored) {\n      if (where === 'textColor') {\n        this.doc.execCommand('foreColor', false, color);\n      } else {\n        this.doc.execCommand('hiliteColor', false, color);\n      }\n    }\n  }\n\n  /**\n   * Set font name\n   * @param fontName string\n   */\n  setFontName(fontName: string) {\n    this.doc.execCommand('fontName', false, fontName);\n  }\n\n  /**\n   * Set font size\n   * @param fontSize string\n   */\n  setFontSize(fontSize: string) {\n    this.doc.execCommand('fontSize', false, fontSize);\n  }\n\n  /**\n   * Create raw HTML\n   * @param html HTML string\n   */\n  insertHtml(html: string): void {\n\n    const isHTMLInserted = this.doc.execCommand('insertHTML', false, html);\n\n    if (!isHTMLInserted) {\n      throw new Error('Unable to perform the operation');\n    }\n  }\n\n  /**\n   * save selection when the editor is focussed out\n   */\n  public saveSelection = (): void => {\n    if (this.doc.getSelection) {\n      const sel = this.doc.getSelection();\n      if (sel.getRangeAt && sel.rangeCount) {\n        this.savedSelection = sel.getRangeAt(0);\n        this.selectedText = sel.toString();\n      }\n    } else if (this.doc.getSelection && this.doc.createRange) {\n      this.savedSelection = document.createRange();\n    } else {\n      this.savedSelection = null;\n    }\n  }\n\n  /**\n   * restore selection when the editor is focused in\n   *\n   * saved selection when the editor is focused out\n   */\n  restoreSelection(): boolean {\n    if (this.savedSelection) {\n      if (this.doc.getSelection) {\n        const sel = this.doc.getSelection();\n        sel.removeAllRanges();\n        sel.addRange(this.savedSelection);\n        return true;\n      } else if (this.doc.getSelection /*&& this.savedSelection.select*/) {\n        // this.savedSelection.select();\n        return true;\n      }\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * setTimeout used for execute 'saveSelection' method in next event loop iteration\n   */\n  public executeInNextQueueIteration(callbackFn: (...args: any[]) => any, timeout = 1e2): void {\n    setTimeout(callbackFn, timeout);\n  }\n\n  /** check any selection is made or not */\n  private checkSelection(): any {\n\n    const selectedText = this.savedSelection.toString();\n\n    if (selectedText.length === 0) {\n      throw new Error('No Selection Made');\n    }\n    return true;\n  }\n\n  /**\n   * Upload file to uploadUrl\n   * @param file The file\n   */\n  uploadImage(file: File): Observable<HttpEvent<UploadResponse>> {\n\n    const uploadData: FormData = new FormData();\n\n    uploadData.append('file', file, file.name);\n\n    return this.http.post<UploadResponse>(this.uploadUrl, uploadData, {\n      reportProgress: true,\n      observe: 'events',\n      withCredentials: this.uploadWithCredentials,\n    });\n  }\n\n  /**\n   * Insert image with Url\n   * @param imageUrl The imageUrl.\n   */\n  insertImage(imageUrl: string) {\n    this.doc.execCommand('insertImage', false, imageUrl);\n  }\n\n  setDefaultParagraphSeparator(separator: string) {\n    this.doc.execCommand('defaultParagraphSeparator', false, separator);\n  }\n\n  createCustomClass(customClass: CustomClass) {\n    let newTag = this.selectedText;\n    if (customClass) {\n      const tagName = customClass.tag ? customClass.tag : 'span';\n      newTag = '<' + tagName + ' class=\"' + customClass.class + '\">' + this.selectedText + '</' + tagName + '>';\n    }\n    this.insertHtml(newTag);\n  }\n\n  insertVideo(videoUrl: string) {\n    if (videoUrl.match('www.youtube.com')) {\n      this.insertYouTubeVideoTag(videoUrl);\n    }\n    if (videoUrl.match('vimeo.com')) {\n      this.insertVimeoVideoTag(videoUrl);\n    }\n  }\n\n  private insertYouTubeVideoTag(videoUrl: string): void {\n    const id = videoUrl.split('v=')[1];\n    const imageUrl = `https://img.youtube.com/vi/${id}/0.jpg`;\n    const thumbnail = `\n      <div style='position: relative'>\n        <a href='${videoUrl}' target='_blank'>\n          <img src=\"${imageUrl}\" alt=\"click to watch\"/>\n          <img style='position: absolute; left:200px; top:140px'\n          src=\"https://img.icons8.com/color/96/000000/youtube-play.png\"/>\n        </a>\n      </div>`;\n    this.insertHtml(thumbnail);\n  }\n\n  private insertVimeoVideoTag(videoUrl: string): void {\n    const sub = this.http.get<any>(`https://vimeo.com/api/oembed.json?url=${videoUrl}`).subscribe(data => {\n      const imageUrl = data.thumbnail_url_with_play_button;\n      const thumbnail = `<div>\n        <a href='${videoUrl}' target='_blank'>\n          <img src=\"${imageUrl}\" alt=\"${data.title}\"/>\n        </a>\n      </div>`;\n      this.insertHtml(thumbnail);\n      sub.unsubscribe();\n    });\n  }\n\n  nextNode(node) {\n    if (node.hasChildNodes()) {\n      return node.firstChild;\n    } else {\n      while (node && !node.nextSibling) {\n        node = node.parentNode;\n      }\n      if (!node) {\n        return null;\n      }\n      return node.nextSibling;\n    }\n  }\n\n  getRangeSelectedNodes(range, includePartiallySelectedContainers) {\n    let node = range.startContainer;\n    const endNode = range.endContainer;\n    let rangeNodes = [];\n\n    // Special case for a range that is contained within a single node\n    if (node === endNode) {\n      rangeNodes = [node];\n    } else {\n      // Iterate nodes until we hit the end container\n      while (node && node !== endNode) {\n        rangeNodes.push( node = this.nextNode(node) );\n      }\n\n      // Add partially selected nodes at the start of the range\n      node = range.startContainer;\n      while (node && node !== range.commonAncestorContainer) {\n        rangeNodes.unshift(node);\n        node = node.parentNode;\n      }\n    }\n\n    // Add ancestors of the range container, if required\n    if (includePartiallySelectedContainers) {\n      node = range.commonAncestorContainer;\n      while (node) {\n        rangeNodes.push(node);\n        node = node.parentNode;\n      }\n    }\n\n    return rangeNodes;\n  }\n\n  getSelectedNodes() {\n    const nodes = [];\n    if (this.doc.getSelection) {\n      const sel = this.doc.getSelection();\n      for (let i = 0, len = sel.rangeCount; i < len; ++i) {\n        nodes.push.apply(nodes, this.getRangeSelectedNodes(sel.getRangeAt(i), true));\n      }\n    }\n    return nodes;\n  }\n\n  replaceWithOwnChildren(el) {\n    const parent = el.parentNode;\n    while (el.hasChildNodes()) {\n      parent.insertBefore(el.firstChild, el);\n    }\n    parent.removeChild(el);\n  }\n\n  removeSelectedElements(tagNames) {\n    const tagNamesArray = tagNames.toLowerCase().split(',');\n    this.getSelectedNodes().forEach((node) => {\n      if (node.nodeType === 1 &&\n        tagNamesArray.indexOf(node.tagName.toLowerCase()) > -1) {\n        // Remove the node and replace it with its children\n        this.replaceWithOwnChildren(node);\n      }\n    });\n  }\n}\n"]}

package/esm2020/lib/config.mjs

@@ -0,0 +1,36 @@
+export const angularEditorConfig = {
+    editable: true,
+    spellcheck: true,
+    height: 'auto',
+    minHeight: '0',
+    maxHeight: 'auto',
+    width: 'auto',
+    minWidth: '0',
+    translate: 'yes',
+    enableToolbar: true,
+    showToolbar: true,
+    placeholder: 'Enter text here...',
+    defaultParagraphSeparator: '',
+    defaultFontName: '',
+    defaultFontSize: '',
+    fonts: [
+        { class: 'arial', name: 'Arial' },
+        { class: 'times-new-roman', name: 'Times New Roman' },
+        { class: 'calibri', name: 'Calibri' },
+        { class: 'comic-sans-ms', name: 'Comic Sans MS' }
+    ],
+    uploadUrl: 'v1/image',
+    uploadWithCredentials: false,
+    sanitize: true,
+    toolbarPosition: 'top',
+    outline: true,
+    /*toolbarHiddenButtons: [
+      ['bold', 'italic', 'underline', 'strikeThrough', 'superscript', 'subscript'],
+      ['heading', 'fontName', 'fontSize', 'color'],
+      ['justifyLeft', 'justifyCenter', 'justifyRight', 'justifyFull', 'indent', 'outdent'],
+      ['cut', 'copy', 'delete', 'removeFormat', 'undo', 'redo'],
+      ['paragraph', 'blockquote', 'removeBlockquote', 'horizontalLine', 'orderedList', 'unorderedList'],
+      ['link', 'unlink', 'image', 'video']
+    ]*/
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvYW5ndWxhci1lZGl0b3Ivc3JjL2xpYi9jb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBMENBLE1BQU0sQ0FBQyxNQUFNLG1CQUFtQixHQUF3QjtJQUN0RCxRQUFRLEVBQUUsSUFBSTtJQUNkLFVBQVUsRUFBRSxJQUFJO0lBQ2hCLE1BQU0sRUFBRSxNQUFNO0lBQ2QsU0FBUyxFQUFFLEdBQUc7SUFDZCxTQUFTLEVBQUUsTUFBTTtJQUNqQixLQUFLLEVBQUUsTUFBTTtJQUNiLFFBQVEsRUFBRSxHQUFHO0lBQ2IsU0FBUyxFQUFFLEtBQUs7SUFDaEIsYUFBYSxFQUFFLElBQUk7SUFDbkIsV0FBVyxFQUFFLElBQUk7SUFDakIsV0FBVyxFQUFFLG9CQUFvQjtJQUNqQyx5QkFBeUIsRUFBRSxFQUFFO0lBQzdCLGVBQWUsRUFBRSxFQUFFO0lBQ25CLGVBQWUsRUFBRSxFQUFFO0lBQ25CLEtBQUssRUFBRTtRQUNMLEVBQUMsS0FBSyxFQUFFLE9BQU8sRUFBRSxJQUFJLEVBQUUsT0FBTyxFQUFDO1FBQy9CLEVBQUMsS0FBSyxFQUFFLGlCQUFpQixFQUFFLElBQUksRUFBRSxpQkFBaUIsRUFBQztRQUNuRCxFQUFDLEtBQUssRUFBRSxTQUFTLEVBQUUsSUFBSSxFQUFFLFNBQVMsRUFBQztRQUNuQyxFQUFDLEtBQUssRUFBRSxlQUFlLEVBQUUsSUFBSSxFQUFFLGVBQWUsRUFBQztLQUNoRDtJQUNELFNBQVMsRUFBRSxVQUFVO0lBQ3JCLHFCQUFxQixFQUFFLEtBQUs7SUFDNUIsUUFBUSxFQUFFLElBQUk7SUFDZCxlQUFlLEVBQUUsS0FBSztJQUN0QixPQUFPLEVBQUUsSUFBSTtJQUNiOzs7Ozs7O09BT0c7Q0FDSixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgVXBsb2FkUmVzcG9uc2UgfSBmcm9tICcuL2FuZ3VsYXItZWRpdG9yLnNlcnZpY2UnO1xuaW1wb3J0IHsgSHR0cEV2ZW50IH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uL2h0dHAnO1xuaW1wb3J0IHsgT2JzZXJ2YWJsZSB9IGZyb20gJ3J4anMnO1xuXG5leHBvcnQgaW50ZXJmYWNlIEN1c3RvbUNsYXNzIHtcbiAgbmFtZTogc3RyaW5nO1xuICBjbGFzczogc3RyaW5nO1xuICB0YWc/OiBzdHJpbmc7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgRm9udCB7XG4gIG5hbWU6IHN0cmluZztcbiAgY2xhc3M6IHN0cmluZztcbn1cblxuZXhwb3J0IGludGVyZmFjZSBBbmd1bGFyRWRpdG9yQ29uZmlnIHtcbiAgZWRpdGFibGU/OiBib29sZWFuO1xuICBzcGVsbGNoZWNrPzogYm9vbGVhbjtcbiAgaGVpZ2h0PzogJ2F1dG8nIHwgc3RyaW5nO1xuICBtaW5IZWlnaHQ/OiAnMCcgfCBzdHJpbmc7XG4gIG1heEhlaWdodD86ICdhdXRvJyB8IHN0cmluZztcbiAgd2lkdGg/OiAnYXV0bycgfCBzdHJpbmc7XG4gIG1pbldpZHRoPzogJzAnIHwgc3RyaW5nO1xuICB0cmFuc2xhdGU/OiAneWVzJyB8ICdub3cnIHwgc3RyaW5nO1xuICBlbmFibGVUb29sYmFyPzogYm9vbGVhbjtcbiAgc2hvd1Rvb2xiYXI/OiBib29sZWFuO1xuICBwbGFjZWhvbGRlcj86IHN0cmluZztcbiAgZGVmYXVsdFBhcmFncmFwaFNlcGFyYXRvcj86IHN0cmluZztcbiAgZGVmYXVsdEZvbnROYW1lPzogc3RyaW5nO1xuICBkZWZhdWx0Rm9udFNpemU/OiAnMScgfCAnMicgfCAnMycgfCAnNCcgfCAnNScgfCAnNicgfCAnNycgfCBzdHJpbmc7XG4gIHVwbG9hZFVybD86IHN0cmluZztcbiAgdXBsb2FkPzogKGZpbGU6IEZpbGUpID0+IE9ic2VydmFibGU8SHR0cEV2ZW50PFVwbG9hZFJlc3BvbnNlPj47XG4gIHVwbG9hZFdpdGhDcmVkZW50aWFscz86IGJvb2xlYW47XG4gIGZvbnRzPzogRm9udFtdO1xuICBjdXN0b21DbGFzc2VzPzogQ3VzdG9tQ2xhc3NbXTtcbiAgc2FuaXRpemU/OiBib29sZWFuO1xuICB0b29sYmFyUG9zaXRpb24/OiAndG9wJyB8ICdib3R0b20nO1xuICBvdXRsaW5lPzogYm9vbGVhbjtcbiAgdG9vbGJhckhpZGRlbkJ1dHRvbnM/OiBzdHJpbmdbXVtdO1xuICByYXdQYXN0ZT86IGJvb2xlYW47XG59XG5cbmV4cG9ydCBjb25zdCBhbmd1bGFyRWRpdG9yQ29uZmlnOiBBbmd1bGFyRWRpdG9yQ29uZmlnID0ge1xuICBlZGl0YWJsZTogdHJ1ZSxcbiAgc3BlbGxjaGVjazogdHJ1ZSxcbiAgaGVpZ2h0OiAnYXV0bycsXG4gIG1pbkhlaWdodDogJzAnLFxuICBtYXhIZWlnaHQ6ICdhdXRvJyxcbiAgd2lkdGg6ICdhdXRvJyxcbiAgbWluV2lkdGg6ICcwJyxcbiAgdHJhbnNsYXRlOiAneWVzJyxcbiAgZW5hYmxlVG9vbGJhcjogdHJ1ZSxcbiAgc2hvd1Rvb2xiYXI6IHRydWUsXG4gIHBsYWNlaG9sZGVyOiAnRW50ZXIgdGV4dCBoZXJlLi4uJyxcbiAgZGVmYXVsdFBhcmFncmFwaFNlcGFyYXRvcjogJycsXG4gIGRlZmF1bHRGb250TmFtZTogJycsXG4gIGRlZmF1bHRGb250U2l6ZTogJycsXG4gIGZvbnRzOiBbXG4gICAge2NsYXNzOiAnYXJpYWwnLCBuYW1lOiAnQXJpYWwnfSxcbiAgICB7Y2xhc3M6ICd0aW1lcy1uZXctcm9tYW4nLCBuYW1lOiAnVGltZXMgTmV3IFJvbWFuJ30sXG4gICAge2NsYXNzOiAnY2FsaWJyaScsIG5hbWU6ICdDYWxpYnJpJ30sXG4gICAge2NsYXNzOiAnY29taWMtc2Fucy1tcycsIG5hbWU6ICdDb21pYyBTYW5zIE1TJ31cbiAgXSxcbiAgdXBsb2FkVXJsOiAndjEvaW1hZ2UnLFxuICB1cGxvYWRXaXRoQ3JlZGVudGlhbHM6IGZhbHNlLFxuICBzYW5pdGl6ZTogdHJ1ZSxcbiAgdG9vbGJhclBvc2l0aW9uOiAndG9wJyxcbiAgb3V0bGluZTogdHJ1ZSxcbiAgLyp0b29sYmFySGlkZGVuQnV0dG9uczogW1xuICAgIFsnYm9sZCcsICdpdGFsaWMnLCAndW5kZXJsaW5lJywgJ3N0cmlrZVRocm91Z2gnLCAnc3VwZXJzY3JpcHQnLCAnc3Vic2NyaXB0J10sXG4gICAgWydoZWFkaW5nJywgJ2ZvbnROYW1lJywgJ2ZvbnRTaXplJywgJ2NvbG9yJ10sXG4gICAgWydqdXN0aWZ5TGVmdCcsICdqdXN0aWZ5Q2VudGVyJywgJ2p1c3RpZnlSaWdodCcsICdqdXN0aWZ5RnVsbCcsICdpbmRlbnQnLCAnb3V0ZGVudCddLFxuICAgIFsnY3V0JywgJ2NvcHknLCAnZGVsZXRlJywgJ3JlbW92ZUZvcm1hdCcsICd1bmRvJywgJ3JlZG8nXSxcbiAgICBbJ3BhcmFncmFwaCcsICdibG9ja3F1b3RlJywgJ3JlbW92ZUJsb2NrcXVvdGUnLCAnaG9yaXpvbnRhbExpbmUnLCAnb3JkZXJlZExpc3QnLCAndW5vcmRlcmVkTGlzdCddLFxuICAgIFsnbGluaycsICd1bmxpbmsnLCAnaW1hZ2UnLCAndmlkZW8nXVxuICBdKi9cbn07XG4iXX0=

package/esm2020/lib/utils.mjs

@@ -0,0 +1,4 @@
+export function isDefined(value) {
+    return value !== undefined && value !== null;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLWVkaXRvci9zcmMvbGliL3V0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sVUFBVSxTQUFTLENBQUMsS0FBVTtJQUNsQyxPQUFPLEtBQUssS0FBSyxTQUFTLElBQUksS0FBSyxLQUFLLElBQUksQ0FBQztBQUMvQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGZ1bmN0aW9uIGlzRGVmaW5lZCh2YWx1ZTogYW55KSB7XG4gIHJldHVybiB2YWx1ZSAhPT0gdW5kZWZpbmVkICYmIHZhbHVlICE9PSBudWxsO1xufVxuIl19

package/esm2020/public-api.mjs

@@ -0,0 +1,8 @@
+/*
+ * Public API Surface of angular-editor
+ */
+export * from './lib/angular-editor.service';
+export * from './lib/angular-editor.component';
+export * from './lib/angular-editor-toolbar.component';
+export * from './lib/angular-editor.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXItZWRpdG9yL3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLGdDQUFnQyxDQUFDO0FBQy9DLGNBQWMsd0NBQXdDLENBQUM7QUFDdkQsY0FBYyw2QkFBNkIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBQdWJsaWMgQVBJIFN1cmZhY2Ugb2YgYW5ndWxhci1lZGl0b3JcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2xpYi9hbmd1bGFyLWVkaXRvci5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2FuZ3VsYXItZWRpdG9yLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9hbmd1bGFyLWVkaXRvci10b29sYmFyLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9hbmd1bGFyLWVkaXRvci5tb2R1bGUnO1xuZXhwb3J0IHsgQW5ndWxhckVkaXRvckNvbmZpZywgQ3VzdG9tQ2xhc3MgfSBmcm9tICcuL2xpYi9jb25maWcnO1xuIl19

package/eugenemahota-angular-editor.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@eugenemahota/angular-editor" />
+export * from './public-api';