@modusoperandi/licit 1.1.3 → 1.1.4

package/EMMarkSpec.js

@@ -1,14 +1,38 @@
-var EM_DOM = ['em', 0];
 var EMMarkSpec = {
+  attrs: {
+    overridden: {
+      "default": false
+    }
+  },
   parseDOM: [{
-    tag: 'i'
+    tag: 'i',
+    getAttrs: function getAttrs(dom) {
+      var _overridden = dom.getAttribute('overridden');
+      return {
+        overridden: _overridden === 'true'
+      };
+    }
   }, {
-    tag: 'em'
+    tag: 'em',
+    getAttrs: function getAttrs(dom) {
+      var _overridden = dom.getAttribute('overridden');
+      return {
+        overridden: _overridden === 'true'
+      };
+    }
   }, {
-    style: 'font-style=italic'
+    tag: 'span[style*=font-style]',
+    getAttrs: function getAttrs(value, dom) {
+      var _overridden = dom.getAttribute('overridden');
+      return {
+        overridden: _overridden === 'true'
+      };
+    }
   }],
-  toDOM: function toDOM() {
-    return EM_DOM;
+  toDOM: function toDOM(mark) {
+    return ['em', {
+      overridden: mark.attrs.overridden
+    }, 0];
   }
 };
 export default EMMarkSpec;

package/EMMarkSpec.js.flow

@@ -1,13 +1,38 @@
-// @flow
 
 import type { MarkSpec } from './Types.js';
 
-const EM_DOM = ['em', 0];
 
 const EMMarkSpec: MarkSpec = {
-  parseDOM: [{ tag: 'i' }, { tag: 'em' }, { style: 'font-style=italic' }],
-  toDOM() {
-    return EM_DOM;
+  attrs: {
+    overridden: { default: false },
+  },
+  parseDOM: [
+    {
+      tag: 'i',
+      getAttrs: (dom: HTMLElement) => {
+        const _overridden = dom.getAttribute('overridden');
+        return { overridden: _overridden === 'true' };
+      }
+    },
+
+    {
+      tag: 'em',
+      getAttrs: (dom: HTMLElement) => {
+        const _overridden = dom.getAttribute('overridden');
+        return { overridden: _overridden === 'true' };
+      }
+    },
+    {
+      tag: 'span[style*=font-style]',
+      getAttrs: (value, dom: HTMLElement) => {
+        const _overridden = dom.getAttribute('overridden');
+        return { overridden: _overridden === 'true' };
+
+      },
+    },
+  ],
+  toDOM(mark) {
+    return ['em', { overridden: mark.attrs.overridden }, 0];
   },
 };
 

package/EditorMarks.js

@@ -24,6 +24,7 @@ import TextSelectionMarkSpec from './TextSelectionMarkSpec.js';
 import TextSuperMarkSpec from './TextSuperMarkSpec.js';
 import TextSubMarkSpec from './TextSubMarkSpec.js';
 import TextUnderlineMarkSpec from './TextUnderlineMarkSpec.js';
+import OverrideMarkSpec from './OverrideMarkSpec.js';
 var MARK_CODE = MarkNames.MARK_CODE,
   MARK_EM = MarkNames.MARK_EM,
   MARK_FONT_SIZE = MarkNames.MARK_FONT_SIZE,
@@ -38,11 +39,12 @@ var MARK_CODE = MarkNames.MARK_CODE,
   MARK_TEXT_HIGHLIGHT = MarkNames.MARK_TEXT_HIGHLIGHT,
   MARK_TEXT_SELECTION = MarkNames.MARK_TEXT_SELECTION,
   MARK_UNDERLINE = MarkNames.MARK_UNDERLINE,
-  MARK_SPACER = MarkNames.MARK_SPACER;
+  MARK_SPACER = MarkNames.MARK_SPACER,
+  MARK_OVERRIDE = MarkNames.MARK_OVERRIDE;
 
 // These nodes are required to build basic marks.
 var nodes = _defineProperty(_defineProperty(_defineProperty({}, DOC, DocNodeSpec), PARAGRAPH, ParagraphNodeSpec), TEXT, TextNodeSpec);
-var marks = (_marks = {}, _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_marks, MARK_LINK, LinkMarkSpec), MARK_NO_BREAK, TextNoWrapMarkSpec), MARK_CODE, CodeMarkSpec), MARK_EM, EMMarkSpec), MARK_FONT_SIZE, FontSizeMarkSpec), MARK_FONT_TYPE, FontTypeMarkSpec), MARK_SPACER, SpacerMarkSpec), MARK_STRIKE, StrikeMarkSpec), MARK_STRONG, StrongMarkSpec), MARK_SUPER, TextSuperMarkSpec), _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_marks, MARK_SUB, TextSubMarkSpec), MARK_TEXT_COLOR, TextColorMarkSpec), MARK_TEXT_HIGHLIGHT, TextHighlightMarkSpec), MARK_TEXT_SELECTION, TextSelectionMarkSpec), MARK_UNDERLINE, TextUnderlineMarkSpec));
+var marks = (_marks = {}, _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_marks, MARK_LINK, LinkMarkSpec), MARK_NO_BREAK, TextNoWrapMarkSpec), MARK_CODE, CodeMarkSpec), MARK_EM, EMMarkSpec), MARK_FONT_SIZE, FontSizeMarkSpec), MARK_FONT_TYPE, FontTypeMarkSpec), MARK_SPACER, SpacerMarkSpec), MARK_STRIKE, StrikeMarkSpec), MARK_STRONG, StrongMarkSpec), MARK_SUPER, TextSuperMarkSpec), _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_marks, MARK_SUB, TextSubMarkSpec), MARK_TEXT_COLOR, TextColorMarkSpec), MARK_TEXT_HIGHLIGHT, TextHighlightMarkSpec), MARK_TEXT_SELECTION, TextSelectionMarkSpec), MARK_UNDERLINE, TextUnderlineMarkSpec), MARK_OVERRIDE, OverrideMarkSpec));
 var schema = new Schema({
   nodes: nodes,
   marks: marks

package/EditorMarks.js.flow

@@ -20,6 +20,7 @@ import TextSelectionMarkSpec from './TextSelectionMarkSpec.js';
 import TextSuperMarkSpec from './TextSuperMarkSpec.js';
 import TextSubMarkSpec from './TextSubMarkSpec.js';
 import TextUnderlineMarkSpec from './TextUnderlineMarkSpec.js';
+import OverrideMarkSpec from './OverrideMarkSpec.js';
 
 const {
   MARK_CODE,
@@ -37,6 +38,7 @@ const {
   MARK_TEXT_SELECTION,
   MARK_UNDERLINE,
   MARK_SPACER,
+  MARK_OVERRIDE
 } = MarkNames;
 
 // These nodes are required to build basic marks.
@@ -64,6 +66,7 @@ const marks = {
   [MARK_TEXT_HIGHLIGHT]: TextHighlightMarkSpec,
   [MARK_TEXT_SELECTION]: TextSelectionMarkSpec,
   [MARK_UNDERLINE]: TextUnderlineMarkSpec,
+  [MARK_OVERRIDE]: OverrideMarkSpec,
 };
 
 const schema = new Schema({ nodes, marks });

package/FontSizeMarkSpec.js

@@ -4,35 +4,50 @@ var FontSizeMarkSpec = {
   attrs: {
     pt: {
       "default": null
+    },
+    overridden: {
+      "default": false
     }
   },
   inline: true,
   group: 'inline',
   parseDOM: [{
-    style: 'font-size',
-    getAttrs: getAttrs
+    tag: 'span[style*=font-size]',
+    getAttrs: function getAttrs(domNode) {
+      var _domNode$parentNode, _domNode$parentNode2;
+      var fontSize = domNode.style.fontSize || '';
+      var _mOverriden = domNode.getAttribute('overridden');
+      var ptValue = 0;
+      var _mptValue = 0;
+      var parentFontsize = ((_domNode$parentNode = domNode.parentNode) === null || _domNode$parentNode === void 0 ? void 0 : _domNode$parentNode.style.fontSize) || '';
+      var mparent_overriden = (_domNode$parentNode2 = domNode.parentNode) === null || _domNode$parentNode2 === void 0 ? void 0 : _domNode$parentNode2.getAttribute('overridden');
+      if (fontSize !== '') {
+        ptValue = toClosestFontPtSize(fontSize);
+      }
+      if (parentFontsize !== '') {
+        _mptValue = toClosestFontPtSize(parentFontsize);
+      }
+      var overridden = _mOverriden === 'true' && fontSize !== '' || parentFontsize !== '' && mparent_overriden === 'true'; // Check if the font is overridden
+
+      return {
+        pt: ptValue || _mptValue,
+        overridden: overridden
+      };
+    }
   }],
   toDOM: function toDOM(node) {
-    var pt = node.attrs.pt;
-    var domAttrs = pt ? {
-      style: "font-size: ".concat(pt, "pt;"),
-      "class": 'czi-font-size-mark'
-    } : null;
-    return ['span', domAttrs, 0];
+    var _node$attrs = node.attrs,
+      pt = _node$attrs.pt,
+      overridden = _node$attrs.overridden;
+    var attrs = {
+      overridden: overridden
+    };
+    if (pt) {
+      attrs.style = "font-size: ".concat(pt, "pt;");
+      attrs["class"] = 'czi-font-size-mark';
+    }
+    return ['span', attrs, 0];
   }
 };
-function getAttrs(fontSize) {
-  var attrs = {};
-  if (!fontSize) {
-    return attrs;
-  }
-  var ptValue = toClosestFontPtSize(fontSize);
-  if (!ptValue) {
-    return attrs;
-  }
-  return {
-    pt: ptValue
-  };
-}
 export default FontSizeMarkSpec;
 import { bpfrpt_proptype_MarkSpec } from "./Types.js";

package/FontSizeMarkSpec.js.flow

@@ -1,49 +1,54 @@
 // @flow
 
 import { Node } from 'prosemirror-model';
-
 import { toClosestFontPtSize } from './toClosestFontPtSize.js';
-
 import type { MarkSpec } from './Types.js';
 
 const FontSizeMarkSpec: MarkSpec = {
   attrs: {
     pt: { default: null },
+    overridden: { default: false },
   },
   inline: true,
   group: 'inline',
   parseDOM: [
     {
-      style: 'font-size',
-      getAttrs: getAttrs,
+      tag: 'span[style*=font-size]',
+      getAttrs: (domNode) => {
+        const fontSize = domNode.style.fontSize || '';
+        const _mOverriden = domNode.getAttribute('overridden');
+        let ptValue = 0;
+        let _mptValue = 0;
+
+        const parentFontsize = domNode.parentNode?.style.fontSize || '';
+        const mparent_overriden = domNode.parentNode?.getAttribute('overridden');
+        if (fontSize !== '') {
+          ptValue = toClosestFontPtSize(fontSize);
+        }
+        if (parentFontsize !== '') {
+          _mptValue = toClosestFontPtSize(parentFontsize);
+        }
+
+        const overridden = (_mOverriden === 'true' && fontSize !== '') || (parentFontsize !== '' && mparent_overriden === 'true');  // Check if the font is overridden
+
+        return {
+          pt: ptValue || _mptValue,
+          overridden: overridden,
+        };
+      },
     },
   ],
   toDOM(node: Node) {
-    const { pt } = node.attrs;
-    const domAttrs = pt
-      ? {
-          style: `font-size: ${pt}pt;`,
-          class: 'czi-font-size-mark',
-        }
-      : null;
+    const { pt, overridden } = node.attrs;
+    const attrs = { overridden };
 
-    return ['span', domAttrs, 0];
+    if (pt) {
+      attrs.style = `font-size: ${pt}pt;`;
+      attrs.class = 'czi-font-size-mark';
+    }
+
+    return ['span', attrs, 0];
   },
 };
 
-function getAttrs(fontSize: string): Object {
-  const attrs = {};
-  if (!fontSize) {
-    return attrs;
-  }
-
-  const ptValue = toClosestFontPtSize(fontSize);
-  if (!ptValue) {
-    return attrs;
-  }
-  return {
-    pt: ptValue,
-  };
-}
-
 export default FontSizeMarkSpec;

package/FontTypeMarkSpec.js

@@ -1,29 +1,23 @@
 import { Node } from 'prosemirror-model';
 // [FS] IRAD-1061 2020-09-19
-// Now loaded locally, so that it work in closed network as well.
+// Now loaded locally, so that it works in closed networks as well.
 
 export var FONT_TYPE_NAMES = [
 // SERIF
-'Aclonica', 'Acme', 'Alegreya', 'Arial',
-//'Arial',//??? - Commented out fonts that are not available to download using https://fonts.googleapis.com/css?family=
-'Arial Black', 'Georgia', 'Tahoma', 'Times New Roman', 'Times', 'Verdana',
+'Aclonica', 'Acme', 'Alegreya', 'Arial', 'Arial Black', 'Georgia', 'Tahoma', 'Times New Roman', 'Times', 'Verdana',
 // MONOSPACE
-'Courier New'
-//'Lucida Console',//???
-//'Monaco',//???
-//'monospace',//???
-];
+'Courier New'];
 
 // FS IRAD-988 2020-06-18
 // Preload fonts that are listed by default,
-// so that even if the font is not available locally, load from web.
+// so that even if the font is not available locally, load from the web.
 export function preLoadFonts() {
   FONT_TYPE_NAMES.forEach(function (name) {
     loadAndCacheFont(name);
   });
 }
 
-// resolve each font after it is loaded.
+// Resolve each font after it is loaded.
 var RESOLVED_FONT_NAMES = new Set([]);
 function loadAndCacheFont(name) {
   // Cache custom fonts
@@ -31,21 +25,43 @@ function loadAndCacheFont(name) {
 }
 var FontTypeMarkSpec = {
   attrs: {
-    name: ''
+    name: '',
+    overridden: {
+      "default": false
+    }
   },
   inline: true,
   group: 'inline',
   parseDOM: [{
-    style: 'font-family',
-    getAttrs: function getAttrs(name) {
+    tag: 'span[style*=font-family]',
+    getAttrs: function getAttrs(domNode) {
+      var _domNode$parentNode, _domNode$parentNode2;
+      var name = domNode.style.fontFamily || '';
+      var parentFontName = ((_domNode$parentNode = domNode.parentNode) === null || _domNode$parentNode === void 0 ? void 0 : _domNode$parentNode.style.fontFamily) || '';
+      var _mOverriden = domNode.getAttribute('overridden');
+      var mparent_overriden = (_domNode$parentNode2 = domNode.parentNode) === null || _domNode$parentNode2 === void 0 ? void 0 : _domNode$parentNode2.getAttribute('overridden');
+      if (name !== '') {
+        name = name ? name.replace(/["']/g, '') : '';
+      }
+      if (parentFontName !== '') {
+        parentFontName = parentFontName ? parentFontName.replace(/["']/g, '') : '';
+      }
+      var overridden = _mOverriden === 'true' && name !== '' || parentFontName !== '' && mparent_overriden === 'true'; // Check if the font is overridden
+
       return {
-        name: name ? name.replace(/["']/g, '') : ''
+        name: name || parentFontName || 'Arial',
+        // Clean up the font name
+        overridden: overridden
       };
     }
   }],
   toDOM: function toDOM(node) {
-    var name = node.attrs.name;
-    var attrs = {};
+    var _node$attrs = node.attrs,
+      name = _node$attrs.name,
+      overridden = _node$attrs.overridden;
+    var attrs = {
+      overridden: overridden
+    };
     if (name) {
       if (!RESOLVED_FONT_NAMES.has(name)) {
         loadAndCacheFont(name);

package/FontTypeMarkSpec.js.flow

@@ -4,7 +4,7 @@ import { Node } from 'prosemirror-model';
 import type { MarkSpec } from './Types.js';
 
 // [FS] IRAD-1061 2020-09-19
-// Now loaded locally, so that it work in closed network as well.
+// Now loaded locally, so that it works in closed networks as well.
 
 export const FONT_TYPE_NAMES = [
   // SERIF
@@ -12,7 +12,6 @@ export const FONT_TYPE_NAMES = [
   'Acme',
   'Alegreya',
   'Arial',
-  //'Arial',//??? - Commented out fonts that are not available to download using https://fonts.googleapis.com/css?family=
   'Arial Black',
   'Georgia',
   'Tahoma',
@@ -21,21 +20,18 @@ export const FONT_TYPE_NAMES = [
   'Verdana',
   // MONOSPACE
   'Courier New',
-  //'Lucida Console',//???
-  //'Monaco',//???
-  //'monospace',//???
 ];
 
 // FS IRAD-988 2020-06-18
 // Preload fonts that are listed by default,
-// so that even if the font is not available locally, load from web.
+// so that even if the font is not available locally, load from the web.
 export function preLoadFonts() {
   FONT_TYPE_NAMES.forEach((name) => {
     loadAndCacheFont(name);
   });
 }
 
-// resolve each font after it is loaded.
+// Resolve each font after it is loaded.
 const RESOLVED_FONT_NAMES = new Set([]);
 
 function loadAndCacheFont(name) {
@@ -46,23 +42,40 @@ function loadAndCacheFont(name) {
 const FontTypeMarkSpec: MarkSpec = {
   attrs: {
     name: '',
+    overridden: { default: false },
   },
   inline: true,
   group: 'inline',
   parseDOM: [
     {
-      style: 'font-family',
-      getAttrs: (name) => {
+      tag: 'span[style*=font-family]',
+      getAttrs: (domNode) => {
+
+        let name = domNode.style.fontFamily || '';
+        let parentFontName = domNode.parentNode?.style.fontFamily || '';
+        const _mOverriden = domNode.getAttribute('overridden');
+        const mparent_overriden = domNode.parentNode?.getAttribute('overridden');
+
+        if (name !== '') {
+          name = name ? name.replace(/["']/g, '') : '';
+        }
+        if (parentFontName !== '') {
+          parentFontName = parentFontName ? parentFontName.replace(/["']/g, '') : '';
+        }
+
+        const overridden = (_mOverriden === 'true' && name !== '') || (parentFontName !== '' && mparent_overriden === 'true');  // Check if the font is overridden
+
         return {
-          name: name ? name.replace(/["']/g, '') : '',
+          name: name || parentFontName || 'Arial',  // Clean up the font name
+          overridden: overridden,
         };
-      },
-    },
+      }
+    }
   ],
 
   toDOM(node: Node) {
-    const { name } = node.attrs;
-    const attrs = {};
+    const { name, overridden } = node.attrs;
+    const attrs = { overridden };
     if (name) {
       if (!RESOLVED_FONT_NAMES.has(name)) {
         loadAndCacheFont(name);
@@ -70,7 +83,7 @@ const FontTypeMarkSpec: MarkSpec = {
       attrs.style = `font-family: ${name}`;
     }
     return ['span', attrs, 0];
-  },
+  }
 };
 
 export default FontTypeMarkSpec;

package/MarkNames.js

@@ -13,4 +13,5 @@ export var MARK_TEXT_COLOR = 'mark-text-color';
 export var MARK_TEXT_HIGHLIGHT = 'mark-text-highlight';
 export var MARK_TEXT_SELECTION = 'mark-text-selection';
 export var MARK_UNDERLINE = 'underline';
-export var MARK_SPACER = 'spacer';
+export var MARK_SPACER = 'spacer';
+export var MARK_OVERRIDE = 'override';

package/MarkNames.js.flow

@@ -16,3 +16,4 @@ export const MARK_TEXT_HIGHLIGHT = 'mark-text-highlight';
 export const MARK_TEXT_SELECTION = 'mark-text-selection';
 export const MARK_UNDERLINE = 'underline';
 export const MARK_SPACER = 'spacer';
+export const MARK_OVERRIDE = 'override';

package/OverrideMarkSpec.js

@@ -0,0 +1,54 @@
+var OverrideMarkSpec = {
+  attrs: {
+    strong: {
+      "default": false
+    },
+    em: {
+      "default": false
+    },
+    underline: {
+      "default": false
+    },
+    strike: {
+      "default": false
+    }
+  },
+  inline: true,
+  group: 'inline',
+  parseDOM: [{
+    tag: 'span',
+    getAttrs: function getAttrs(dom) {
+      var strong = dom.getAttribute('cs-strong') === 'true';
+      var em = dom.getAttribute('cs-em') === 'true';
+      var underline = dom.getAttribute('cs-underline') === 'true';
+      var strike = dom.getAttribute('cs-strike') === 'true';
+
+      // Only create the mark if at least one attribute is true
+      if (strong || em || underline || strike) {
+        return {
+          strong: strong,
+          em: em,
+          underline: underline,
+          strike: strike
+        };
+      }
+      return false; // Ignore spans where all attributes are false
+    }
+  }],
+  toDOM: function toDOM(mark) {
+    // Only render the <span> if at least one attribute is true
+    if (mark.attrs.strong || mark.attrs.em || mark.attrs.underline || mark.attrs.strike) {
+      return ['span', {
+        'cs-strong': mark.attrs.strong,
+        'cs-em': mark.attrs.em,
+        'cs-underline': mark.attrs.underline,
+        'cs-strike': mark.attrs.strike
+      }, 0];
+    }
+
+    // If no attributes are true, return nothing (ProseMirror will ignore this)
+    return null;
+  }
+};
+export default OverrideMarkSpec;
+import { bpfrpt_proptype_MarkSpec } from "./Types.js";

package/OverrideMarkSpec.js.flow

@@ -0,0 +1,49 @@
+import type { MarkSpec } from './Types.js';
+const OverrideMarkSpec: MarkSpec = {
+    attrs: {
+        strong: { default: false },
+        em: { default: false },
+        underline: { default: false },
+        strike: { default: false },
+    },
+    inline: true,
+    group: 'inline',
+    parseDOM: [
+        {
+            tag: 'span',
+            getAttrs: (dom) => {
+                const strong = dom.getAttribute('cs-strong') === 'true';
+                const em = dom.getAttribute('cs-em') === 'true';
+                const underline = dom.getAttribute('cs-underline') === 'true';
+                const strike = dom.getAttribute('cs-strike') === 'true';
+
+                // Only create the mark if at least one attribute is true
+                if (strong || em || underline || strike) {
+                    return { strong, em, underline, strike };
+                }
+
+                return false; // Ignore spans where all attributes are false
+            },
+        },
+    ],
+    toDOM: (mark) => {
+        // Only render the <span> if at least one attribute is true
+        if (mark.attrs.strong || mark.attrs.em || mark.attrs.underline || mark.attrs.strike) {
+            return [
+                'span',
+                {
+                    'cs-strong': mark.attrs.strong,
+                    'cs-em': mark.attrs.em,
+                    'cs-underline': mark.attrs.underline,
+                    'cs-strike': mark.attrs.strike,
+                },
+                0,
+            ];
+        }
+
+        // If no attributes are true, return nothing (ProseMirror will ignore this)
+        return null;
+    },
+};
+
+export default OverrideMarkSpec;

package/ParagraphNodeSpec.js

@@ -1,3 +1,9 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 import convertToCSSPTValue from './convertToCSSPTValue.js';
 import toCSSLineSpacing from './ui/toCSSLineSpacing.js';
 import { Node } from 'prosemirror-model';
@@ -67,6 +73,7 @@ var ParagraphNodeSpec = {
   },
   content: 'inline*',
   group: 'block',
+  defining: true,
   parseDOM: [{
     tag: 'p',
     getAttrs: getAttrs
@@ -80,7 +87,7 @@ function getAttrs(dom) {
     marginLeft = _dom$style.marginLeft,
     paddingTop = _dom$style.paddingTop,
     paddingBottom = _dom$style.paddingBottom;
-  var align = dom.getAttribute('align') || textAlign || '';
+  var align = dom.getAttribute('align') || textAlign || 'left';
   align = ALIGN_PATTERN.test(align) ? align : null;
   var indent = parseInt(dom.getAttribute(ATTRIBUTE_INDENT), 10);
   if (!indent && marginLeft) {
@@ -96,6 +103,7 @@ function getAttrs(dom) {
   var overriddenIndent = dom.getAttribute('overriddenIndent') || '';
   var overriddenIndentValue = dom.getAttribute('overriddenIndentValue') || '';
   var innerLink = dom.getAttribute('innerLink') || '';
+  var objectId = dom.getAttribute('objectId') || '';
   return {
     align: align,
     indent: indent,
@@ -109,7 +117,8 @@ function getAttrs(dom) {
     overriddenLineSpacingValue: overriddenLineSpacingValue,
     overriddenIndent: overriddenIndent,
     overriddenIndentValue: overriddenIndentValue,
-    innerLink: innerLink
+    innerLink: innerLink,
+    objectId: objectId
   };
 }
 function getStyle(attrs) {
@@ -147,7 +156,7 @@ function toDOM(node) {
     overriddenIndent = _node$attrs.overriddenIndent,
     overriddenIndentValue = _node$attrs.overriddenIndentValue,
     innerLink = _node$attrs.innerLink;
-  var attrs = {};
+  var attrs = _objectSpread({}, node.attrs);
   var _getStyle = getStyle(node.attrs),
     style = _getStyle.style;
   style && (attrs.style = style);