tiny-markdown-editor 0.1.8 → 0.1.10

package/globals.d.ts

@@ -0,0 +1,172 @@
+declare module "tiny-markdown-editor" {
+  type CursorPosition = {
+    col: number;
+    row: number;
+    node?: HTMLElement;
+  };
+
+  type CommonCommandName =
+    | "bold"
+    | "italic"
+    | "strikethrough"
+    | "code"
+    | "h1"
+    | "h2"
+    | "ul"
+    | "ol"
+    | "blockquote";
+
+  type CommandBarCommandName =
+    | CommonCommandName
+    | "hr"
+    | "insertLink"
+    | "insertImage";
+
+  type EditorCommandName = CommonCommandName | "h3" | "h4" | "h5" | "h6";
+
+  type ChangeEvent = {
+    content: string;
+    linesDirty: boolean[];
+  };
+
+  type SelectionEvent = {
+    focus: CursorPosition;
+    anchor: CursorPosition;
+    commandState: Record<EditorCommandName, boolean>;
+  };
+
+  type Listener<T extends "change" | "selection"> = (
+    event: T extends "change" ? ChangeEvent : SelectionEvent
+  ) => void;
+
+  type EditorParams = {
+    element?: string | HTMLElement;
+    content?: string;
+    textarea?: string | HTMLElement;
+  };
+
+  export class Editor {
+    constructor(params: EditorParams?);
+
+    public getContent(): string;
+
+    public getSelection(getAnchor: boolean): CursorPosition | null;
+
+    public setSelection(
+      focus: CursorPosition,
+      anchor?: CursorPosition | null
+    ): void;
+
+    public paste(
+      text: string,
+      anchor: CursorPosition,
+      focus: CursorPosition
+    ): void;
+
+    public wrapSelection(
+      pre: string,
+      post: string,
+      anchor?: CursorPosition | null,
+      focus?: CursorPosition | null
+    ): void;
+
+    public addEventListener<T extends "change" | "selection">(
+      type: T,
+      listener: Listener<T>
+    ): void;
+  }
+
+  type ModifierKey =
+    | "Ctrl"
+    | "Cmd"
+    | "Alt"
+    | "Option"
+    | "Win"
+    | "Shift"
+    | "Mod"
+    | "Mod2";
+  type AlphanumericKey =
+    | "A"
+    | "B"
+    | "C"
+    | "D"
+    | "E"
+    | "F"
+    | "G"
+    | "H"
+    | "I"
+    | "J"
+    | "K"
+    | "L"
+    | "M"
+    | "N"
+    | "O"
+    | "P"
+    | "Q"
+    | "R"
+    | "S"
+    | "T"
+    | "U"
+    | "V"
+    | "W"
+    | "X"
+    | "Y"
+    | "Z"
+    | "a"
+    | "b"
+    | "c"
+    | "d"
+    | "e"
+    | "f"
+    | "g"
+    | "h"
+    | "i"
+    | "j"
+    | "k"
+    | "l"
+    | "m"
+    | "n"
+    | "o"
+    | "p"
+    | "q"
+    | "r"
+    | "s"
+    | "t"
+    | "u"
+    | "v"
+    | "w"
+    | "x"
+    | "y"
+    | "z"
+    | "0"
+    | "1"
+    | "2"
+    | "3"
+    | "4"
+    | "5"
+    | "6"
+    | "7"
+    | "8"
+    | "9";
+  type HotKey = AlphanumericKey | `${ModifierKey}-${HotKey}`;
+
+  type CommandBarCommand =
+    | CommandBarCommandName
+    | "|"
+    | {
+        name: CommandBarCommandName | string;
+        title?: string | undefined;
+        innerHTML?: string;
+        action?: (editor: Editor) => void;
+        hotkey?: HotKey;
+      };
+
+  type CommandBarParams = {
+    element?: string | HTMLElement;
+    editor: Editor;
+    commands?: CommandBarCommand[];
+  };
+  export class CommandBar {
+    constructor(params: CommandBarParams);
+  }
+}

package/lib/TinyMDE.js

@@ -1,10 +1,4 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _grammar = require("./grammar");
+import { inlineGrammar, lineGrammar, punctuationLeading, punctuationTrailing, htmlescape, htmlBlockGrammar, commands } from "./grammar";
 class Editor {
   constructor() {
     let props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
@@ -121,7 +115,7 @@ class Editor {
     this.linkLabels = [];
     for (let l = 0; l < this.lines.length; l++) {
       if (this.lineTypes[l] == 'TMLinkReferenceDefinition') {
-        this.linkLabels.push(this.lineCaptures[l][_grammar.lineGrammar.TMLinkReferenceDefinition.labelPlaceholder]);
+        this.linkLabels.push(this.lineCaptures[l][lineGrammar.TMLinkReferenceDefinition.labelPlaceholder]);
       }
     }
   }
@@ -138,7 +132,7 @@ class Editor {
    */
   replace(replacement, capture) {
     return replacement.replace(/(\${1,2})([0-9])/g, (str, p1, p2) => {
-      if (p1 == '$') return (0, _grammar.htmlescape)(capture[p2]);else return `<span class="TMInlineFormatted">${this.processInlineStyles(capture[p2])}</span>`;
+      if (p1 == '$') return htmlescape(capture[p2]);else return `<span class="TMInlineFormatted">${this.processInlineStyles(capture[p2])}</span>`;
     });
   }
 
@@ -178,10 +172,10 @@ class Editor {
       // if (lineNum > 0 && (this.lineTypes[lineNum - 1] == 'TMCodeFenceBacktickOpen' || this.lineTypes[lineNum - 1] == 'TMFencedCodeBacktick')) {
       if (codeBlockType == 'TMCodeFenceBacktickOpen') {
         // We're in a backtick-fenced code block, check if the current line closes it
-        let capture = _grammar.lineGrammar.TMCodeFenceBacktickClose.regexp.exec(this.lines[lineNum]);
+        let capture = lineGrammar.TMCodeFenceBacktickClose.regexp.exec(this.lines[lineNum]);
         if (capture && capture.groups['seq'].length >= codeBlockSeqLength) {
           lineType = 'TMCodeFenceBacktickClose';
-          lineReplacement = _grammar.lineGrammar.TMCodeFenceBacktickClose.replacement;
+          lineReplacement = lineGrammar.TMCodeFenceBacktickClose.replacement;
           lineCapture = capture;
           codeBlockType = false;
         } else {
@@ -193,10 +187,10 @@ class Editor {
       // if (lineNum > 0 && (this.lineTypes[lineNum - 1] == 'TMCodeFenceTildeOpen' || this.lineTypes[lineNum - 1] == 'TMFencedCodeTilde')) {
       else if (codeBlockType == 'TMCodeFenceTildeOpen') {
         // We're in a tilde-fenced code block
-        let capture = _grammar.lineGrammar.TMCodeFenceTildeClose.regexp.exec(this.lines[lineNum]);
+        let capture = lineGrammar.TMCodeFenceTildeClose.regexp.exec(this.lines[lineNum]);
         if (capture && capture.groups['seq'].length >= codeBlockSeqLength) {
           lineType = 'TMCodeFenceTildeClose';
-          lineReplacement = _grammar.lineGrammar.TMCodeFenceTildeClose.replacement;
+          lineReplacement = lineGrammar.TMCodeFenceTildeClose.replacement;
           lineCapture = capture;
           codeBlockType = false;
         } else {
@@ -208,7 +202,7 @@ class Editor {
 
       // Check HTML block types
       if (lineType == 'TMPara' && htmlBlock === false) {
-        for (let htmlBlockType of _grammar.htmlBlockGrammar) {
+        for (let htmlBlockType of htmlBlockGrammar) {
           if (this.lines[lineNum].match(htmlBlockType.start)) {
             // Matching start condition. Check if this tag can start here (not all start conditions allow breaking a paragraph).
             if (htmlBlockType.paraInterrupt || lineNum == 0 || !(this.lineTypes[lineNum - 1] == 'TMPara' || this.lineTypes[lineNum - 1] == 'TMUL' || this.lineTypes[lineNum - 1] == 'TMOL' || this.lineTypes[lineNum - 1] == 'TMBlockquote')) {
@@ -231,7 +225,7 @@ class Editor {
           }
         } else {
           // No specific end condition, ends with blank line
-          if (lineNum == this.lines.length - 1 || this.lines[lineNum + 1].match(_grammar.lineGrammar.TMBlankLine.regexp)) {
+          if (lineNum == this.lines.length - 1 || this.lines[lineNum + 1].match(lineGrammar.TMBlankLine.regexp)) {
             htmlBlock = false;
           }
         }
@@ -239,12 +233,12 @@ class Editor {
 
       // Check all regexps if we haven't applied one of the code block types
       if (lineType == 'TMPara') {
-        for (let type in _grammar.lineGrammar) {
-          if (_grammar.lineGrammar[type].regexp) {
-            let capture = _grammar.lineGrammar[type].regexp.exec(this.lines[lineNum]);
+        for (let type in lineGrammar) {
+          if (lineGrammar[type].regexp) {
+            let capture = lineGrammar[type].regexp.exec(this.lines[lineNum]);
             if (capture) {
               lineType = type;
-              lineReplacement = _grammar.lineGrammar[type].replacement;
+              lineReplacement = lineGrammar[type].replacement;
               lineCapture = capture;
               break;
             }
@@ -268,10 +262,10 @@ class Editor {
 
       // Setext H2 markers that can also be interpreted as an empty list item should be regarded as such (as per CommonMark spec)
       if (lineType == 'TMSetextH2Marker') {
-        let capture = _grammar.lineGrammar.TMUL.regexp.exec(this.lines[lineNum]);
+        let capture = lineGrammar.TMUL.regexp.exec(this.lines[lineNum]);
         if (capture) {
           lineType = 'TMUL';
-          lineReplacement = _grammar.lineGrammar.TMUL.replacement;
+          lineReplacement = lineGrammar.TMUL.replacement;
           lineCapture = capture;
         }
       }
@@ -280,12 +274,12 @@ class Editor {
       if (lineType == 'TMSetextH1Marker' || lineType == 'TMSetextH2Marker') {
         if (lineNum == 0 || this.lineTypes[lineNum - 1] != 'TMPara') {
           // Setext marker is invalid. However, a H2 marker might still be a valid HR, so let's check that
-          let capture = _grammar.lineGrammar.TMHR.regexp.exec(this.lines[lineNum]);
+          let capture = lineGrammar.TMHR.regexp.exec(this.lines[lineNum]);
           if (capture) {
             // Valid HR
             lineType = 'TMHR';
             lineCapture = capture;
-            lineReplacement = _grammar.lineGrammar.TMHR.replacement;
+            lineReplacement = lineGrammar.TMHR.replacement;
           } else {
             // Not valid HR, format as TMPara
             lineType = 'TMPara';
@@ -353,7 +347,7 @@ class Editor {
       // Capture any escapes and code blocks at current position, they bind more strongly than links
       // We don't have to actually process them here, that'll be done later in case the link / image is valid, but we need to skip over them.
       for (let rule of ['escape', 'code', 'autolink', 'html']) {
-        let cap = _grammar.inlineGrammar[rule].regexp.exec(string);
+        let cap = inlineGrammar[rule].regexp.exec(string);
         if (cap) {
           currentOffset += cap[0].length;
           continue textOuter;
@@ -361,7 +355,7 @@ class Editor {
       }
 
       // Check for image. It's okay for an image to be included in a link or image
-      if (string.match(_grammar.inlineGrammar.imageOpen.regexp)) {
+      if (string.match(inlineGrammar.imageOpen.regexp)) {
         // Opening image. It's okay if this is a matching pair of brackets
         bracketLevel++;
         currentOffset += 2;
@@ -369,7 +363,7 @@ class Editor {
       }
 
       // Check for link (not an image because that would have been captured and skipped over above)
-      if (string.match(_grammar.inlineGrammar.linkOpen.regexp)) {
+      if (string.match(inlineGrammar.linkOpen.regexp)) {
         // Opening bracket. Two things to do:
         // 1) it's okay if this part of a pair of brackets.
         // 2) If we are currently trying to parse a link, this nested bracket musn't start a valid link (no nested links allowed)
@@ -409,14 +403,14 @@ class Editor {
     // REFERENCE LINKS
     if (nextChar == '[') {
       let string = originalString.substr(currentOffset);
-      let cap = _grammar.inlineGrammar.linkLabel.regexp.exec(string);
+      let cap = inlineGrammar.linkLabel.regexp.exec(string);
       if (cap) {
         // Valid link label
         currentOffset += cap[0].length;
         linkLabel.push(cap[1], cap[2], cap[3]);
-        if (cap[_grammar.inlineGrammar.linkLabel.labelPlaceholder]) {
+        if (cap[inlineGrammar.linkLabel.labelPlaceholder]) {
           // Full reference link
-          linkRef = cap[_grammar.inlineGrammar.linkLabel.labelPlaceholder];
+          linkRef = cap[inlineGrammar.linkLabel.labelPlaceholder];
         } else {
           // Collapsed reference link
           linkRef = linkText.trim();
@@ -490,7 +484,7 @@ class Editor {
         }
 
         // Process backslash escapes
-        cap = _grammar.inlineGrammar.escape.regexp.exec(string);
+        cap = inlineGrammar.escape.regexp.exec(string);
         if (cap) {
           switch (linkDetails.length) {
             case 0:
@@ -719,20 +713,20 @@ class Editor {
     outer: while (string) {
       // Process simple rules (non-delimiter)
       for (let rule of ['escape', 'code', 'autolink', 'html']) {
-        let cap = _grammar.inlineGrammar[rule].regexp.exec(string);
+        let cap = inlineGrammar[rule].regexp.exec(string);
         if (cap) {
           string = string.substr(cap[0].length);
           offset += cap[0].length;
-          processed += _grammar.inlineGrammar[rule].replacement
+          processed += inlineGrammar[rule].replacement
           // .replace(/\$\$([1-9])/g, (str, p1) => processInlineStyles(cap[p1])) // todo recursive calling
-          .replace(/\$([1-9])/g, (str, p1) => (0, _grammar.htmlescape)(cap[p1]));
+          .replace(/\$([1-9])/g, (str, p1) => htmlescape(cap[p1]));
           continue outer;
         }
       }
 
       // Check for links / images
-      let potentialLink = string.match(_grammar.inlineGrammar.linkOpen.regexp);
-      let potentialImage = string.match(_grammar.inlineGrammar.imageOpen.regexp);
+      let potentialLink = string.match(inlineGrammar.linkOpen.regexp);
+      let potentialImage = string.match(inlineGrammar.imageOpen.regexp);
       if (potentialImage || potentialLink) {
         let result = this.parseLinkOrImage(string, potentialImage);
         if (result) {
@@ -756,8 +750,8 @@ class Editor {
 
         const preceding = offset > 0 ? originalString.substr(0, offset) : ' '; // beginning and end of line count as whitespace
         const following = offset + cap[0].length < originalString.length ? string : ' ';
-        const punctuationFollows = following.match(_grammar.punctuationLeading);
-        const punctuationPrecedes = preceding.match(_grammar.punctuationTrailing);
+        const punctuationFollows = following.match(punctuationLeading);
+        const punctuationPrecedes = preceding.match(punctuationTrailing);
         const whitespaceFollows = following.match(/^\s/);
         const whitespacePrecedes = preceding.match(/\s$/);
 
@@ -876,11 +870,11 @@ class Editor {
       }
 
       // Process 'default' rule
-      cap = _grammar.inlineGrammar.default.regexp.exec(string);
+      cap = inlineGrammar.default.regexp.exec(string);
       if (cap) {
         string = string.substr(cap[0].length);
         offset += cap[0].length;
-        processed += _grammar.inlineGrammar.default.replacement.replace(/\$([1-9])/g, (str, p1) => (0, _grammar.htmlescape)(cap[p1]));
+        processed += inlineGrammar.default.replacement.replace(/\$([1-9])/g, (str, p1) => htmlescape(cap[p1]));
         continue outer;
       }
       throw 'Infinite loop!';
@@ -984,7 +978,7 @@ class Editor {
     sel.col = 0;
     if (continuableType) {
       // Check if the previous line was non-empty
-      let capture = _grammar.lineGrammar[continuableType].regexp.exec(this.lines[sel.row - 1]);
+      let capture = lineGrammar[continuableType].regexp.exec(this.lines[sel.row - 1]);
       if (capture) {
         // Convention: capture[1] is the line type marker, capture[2] is the content
         if (capture[2]) {
@@ -1169,6 +1163,7 @@ class Editor {
   /**
    * Sets the selection based on rows and columns within the editor Markdown content.
    * @param {object} focus Object representing the selection, needs to have properties row and col.
+   * @param anchor Anchor of the selection. If not given, assumes the current anchor.
    */
   setSelection(focus) {
     let anchor = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
@@ -1371,6 +1366,7 @@ class Editor {
   /**
    * Returns the state (true / false) of all commands.
    * @param focus Focus of the selection. If not given, assumes the current focus.
+   * @param anchor Anchor of the selection. If not given, assumes the current anchor.
    */
   getCommandState() {
     let focus = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
@@ -1379,7 +1375,7 @@ class Editor {
     if (!focus) focus = this.getSelection(false);
     if (!anchor) anchor = this.getSelection(true);
     if (!focus) {
-      for (let cmd in _grammar.commands) {
+      for (let cmd in commands) {
         commandState[cmd] = null;
       }
       return commandState;
@@ -1398,25 +1394,25 @@ class Editor {
       end.col = this.lines[end.row].length; // Selection to beginning of next line is said to end at the beginning of the last line
     }
 
-    for (let cmd in _grammar.commands) {
-      if (_grammar.commands[cmd].type == 'inline') {
+    for (let cmd in commands) {
+      if (commands[cmd].type == 'inline') {
         if (!focus || focus.row != anchor.row || !this.isInlineFormattingAllowed(focus, anchor)) {
           commandState[cmd] = null;
         } else {
           // The command state is true if there is a respective enclosing markup node (e.g., the selection is enclosed in a <b>..</b>) ... 
-          commandState[cmd] = !!this.computeEnclosingMarkupNode(focus, anchor, _grammar.commands[cmd].className) ||
+          commandState[cmd] = !!this.computeEnclosingMarkupNode(focus, anchor, commands[cmd].className) ||
           // ... or if it's an empty string preceded by and followed by formatting markers, e.g. **|** where | is the cursor
 
-          focus.col == anchor.col && !!this.lines[focus.row].substr(0, focus.col).match(_grammar.commands[cmd].unset.prePattern) && !!this.lines[focus.row].substr(focus.col).match(_grammar.commands[cmd].unset.postPattern);
+          focus.col == anchor.col && !!this.lines[focus.row].substr(0, focus.col).match(commands[cmd].unset.prePattern) && !!this.lines[focus.row].substr(focus.col).match(commands[cmd].unset.postPattern);
         }
       }
-      if (_grammar.commands[cmd].type == 'line') {
+      if (commands[cmd].type == 'line') {
         if (!focus) {
           commandState[cmd] = null;
         } else {
-          let state = this.lineTypes[start.row] == _grammar.commands[cmd].className;
+          let state = this.lineTypes[start.row] == commands[cmd].className;
           for (let line = start.row; line <= end.row; line++) {
-            if (this.lineTypes[line] == _grammar.commands[cmd].className != state) {
+            if (this.lineTypes[line] == commands[cmd].className != state) {
               state = null;
               break;
             }
@@ -1434,14 +1430,14 @@ class Editor {
    * @param {boolean} state 
    */
   setCommandState(command, state) {
-    if (_grammar.commands[command].type == 'inline') {
+    if (commands[command].type == 'inline') {
       let anchor = this.getSelection(true);
       let focus = this.getSelection(false);
       if (!anchor) anchor = focus;
       if (!anchor) return;
       if (anchor.row != focus.row) return;
       if (!this.isInlineFormattingAllowed(focus, anchor)) return;
-      let markupNode = this.computeEnclosingMarkupNode(focus, anchor, _grammar.commands[command].className);
+      let markupNode = this.computeEnclosingMarkupNode(focus, anchor, commands[command].className);
       this.clearDirtyFlag();
 
       // First case: There's an enclosing markup node, remove the markers around that markup node
@@ -1449,24 +1445,26 @@ class Editor {
         this.lineDirty[focus.row] = true;
         const startCol = this.computeColumn(markupNode, 0);
         const len = markupNode.textContent.length;
-        const left = this.lines[focus.row].substr(0, startCol).replace(_grammar.commands[command].unset.prePattern, '');
+        const left = this.lines[focus.row].substr(0, startCol).replace(commands[command].unset.prePattern, '');
         const mid = this.lines[focus.row].substr(startCol, len);
-        const right = this.lines[focus.row].substr(startCol + len).replace(_grammar.commands[command].unset.postPattern, '');
+        const right = this.lines[focus.row].substr(startCol + len).replace(commands[command].unset.postPattern, '');
         this.lines[focus.row] = left.concat(mid, right);
         anchor.col = left.length;
         focus.col = anchor.col + len;
         this.updateFormatting();
         this.setSelection(focus, anchor);
+        this.fireChange();
 
         // Second case: Empty selection with surrounding formatting markers, remove those
-      } else if (focus.col == anchor.col && !!this.lines[focus.row].substr(0, focus.col).match(_grammar.commands[command].unset.prePattern) && !!this.lines[focus.row].substr(focus.col).match(_grammar.commands[command].unset.postPattern)) {
+      } else if (focus.col == anchor.col && !!this.lines[focus.row].substr(0, focus.col).match(commands[command].unset.prePattern) && !!this.lines[focus.row].substr(focus.col).match(commands[command].unset.postPattern)) {
         this.lineDirty[focus.row] = true;
-        const left = this.lines[focus.row].substr(0, focus.col).replace(_grammar.commands[command].unset.prePattern, '');
-        const right = this.lines[focus.row].substr(focus.col).replace(_grammar.commands[command].unset.postPattern, '');
+        const left = this.lines[focus.row].substr(0, focus.col).replace(commands[command].unset.prePattern, '');
+        const right = this.lines[focus.row].substr(focus.col).replace(commands[command].unset.postPattern, '');
         this.lines[focus.row] = left.concat(right);
         focus.col = anchor.col = left.length;
         this.updateFormatting();
         this.setSelection(focus, anchor);
+        this.fireChange();
 
         // Not currently formatted, insert formatting markers
       } else {
@@ -1490,10 +1488,11 @@ class Editor {
         anchor.col = endCol;
 
         // Just insert markup before and after and hope for the best. 
-        this.wrapSelection(_grammar.commands[command].set.pre, _grammar.commands[command].set.post, focus, anchor);
+        this.wrapSelection(commands[command].set.pre, commands[command].set.post, focus, anchor);
+        this.fireChange();
         // TODO clean this up so that markup remains properly nested
       }
-    } else if (_grammar.commands[command].type == 'line') {
+    } else if (commands[command].type == 'line') {
       let anchor = this.getSelection(true);
       let focus = this.getSelection(false);
       if (!anchor) anchor = focus;
@@ -1505,12 +1504,12 @@ class Editor {
         end.row--;
       }
       for (let line = start.row; line <= end.row; line++) {
-        if (state && this.lineTypes[line] != _grammar.commands[command].className) {
-          this.lines[line] = this.lines[line].replace(_grammar.commands[command].set.pattern, _grammar.commands[command].set.replacement.replace('$#', line - start.row + 1));
+        if (state && this.lineTypes[line] != commands[command].className) {
+          this.lines[line] = this.lines[line].replace(commands[command].set.pattern, commands[command].set.replacement.replace('$#', line - start.row + 1));
           this.lineDirty[line] = true;
         }
-        if (!state && this.lineTypes[line] == _grammar.commands[command].className) {
-          this.lines[line] = this.lines[line].replace(_grammar.commands[command].unset.pattern, _grammar.commands[command].unset.replacement);
+        if (!state && this.lineTypes[line] == commands[command].className) {
+          this.lines[line] = this.lines[line].replace(commands[command].unset.pattern, commands[command].unset.replacement);
           this.lineDirty[line] = true;
         }
       }
@@ -1522,6 +1521,7 @@ class Editor {
         row: start.row,
         col: 0
       });
+      this.fireChange();
     }
   }
 
@@ -1642,4 +1642,4 @@ class Editor {
     }
   }
 }
-var _default = exports.default = Editor;
+export default Editor;

package/lib/TinyMDECommandBar.js

@@ -1,70 +1,63 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _svg = _interopRequireDefault(require("./svg/svg"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+import svg from './svg/svg';
 const isMacLike = /(Mac|iPhone|iPod|iPad)/i.test(navigator.platform);
 const DefaultCommands = {
   'bold': {
     name: 'bold',
     action: 'bold',
-    innerHTML: _svg.default.bold,
+    innerHTML: svg.bold,
     title: 'Bold',
     hotkey: 'Mod-B'
   },
   'italic': {
     name: 'italic',
     action: 'italic',
-    innerHTML: _svg.default.italic,
+    innerHTML: svg.italic,
     title: 'Italic',
     hotkey: 'Mod-I'
   },
   'strikethrough': {
     name: 'strikethrough',
     action: 'strikethrough',
-    innerHTML: _svg.default.strikethrough,
+    innerHTML: svg.strikethrough,
     title: 'Strikethrough',
     hotkey: 'Mod2-Shift-5'
   },
   'code': {
     name: 'code',
     action: 'code',
-    innerHTML: _svg.default.code,
+    innerHTML: svg.code,
     title: 'Format as code'
   },
   'h1': {
     name: 'h1',
     action: 'h1',
-    innerHTML: _svg.default.h1,
+    innerHTML: svg.h1,
     title: 'Level 1 heading',
     hotkey: 'Mod-Shift-1'
   },
   'h2': {
     name: 'h2',
     action: 'h2',
-    innerHTML: _svg.default.h2,
+    innerHTML: svg.h2,
     title: 'Level 2 heading',
     hotkey: 'Mod-Shift-2'
   },
   'ul': {
     name: 'ul',
     action: 'ul',
-    innerHTML: _svg.default.ul,
+    innerHTML: svg.ul,
     title: 'Bulleted list'
   },
   'ol': {
     name: 'ol',
     action: 'ol',
-    innerHTML: _svg.default.ol,
+    innerHTML: svg.ol,
     title: 'Numbered list'
   },
   'blockquote': {
     name: 'blockquote',
     action: 'blockquote',
-    innerHTML: _svg.default.blockquote,
+    innerHTML: svg.blockquote,
     title: 'Quote',
     hotkey: 'Mod2-Shift-Q'
   },
@@ -74,7 +67,7 @@ const DefaultCommands = {
       if (editor.isInlineFormattingAllowed()) editor.wrapSelection('[', ']()');
     },
     enabled: (editor, focus, anchor) => editor.isInlineFormattingAllowed(focus, anchor) ? false : null,
-    innerHTML: _svg.default.link,
+    innerHTML: svg.link,
     title: 'Insert link',
     hotkey: 'Mod-K'
   },
@@ -84,7 +77,7 @@ const DefaultCommands = {
       if (editor.isInlineFormattingAllowed()) editor.wrapSelection('![', ']()');
     },
     enabled: (editor, focus, anchor) => editor.isInlineFormattingAllowed(focus, anchor) ? false : null,
-    innerHTML: _svg.default.image,
+    innerHTML: svg.image,
     title: 'Insert image',
     hotkey: 'Mod2-Shift-I'
   },
@@ -92,7 +85,7 @@ const DefaultCommands = {
     name: 'hr',
     action: editor => editor.paste('\n***\n'),
     enabled: () => false,
-    innerHTML: _svg.default.hr,
+    innerHTML: svg.hr,
     title: 'Insert horizontal line',
     hotkey: 'Mod2-Shift-L'
   }
@@ -262,4 +255,4 @@ class CommandBar {
     }
   }
 }
-var _default = exports.default = CommandBar;
+export default CommandBar;