@seafile/sdoc-editor 2.0.82 → 2.0.83

package/dist/extension/plugins/link/helpers.js

@@ -0,0 +1,225 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.upsertLinkText = exports.updateLink = exports.unWrapLinkNode = exports.isWeChat = exports.isSdocFile = exports.isMenuDisabled = exports.isLinkToolBarActive = exports.insertLink = exports.getMenuPosition = exports.getLinkType = exports.genLinkNode = exports.checkLink = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/objectSpread2"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/slicedToArray"));
+var _slate = require("@seafile/slate");
+var _slateReact = require("@seafile/slate-react");
+var _slugid = _interopRequireDefault(require("slugid"));
+var _constants = require("../../constants");
+var _core = require("../../core");
+var isMenuDisabled = exports.isMenuDisabled = function isMenuDisabled(editor, readonly) {
+  if (readonly) return true;
+  if (editor.selection == null) return true;
+  var selectedElems = (0, _core.getSelectedElems)(editor);
+  var notMatch = selectedElems.some(function (elem) {
+    var type = elem.type;
+    if (editor.isVoid(elem)) return true;
+    if ([_constants.CODE_BLOCK, _constants.CODE_LINE, _constants.LINK].includes(type)) return true;
+    return false;
+  });
+  if (notMatch) return true; // disabled
+  return false; // enable
+};
+var checkLink = exports.checkLink = function checkLink(url) {
+  if (url.indexOf('http') !== 0) {
+    return true;
+  }
+  return false;
+};
+var genLinkNode = exports.genLinkNode = function genLinkNode(url, text) {
+  var linkNode = {
+    id: _slugid["default"].nice(),
+    type: 'link',
+    href: url,
+    title: text,
+    children: [{
+      id: _slugid["default"].nice(),
+      text: text || ''
+    }]
+  };
+  return linkNode;
+};
+var getLinkType = exports.getLinkType = function getLinkType(editor) {
+  var _Editor$nodes = _slate.Editor.nodes(editor, {
+      match: function match(n) {
+        return (0, _core.getNodeType)(n) === _constants.LINK;
+      },
+      universal: true
+    }),
+    _Editor$nodes2 = (0, _slicedToArray2["default"])(_Editor$nodes, 1),
+    match = _Editor$nodes2[0];
+  if (!match) return _constants.PARAGRAPH;
+  var _match = (0, _slicedToArray2["default"])(match, 1),
+    n = _match[0];
+  return (0, _core.getNodeType)(n);
+};
+var insertLink = exports.insertLink = function insertLink(editor, title, url) {
+  var position = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : _constants.INSERT_POSITION.CURRENT;
+  var slateNode = arguments.length > 4 ? arguments[4] : undefined;
+  if (position === _constants.INSERT_POSITION.CURRENT && isMenuDisabled(editor)) return;
+  if (!title || !url) return;
+  var linkNode = genLinkNode(url, title);
+  if (position === _constants.INSERT_POSITION.AFTER) {
+    var path = _slate.Editor.path(editor, editor.selection);
+    if (slateNode && (slateNode === null || slateNode === void 0 ? void 0 : slateNode.type) === _constants.LIST_ITEM) {
+      path = _slateReact.ReactEditor.findPath(editor, slateNode);
+      var nextPath = _slate.Path.next(path);
+      _slate.Transforms.insertNodes(editor, linkNode, {
+        at: nextPath
+      });
+      return;
+    }
+    var p = (0, _core.generateEmptyElement)(_constants.ELEMENT_TYPE.PARAGRAPH);
+    p.children[1] = linkNode;
+    _slate.Transforms.insertNodes(editor, p, {
+      at: [path[0] + 1]
+    });
+    return;
+  }
+
+  // Selection folded or not
+  var selection = editor.selection;
+  if (selection == null) return;
+  var isCollapsed = _slate.Range.isCollapsed(selection);
+  if (isCollapsed) {
+    _slate.Transforms.insertNodes(editor, linkNode);
+    return;
+  }
+  var selectedText = _slate.Editor.string(editor, selection); // Selected text
+
+  // If the selected text is different from the typed text, delete the text and insert the link
+  if (selectedText !== title) {
+    editor.deleteFragment();
+    _slate.Transforms.insertNodes(editor, linkNode);
+    return;
+  }
+
+  // If the selected text is the same as the entered text, only the link can be wrapped
+  _slate.Transforms.wrapNodes(editor, linkNode, {
+    split: true
+  });
+  _slate.Transforms.collapse(editor, {
+    edge: 'end'
+  });
+};
+var updateLink = exports.updateLink = function updateLink(editor, newText, newUrl) {
+  // Update children
+  var linkAbove = (0, _core.getAboveNode)(editor, {
+    match: {
+      type: _constants.LINK
+    }
+  });
+  if (linkAbove) {
+    var _ref = linkAbove[0] || {},
+      oldUrl = _ref.href,
+      oldText = _ref.title;
+    if (oldUrl !== newUrl || oldText !== newText) {
+      _slate.Transforms.setNodes(editor, {
+        href: newUrl,
+        title: newText
+      }, {
+        at: linkAbove[1]
+      });
+    }
+    upsertLinkText(editor, {
+      text: newText
+    });
+    return true;
+  }
+};
+var upsertLinkText = exports.upsertLinkText = function upsertLinkText(editor, _ref2) {
+  var text = _ref2.text;
+  var newLink = (0, _core.getAboveNode)(editor, {
+    match: {
+      type: _constants.LINK
+    }
+  });
+  if (newLink) {
+    var _newLink = (0, _slicedToArray2["default"])(newLink, 2),
+      newLInkNode = _newLink[0],
+      newLinkPath = _newLink[1];
+    if (text && text.length && text !== (0, _core.getEditorString)(editor, newLinkPath)) {
+      var firstText = newLInkNode.children[0];
+      (0, _core.replaceNodeChildren)(editor, {
+        at: newLinkPath,
+        nodes: (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, firstText), {}, {
+          text: text
+        }),
+        insertOptions: {
+          select: true
+        }
+      });
+    }
+  }
+};
+var unWrapLinkNode = exports.unWrapLinkNode = function unWrapLinkNode(editor) {
+  if (editor.selection == null) return;
+  var _Editor$nodes3 = _slate.Editor.nodes(editor, {
+      match: function match(n) {
+        return (0, _core.getNodeType)(n) === _constants.LINK;
+      }
+    }),
+    _Editor$nodes4 = (0, _slicedToArray2["default"])(_Editor$nodes3, 1),
+    nodeEntry = _Editor$nodes4[0];
+
+  // If the selection is not in a link node, it is disabled
+  if (nodeEntry == null || nodeEntry[0] == null) return;
+
+  // unlink
+  _slate.Transforms.unwrapNodes(editor, {
+    match: function match(n) {
+      return (0, _core.getNodeType)(n) === _constants.LINK;
+    }
+  });
+};
+var isSdocFile = exports.isSdocFile = function isSdocFile(res, url) {
+  var files_info = res.data.files_info;
+  var fileInfo = files_info[url];
+  var _ref3 = fileInfo || {},
+    is_dir = _ref3.is_dir,
+    file_ext = _ref3.file_ext;
+  return !is_dir && file_ext === 'sdoc';
+};
+var isWeChat = exports.isWeChat = function isWeChat() {
+  var ua = window.navigator.userAgent.toLowerCase();
+  var isWeChat = ua.match(/MicroMessenger/i) === 'micromessenger';
+  var isEnterpriseWeChat = ua.match(/MicroMessenger/i) === 'micromessenger' && ua.match(/wxwork/i) === 'wxwork';
+  return isEnterpriseWeChat || isWeChat;
+};
+var getMenuPosition = exports.getMenuPosition = function getMenuPosition(element, editor) {
+  if (!element) return {};
+  var _element$getBoundingC = element.getBoundingClientRect(),
+    top = _element$getBoundingC.top,
+    left = _element$getBoundingC.left,
+    width = _element$getBoundingC.width;
+  // top = top distance - menu height
+  var menuTop = top - 42;
+  // left = left distance - (menu width / 2) + (link with / 2)
+  var menuLeft = left - 140 / 2 + width / 2;
+  var menuPosition = {
+    top: menuTop,
+    left: menuLeft
+  };
+  // topOffset: the editor container left-top distance with browser top
+  if (editor.topOffset && menuPosition.top < editor.topOffset) {
+    menuPosition['display'] = 'none';
+  }
+  return menuPosition;
+};
+var isLinkToolBarActive = exports.isLinkToolBarActive = function isLinkToolBarActive(editor) {
+  if (!editor.selection) return false;
+  var _Editor$nodes5 = _slate.Editor.nodes(editor, {
+      match: function match(n) {
+        return (0, _core.getNodeType)(n) === _constants.LINK;
+      }
+    }),
+    _Editor$nodes6 = (0, _slicedToArray2["default"])(_Editor$nodes5, 1),
+    nodeEntry = _Editor$nodes6[0];
+  if (nodeEntry) return true;
+  return false;
+};

package/dist/extension/plugins/link/hover/index.js

@@ -0,0 +1,57 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _reactDom = require("react-dom");
+var _reactI18next = require("react-i18next");
+var _slateReact = require("@seafile/slate-react");
+var _helpers = require("../helpers");
+require("./index.css");
+var LinkHover = function LinkHover(_ref) {
+  var editor = _ref.editor,
+    element = _ref.element,
+    menuPosition = _ref.menuPosition,
+    onDeleteLink = _ref.onDeleteLink,
+    onEditLink = _ref.onEditLink;
+  var readOnly = (0, _slateReact.useReadOnly)();
+  var _useTranslation = (0, _reactI18next.useTranslation)('sdoc-editor'),
+    t = _useTranslation.t;
+  var onMouseDown = (0, _react.useCallback)(function (event) {
+    event.stopPropagation();
+    if (!(0, _helpers.isWeChat)()) {
+      window.open(element.href);
+    } else {
+      // eslint-disable-next-line no-restricted-globals
+      location.href = element.href;
+    }
+  }, [element.href]);
+  return /*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, null, /*#__PURE__*/(0, _reactDom.createPortal)(/*#__PURE__*/_react["default"].createElement("div", {
+    id: "link-op-menu",
+    className: "link-op-menu",
+    style: menuPosition
+  }, /*#__PURE__*/_react["default"].createElement("span", {
+    target: "_blank",
+    rel: "noopener noreferrer",
+    className: "link-op-menu-link",
+    onMouseDown: onMouseDown
+  }, t('Open_link')), !readOnly && /*#__PURE__*/_react["default"].createElement("div", {
+    className: "link-op-icons d-flex"
+  }, /*#__PURE__*/_react["default"].createElement("span", {
+    role: "button",
+    className: "link-op-icon",
+    onClick: onEditLink
+  }, /*#__PURE__*/_react["default"].createElement("i", {
+    className: "sdocfont sdoc-rename"
+  })), /*#__PURE__*/_react["default"].createElement("span", {
+    role: "button",
+    className: "link-op-icon",
+    onClick: onDeleteLink
+  }, /*#__PURE__*/_react["default"].createElement("i", {
+    className: "sdocfont sdoc-unlink"
+  })))), document.body));
+};
+var _default = exports["default"] = LinkHover;

package/dist/extension/plugins/link/index.js

@@ -0,0 +1,21 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _constants = require("../../constants");
+var _menu = _interopRequireDefault(require("./menu"));
+var _model = _interopRequireDefault(require("./model"));
+var _plugin = _interopRequireDefault(require("./plugin"));
+var _renderElem = _interopRequireDefault(require("./render-elem"));
+var LinkPlugin = {
+  type: _constants.LINK,
+  nodeType: 'element',
+  model: _model["default"],
+  editorMenus: [_menu["default"]],
+  editorPlugin: _plugin["default"],
+  renderElements: [_renderElem["default"]]
+};
+var _default = exports["default"] = LinkPlugin;

package/dist/extension/plugins/link/menu/index.js

@@ -0,0 +1,62 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard")["default"];
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/objectSpread2"));
+var _react = _interopRequireWildcard(require("react"));
+var _constants = require("../../../../constants");
+var _commonUtils = require("../../../../utils/common-utils");
+var _commons = require("../../../commons");
+var _dropdownMenuItem = _interopRequireDefault(require("../../../commons/dropdown-menu-item"));
+var _constants2 = require("../../../constants");
+var _helpers = require("../helpers");
+var LinkMenu = function LinkMenu(_ref) {
+  var editor = _ref.editor,
+    readonly = _ref.readonly,
+    toggle = _ref.toggle,
+    eventBus = _ref.eventBus,
+    isRichEditor = _ref.isRichEditor,
+    className = _ref.className;
+  var disabled = (0, _helpers.isMenuDisabled)(editor, readonly);
+  var menuConfig = _constants2.MENUS_CONFIG_MAP[_constants2.ELEMENT_TYPE.LINK];
+  var openLinkDialog = (0, _react.useCallback)(function () {
+    eventBus.dispatch(_constants.INTERNAL_EVENT.INSERT_ELEMENT, {
+      type: _constants2.ELEMENT_TYPE.LINK,
+      editor: editor
+    });
+    toggle && toggle();
+
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [toggle, eventBus]);
+
+  // Apply for comment Editor
+  if (editor.editorType === _constants.COMMENT_EDITOR) {
+    var menuProps = (0, _objectSpread2["default"])((0, _objectSpread2["default"])({
+      isRichEditor: isRichEditor,
+      className: className
+    }, menuConfig), {}, {
+      disabled: disabled,
+      isActive: false,
+      onMouseDown: openLinkDialog
+    });
+    menuProps.id = 'sdoc-comment-editor' + menuConfig.id;
+    return /*#__PURE__*/_react["default"].createElement(_commons.MenuItem, menuProps);
+  }
+
+  // eslint-disable-next-line react-hooks/rules-of-hooks
+  var linkShortCutTexts = (0, _react.useMemo)(function () {
+    var printTexts = (0, _commonUtils.isMac)() ? ['⌘', 'k'] : ['Ctrl', 'k'];
+    return printTexts;
+  }, []);
+  return /*#__PURE__*/_react["default"].createElement(_dropdownMenuItem["default"], {
+    disabled: disabled,
+    menuConfig: menuConfig,
+    onClick: openLinkDialog,
+    shortcut: linkShortCutTexts
+  });
+};
+var _default = exports["default"] = LinkMenu;

package/dist/extension/plugins/link/model.js

@@ -0,0 +1,20 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/createClass"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/classCallCheck"));
+var _constants = require("../../constants");
+var Link = /*#__PURE__*/(0, _createClass2["default"])(function Link(options) {
+  (0, _classCallCheck2["default"])(this, Link);
+  this.type = options.type || _constants.LINK;
+  this.children = options.children || [{
+    text: ''
+  }];
+  this.href = options.href || '';
+  this.title = options.title || '';
+});
+var _default = exports["default"] = Link;

package/dist/extension/plugins/link/plugin.js

@@ -0,0 +1,189 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _toArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/toArray"));
+var _regeneratorRuntime2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/regeneratorRuntime"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/slicedToArray"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/asyncToGenerator"));
+var _slate = require("@seafile/slate");
+var _isHotkey = _interopRequireDefault(require("is-hotkey"));
+var _isUrl = _interopRequireDefault(require("is-url"));
+var _constants = require("../../../constants");
+var _context2 = _interopRequireDefault(require("../../../context"));
+var _eventBus = _interopRequireDefault(require("../../../utils/event-bus"));
+var _constants2 = require("../../constants");
+var _core = require("../../core");
+var _utils = require("../../utils");
+var _helpers = require("../sdoc-link/helpers");
+var _helpers2 = require("./helpers");
+var withLink = function withLink(editor) {
+  var normalizeNode = editor.normalizeNode,
+    isInline = editor.isInline,
+    insertData = editor.insertData,
+    insertFragment = editor.insertFragment,
+    onHotKeyDown = editor.onHotKeyDown;
+  var newEditor = editor;
+
+  // Rewrite isInline
+  newEditor.isInline = function (elem) {
+    var type = elem.type;
+    if (type === _constants2.LINK) {
+      return true;
+    }
+    return isInline(elem);
+  };
+  newEditor.insertData = /*#__PURE__*/function () {
+    var _ref = (0, _asyncToGenerator2["default"])(/*#__PURE__*/(0, _regeneratorRuntime2["default"])().mark(function _callee(data) {
+      var text, res, fileName, fileUuid, link, _link, _link2, _Editor$next, _Editor$next2, focusPath, focusPoint;
+      return (0, _regeneratorRuntime2["default"])().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            // Paste link content
+            text = data.getData('text/plain'); // Internal link, insert sdoc file link
+            if (!((0, _isUrl["default"])(text) && !(0, _utils.isImage)(text))) {
+              _context.next = 22;
+              break;
+            }
+            if (!(0, _utils.isSameDomain)(text, _context2["default"].getSetting('serviceUrl'))) {
+              _context.next = 16;
+              break;
+            }
+            _context.prev = 3;
+            _context.next = 6;
+            return _context2["default"].getLinkFilesInfo([text]);
+          case 6:
+            res = _context.sent;
+            if ((0, _helpers2.isSdocFile)(res, text)) {
+              fileName = res.data.files_info[text].name;
+              fileUuid = res.data.files_info[text].file_uuid;
+              (0, _helpers.insertSdocFileLink)(editor, fileName, fileUuid);
+            } else {
+              link = (0, _helpers2.genLinkNode)(text, text);
+              _slate.Transforms.insertNodes(newEditor, link);
+            }
+            _context.next = 14;
+            break;
+          case 10:
+            _context.prev = 10;
+            _context.t0 = _context["catch"](3);
+            _link = (0, _helpers2.genLinkNode)(text, text);
+            _slate.Transforms.insertNodes(newEditor, _link);
+          case 14:
+            _context.next = 18;
+            break;
+          case 16:
+            _link2 = (0, _helpers2.genLinkNode)(text, text);
+            _slate.Transforms.insertNodes(newEditor, _link2);
+          case 18:
+            // Void merging text from link
+            _Editor$next = _slate.Editor.next(newEditor), _Editor$next2 = (0, _slicedToArray2["default"])(_Editor$next, 2), focusPath = _Editor$next2[1];
+            focusPoint = _slate.Editor.start(newEditor, focusPath);
+            _slate.Transforms.select(newEditor, focusPoint);
+            return _context.abrupt("return");
+          case 22:
+            insertData(data);
+          case 23:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, null, [[3, 10]]);
+    }));
+    return function (_x) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+  newEditor.insertFragment = function (data) {
+    // Paste into link
+    if ((0, _core.getSelectedNodeByType)(newEditor, _constants2.LINK)) {
+      var fragments = data.slice(0).filter(function (item) {
+        return _slate.Node.string(item).length !== 0;
+      });
+      // Prevent fragments containing list blocks
+      if (fragments.length > 1 && fragments.some(function (item) {
+        return [_constants2.ORDERED_LIST, _constants2.UNORDERED_LIST].includes(item.type);
+      })) return;
+      // Prevent multiple list-items in a single list block
+      if (fragments.length === 1 && [_constants2.ORDERED_LIST, _constants2.UNORDERED_LIST].includes(fragments[0].type) && fragments[0].children.length > 1) return;
+    }
+    return insertFragment(data);
+  };
+  newEditor.onHotKeyDown = function (e) {
+    if ((0, _isHotkey["default"])('mod+k', e)) {
+      // Prevent edge behavior
+      e.preventDefault();
+      var selection = newEditor.selection;
+      var isCollapsed = _slate.Range.isCollapsed(selection);
+      var eventBus = _eventBus["default"].getInstance();
+      if (isCollapsed) {
+        eventBus.dispatch(_constants.INTERNAL_EVENT.INSERT_ELEMENT, {
+          type: _constants2.ELEMENT_TYPE.LINK,
+          editor: editor
+        });
+      } else {
+        var _getSelectedElems = (0, _core.getSelectedElems)(newEditor),
+          _getSelectedElems2 = (0, _toArray2["default"])(_getSelectedElems),
+          firstSelectedNode = _getSelectedElems2[0],
+          restNodes = _getSelectedElems2.slice(1);
+        if (!firstSelectedNode || restNodes.length) return; // If select more than one node or not select any node, return
+        var isSelectTextNodes = firstSelectedNode.children.some(function (node) {
+          return _slate.Text.isText(node);
+        });
+        if (!isSelectTextNodes) return;
+        var selectContent = window.getSelection().toString();
+        var replaceLinkNode = function replaceLinkNode() {
+          return _slate.Editor.deleteBackward(editor, selection);
+        };
+        eventBus.dispatch(_constants.INTERNAL_EVENT.INSERT_ELEMENT, {
+          type: _constants2.ELEMENT_TYPE.LINK,
+          editor: newEditor,
+          linkTitle: selectContent,
+          handleSubmit: replaceLinkNode
+        });
+      }
+    }
+    return onHotKeyDown && onHotKeyDown(e);
+  };
+
+  // Rewrite normalizeNode
+  newEditor.normalizeNode = function (_ref2) {
+    var _ref3 = (0, _slicedToArray2["default"])(_ref2, 2),
+      node = _ref3[0],
+      path = _ref3[1];
+    var type = (0, _core.getNodeType)(node);
+    if (type !== _constants2.LINK) {
+      // If the type is not link, perform default normalizeNode
+      return normalizeNode([node, path]);
+    }
+
+    // If the link is empty, delete it
+    var str = _slate.Node.string(node);
+    if (str === '') {
+      return _slate.Transforms.removeNodes(newEditor, {
+        at: path
+      });
+    }
+    return normalizeNode([node, path]);
+  };
+  newEditor.onCompositionStart = function (e) {
+    var selection = editor.selection;
+    if (_slate.Range.isCollapsed(selection)) {
+      var _Editor$nodes = _slate.Editor.nodes(editor, {
+          match: function match(n) {
+            return _slate.Element.isElement && n.type === _constants2.LINK;
+          }
+        }),
+        _Editor$nodes2 = (0, _slicedToArray2["default"])(_Editor$nodes, 1),
+        LinkNodeEntry = _Editor$nodes2[0];
+      if (LinkNodeEntry) {
+        e.preventDefault();
+        return true;
+      }
+    }
+  };
+  return newEditor;
+};
+var _default = exports["default"] = withLink;