@oliasoft-open-source/react-ui-library 4.9.1 → 4.9.2

package/dist/index.js

@@ -25685,7 +25685,7 @@ class DOMParser {
   */
   parse(dom, options = {}) {
     let context2 = new ParseContext(this, options, false);
-    context2.addAll(dom, options.from, options.to);
+    context2.addAll(dom, Mark$1.none, options.from, options.to);
     return context2.finish();
   }
   /**
@@ -25698,7 +25698,7 @@ class DOMParser {
   */
   parseSlice(dom, options = {}) {
     let context2 = new ParseContext(this, options, true);
-    context2.addAll(dom, options.from, options.to);
+    context2.addAll(dom, Mark$1.none, options.from, options.to);
     return Slice.maxOpen(context2.finish());
   }
   /**
@@ -25831,16 +25831,14 @@ function wsOptionsFor(type, preserveWhitespace, base2) {
   return type && type.whitespace == "pre" ? OPT_PRESERVE_WS | OPT_PRESERVE_WS_FULL : base2 & ~OPT_OPEN_LEFT;
 }
 class NodeContext {
-  constructor(type, attrs, marks, pendingMarks, solid, match2, options) {
+  constructor(type, attrs, marks, solid, match2, options) {
     this.type = type;
     this.attrs = attrs;
     this.marks = marks;
-    this.pendingMarks = pendingMarks;
     this.solid = solid;
     this.options = options;
     this.content = [];
     this.activeMarks = Mark$1.none;
-    this.stashMarks = [];
     this.match = match2 || (options & OPT_OPEN_LEFT ? null : type.contentMatch);
   }
   findWrapping(node2) {
@@ -25878,20 +25876,6 @@ class NodeContext {
       content2 = content2.append(this.match.fillBefore(Fragment.empty, true));
     return this.type ? this.type.create(this.attrs, content2, this.marks) : content2;
   }
-  popFromStashMark(mark) {
-    for (let i = this.stashMarks.length - 1; i >= 0; i--)
-      if (mark.eq(this.stashMarks[i]))
-        return this.stashMarks.splice(i, 1)[0];
-  }
-  applyPending(nextType) {
-    for (let i = 0, pending = this.pendingMarks; i < pending.length; i++) {
-      let mark = pending[i];
-      if ((this.type ? this.type.allowsMarkType(mark.type) : markMayApply(mark.type, nextType)) && !mark.isInSet(this.activeMarks)) {
-        this.activeMarks = mark.addToSet(this.activeMarks);
-        this.pendingMarks = mark.removeFromSet(this.pendingMarks);
-      }
-    }
-  }
   inlineContext(node2) {
     if (this.type)
       return this.type.inlineContent;
@@ -25909,11 +25893,11 @@ class ParseContext {
     let topNode = options.topNode, topContext;
     let topOptions = wsOptionsFor(null, options.preserveWhitespace, 0) | (isOpen2 ? OPT_OPEN_LEFT : 0);
     if (topNode)
-      topContext = new NodeContext(topNode.type, topNode.attrs, Mark$1.none, Mark$1.none, true, options.topMatch || topNode.type.contentMatch, topOptions);
+      topContext = new NodeContext(topNode.type, topNode.attrs, Mark$1.none, true, options.topMatch || topNode.type.contentMatch, topOptions);
     else if (isOpen2)
-      topContext = new NodeContext(null, null, Mark$1.none, Mark$1.none, true, null, topOptions);
+      topContext = new NodeContext(null, null, Mark$1.none, true, null, topOptions);
     else
-      topContext = new NodeContext(parser2.schema.topNodeType, null, Mark$1.none, Mark$1.none, true, null, topOptions);
+      topContext = new NodeContext(parser2.schema.topNodeType, null, Mark$1.none, true, null, topOptions);
     this.nodes = [topContext];
     this.find = options.findPositions;
     this.needsBlock = false;
@@ -25924,31 +25908,13 @@ class ParseContext {
   // Add a DOM node to the content. Text is inserted as text node,
   // otherwise, the node is passed to `addElement` or, if it has a
   // `style` attribute, `addElementWithStyles`.
-  addDOM(dom) {
+  addDOM(dom, marks) {
     if (dom.nodeType == 3)
-      this.addTextNode(dom);
+      this.addTextNode(dom, marks);
     else if (dom.nodeType == 1)
-      this.addElement(dom);
-  }
-  withStyleRules(dom, f2) {
-    let style2 = dom.style;
-    if (!style2 || !style2.length)
-      return f2();
-    let marks = this.readStyles(dom.style);
-    if (!marks)
-      return;
-    let [addMarks, removeMarks] = marks, top2 = this.top;
-    for (let i = 0; i < removeMarks.length; i++)
-      this.removePendingMark(removeMarks[i], top2);
-    for (let i = 0; i < addMarks.length; i++)
-      this.addPendingMark(addMarks[i]);
-    f2();
-    for (let i = 0; i < addMarks.length; i++)
-      this.removePendingMark(addMarks[i], top2);
-    for (let i = 0; i < removeMarks.length; i++)
-      this.addPendingMark(removeMarks[i]);
-  }
-  addTextNode(dom) {
+      this.addElement(dom, marks);
+  }
+  addTextNode(dom, marks) {
     let value = dom.nodeValue;
     let top2 = this.top;
     if (top2.options & OPT_PRESERVE_WS_FULL || top2.inlineContext(dom) || /[^ \t\r\n\u000c]/.test(value)) {
@@ -25966,7 +25932,7 @@ class ParseContext {
         value = value.replace(/\r\n?/g, "\n");
       }
       if (value)
-        this.insertNode(this.parser.schema.text(value));
+        this.insertNode(this.parser.schema.text(value), marks);
       this.findInText(dom);
     } else {
       this.findInside(dom);
@@ -25974,14 +25940,14 @@ class ParseContext {
   }
   // Try to find a handler for the given tag and use that to parse. If
   // none is found, the element's content nodes are added directly.
-  addElement(dom, matchAfter) {
+  addElement(dom, marks, matchAfter) {
     let name2 = dom.nodeName.toLowerCase(), ruleID;
     if (listTags.hasOwnProperty(name2) && this.parser.normalizeLists)
       normalizeList(dom);
     let rule = this.options.ruleFromNode && this.options.ruleFromNode(dom) || (ruleID = this.parser.matchTag(dom, this, matchAfter));
     if (rule ? rule.ignore : ignoreTags.hasOwnProperty(name2)) {
       this.findInside(dom);
-      this.ignoreFallback(dom);
+      this.ignoreFallback(dom, marks);
     } else if (!rule || rule.skip || rule.closeParent) {
       if (rule && rule.closeParent)
         this.open = Math.max(0, this.open - 1);
@@ -25997,38 +25963,37 @@ class ParseContext {
         if (!top2.type)
           this.needsBlock = true;
       } else if (!dom.firstChild) {
-        this.leafFallback(dom);
+        this.leafFallback(dom, marks);
         return;
       }
-      if (rule && rule.skip)
-        this.addAll(dom);
-      else
-        this.withStyleRules(dom, () => this.addAll(dom));
+      let innerMarks = rule && rule.skip ? marks : this.readStyles(dom, marks);
+      if (innerMarks)
+        this.addAll(dom, innerMarks);
       if (sync2)
         this.sync(top2);
       this.needsBlock = oldNeedsBlock;
     } else {
-      this.withStyleRules(dom, () => {
-        this.addElementByRule(dom, rule, rule.consuming === false ? ruleID : void 0);
-      });
+      let innerMarks = this.readStyles(dom, marks);
+      if (innerMarks)
+        this.addElementByRule(dom, rule, innerMarks, rule.consuming === false ? ruleID : void 0);
     }
   }
   // Called for leaf DOM nodes that would otherwise be ignored
-  leafFallback(dom) {
+  leafFallback(dom, marks) {
     if (dom.nodeName == "BR" && this.top.type && this.top.type.inlineContent)
-      this.addTextNode(dom.ownerDocument.createTextNode("\n"));
+      this.addTextNode(dom.ownerDocument.createTextNode("\n"), marks);
   }
   // Called for ignored nodes
-  ignoreFallback(dom) {
+  ignoreFallback(dom, marks) {
     if (dom.nodeName == "BR" && (!this.top.type || !this.top.type.inlineContent))
-      this.findPlace(this.parser.schema.text("-"));
+      this.findPlace(this.parser.schema.text("-"), marks);
   }
   // Run any style parser associated with the node's styles. Either
-  // return an array of marks, or null to indicate some of the styles
-  // had a rule with `ignore` set.
-  readStyles(styles2) {
-    let add3 = Mark$1.none, remove2 = Mark$1.none;
-    if (styles2.length)
+  // return an updated array of marks, or null to indicate some of the
+  // styles had a rule with `ignore` set.
+  readStyles(dom, marks) {
+    let styles2 = dom.style;
+    if (styles2 && styles2.length)
       for (let i = 0; i < this.parser.matchedStyles.length; i++) {
         let name2 = this.parser.matchedStyles[i], value = styles2.getPropertyValue(name2);
         if (value)
@@ -26038,47 +26003,46 @@ class ParseContext {
               break;
             if (rule.ignore)
               return null;
-            if (rule.clearMark) {
-              this.top.pendingMarks.concat(this.top.activeMarks).forEach((m2) => {
-                if (rule.clearMark(m2))
-                  remove2 = m2.addToSet(remove2);
-              });
-            } else {
-              add3 = this.parser.schema.marks[rule.mark].create(rule.attrs).addToSet(add3);
-            }
+            if (rule.clearMark)
+              marks = marks.filter((m2) => !rule.clearMark(m2));
+            else
+              marks = marks.concat(this.parser.schema.marks[rule.mark].create(rule.attrs));
             if (rule.consuming === false)
               after = rule;
             else
               break;
           }
       }
-    return [add3, remove2];
+    return marks;
   }
   // Look up a handler for the given node. If none are found, return
   // false. Otherwise, apply it, use its return value to drive the way
   // the node's content is wrapped, and return true.
-  addElementByRule(dom, rule, continueAfter) {
-    let sync2, nodeType, mark;
+  addElementByRule(dom, rule, marks, continueAfter) {
+    let sync2, nodeType;
     if (rule.node) {
       nodeType = this.parser.schema.nodes[rule.node];
       if (!nodeType.isLeaf) {
-        sync2 = this.enter(nodeType, rule.attrs || null, rule.preserveWhitespace);
-      } else if (!this.insertNode(nodeType.create(rule.attrs))) {
-        this.leafFallback(dom);
+        let inner2 = this.enter(nodeType, rule.attrs || null, marks, rule.preserveWhitespace);
+        if (inner2) {
+          sync2 = true;
+          marks = inner2;
+        }
+      } else if (!this.insertNode(nodeType.create(rule.attrs), marks)) {
+        this.leafFallback(dom, marks);
       }
     } else {
       let markType = this.parser.schema.marks[rule.mark];
-      mark = markType.create(rule.attrs);
-      this.addPendingMark(mark);
+      marks = marks.concat(markType.create(rule.attrs));
     }
     let startIn = this.top;
     if (nodeType && nodeType.isLeaf) {
       this.findInside(dom);
     } else if (continueAfter) {
-      this.addElement(dom, continueAfter);
+      this.addElement(dom, marks, continueAfter);
     } else if (rule.getContent) {
       this.findInside(dom);
-      rule.getContent(dom, this.parser.schema).forEach((node2) => this.insertNode(node2));
+      rule.getContent(dom, this.parser.schema).forEach((node2) => this.insertNode(node2, marks));
     } else {
       let contentDOM = dom;
       if (typeof rule.contentElement == "string")
@@ -26088,28 +26052,26 @@ class ParseContext {
       else if (rule.contentElement)
         contentDOM = rule.contentElement;
       this.findAround(dom, contentDOM, true);
-      this.addAll(contentDOM);
+      this.addAll(contentDOM, marks);
     }
     if (sync2 && this.sync(startIn))
       this.open--;
-    if (mark)
-      this.removePendingMark(mark, startIn);
   }
   // Add all child nodes between `startIndex` and `endIndex` (or the
   // whole node, if not given). If `sync` is passed, use it to
   // synchronize after every block element.
-  addAll(parent, startIndex, endIndex) {
+  addAll(parent, marks, startIndex, endIndex) {
     let index2 = startIndex || 0;
     for (let dom = startIndex ? parent.childNodes[startIndex] : parent.firstChild, end2 = endIndex == null ? null : parent.childNodes[endIndex]; dom != end2; dom = dom.nextSibling, ++index2) {
       this.findAtPoint(parent, index2);
-      this.addDOM(dom);
+      this.addDOM(dom, marks);
     }
     this.findAtPoint(parent, index2);
   }
   // Try to find a way to fit the given node type into the current
   // context. May add intermediate wrappers and/or leave non-solid
   // nodes that we're in.
-  findPlace(node2) {
+  findPlace(node2, marks) {
     let route, sync2;
     for (let depth = this.open; depth >= 0; depth--) {
       let cx3 = this.nodes[depth];
@@ -26124,53 +26086,61 @@ class ParseContext {
         break;
     }
     if (!route)
-      return false;
+      return null;
     this.sync(sync2);
     for (let i = 0; i < route.length; i++)
-      this.enterInner(route[i], null, false);
-    return true;
+      marks = this.enterInner(route[i], null, marks, false);
+    return marks;
   }
   // Try to insert the given node, adjusting the context when needed.
-  insertNode(node2) {
+  insertNode(node2, marks) {
     if (node2.isInline && this.needsBlock && !this.top.type) {
       let block2 = this.textblockFromContext();
       if (block2)
-        this.enterInner(block2);
+        marks = this.enterInner(block2, null, marks);
     }
-    if (this.findPlace(node2)) {
+    let innerMarks = this.findPlace(node2, marks);
+    if (innerMarks) {
       this.closeExtra();
       let top2 = this.top;
-      top2.applyPending(node2.type);
       if (top2.match)
         top2.match = top2.match.matchType(node2.type);
-      let marks = top2.activeMarks;
-      for (let i = 0; i < node2.marks.length; i++)
-        if (!top2.type || top2.type.allowsMarkType(node2.marks[i].type))
-          marks = node2.marks[i].addToSet(marks);
-      top2.content.push(node2.mark(marks));
+      let nodeMarks = Mark$1.none;
+      for (let m2 of innerMarks.concat(node2.marks))
+        if (top2.type ? top2.type.allowsMarkType(m2.type) : markMayApply(m2.type, node2.type))
+          nodeMarks = m2.addToSet(nodeMarks);
+      top2.content.push(node2.mark(nodeMarks));
       return true;
     }
     return false;
   }
   // Try to start a node of the given type, adjusting the context when
   // necessary.
-  enter(type, attrs, preserveWS) {
-    let ok = this.findPlace(type.create(attrs));
-    if (ok)
-      this.enterInner(type, attrs, true, preserveWS);
-    return ok;
+  enter(type, attrs, marks, preserveWS) {
+    let innerMarks = this.findPlace(type.create(attrs), marks);
+    if (innerMarks)
+      innerMarks = this.enterInner(type, attrs, marks, true, preserveWS);
+    return innerMarks;
   }
   // Open a node of the given type
-  enterInner(type, attrs = null, solid = false, preserveWS) {
+  enterInner(type, attrs, marks, solid = false, preserveWS) {
     this.closeExtra();
     let top2 = this.top;
-    top2.applyPending(type);
     top2.match = top2.match && top2.match.matchType(type);
     let options = wsOptionsFor(type, preserveWS, top2.options);
     if (top2.options & OPT_OPEN_LEFT && top2.content.length == 0)
       options |= OPT_OPEN_LEFT;
-    this.nodes.push(new NodeContext(type, attrs, top2.activeMarks, top2.pendingMarks, solid, null, options));
+    let applyMarks = Mark$1.none;
+    marks = marks.filter((m2) => {
+      if (top2.type ? top2.type.allowsMarkType(m2.type) : markMayApply(m2.type, type)) {
+        applyMarks = m2.addToSet(applyMarks);
+        return false;
+      }
+      return true;
+    });
+    this.nodes.push(new NodeContext(type, attrs, applyMarks, solid, null, options));
     this.open++;
+    return marks;
   }
   // Make sure all nodes above this.open are finished and added to
   // their parents
@@ -26281,28 +26251,6 @@ class ParseContext {
         return type;
     }
   }
-  addPendingMark(mark) {
-    let found2 = findSameMarkInSet(mark, this.top.pendingMarks);
-    if (found2)
-      this.top.stashMarks.push(found2);
-    this.top.pendingMarks = mark.addToSet(this.top.pendingMarks);
-  }
-  removePendingMark(mark, upto) {
-    for (let depth = this.open; depth >= 0; depth--) {
-      let level = this.nodes[depth];
-      let found2 = level.pendingMarks.lastIndexOf(mark);
-      if (found2 > -1) {
-        level.pendingMarks = mark.removeFromSet(level.pendingMarks);
-      } else {
-        level.activeMarks = mark.removeFromSet(level.activeMarks);
-        let stashMark = level.popFromStashMark(mark);
-        if (stashMark && level.type && level.type.allowsMarkType(stashMark.type))
-          level.activeMarks = stashMark.addToSet(level.activeMarks);
-      }
-      if (level == upto)
-        break;
-    }
-  }
 }
 function normalizeList(dom) {
   for (let child = dom.firstChild, prevItem = null; child; child = child.nextSibling) {
@@ -26346,12 +26294,6 @@ function markMayApply(markType, nodeType) {
       return true;
   }
 }
-function findSameMarkInSet(mark, set2) {
-  for (let i = 0; i < set2.length; i++) {
-    if (mark.eq(set2[i]))
-      return set2[i];
-  }
-}
 class DOMSerializer {
   /**
   Create a serializer. `nodes` should map node names to functions
@@ -70217,16 +70159,12 @@ const convertUnit = (stringValue = "", toUnit, defaultFromUnit = "", doNotConver
     } catch (e2) {
     }
   }
-  return stringValue;
 };
 const isValueWithUnknownUnit = (value) => {
   if (!value) return false;
   return Boolean(getUnit(value));
 };
 const safeConvertValue = (value = "", toUnit, defaultFromUnit, doNotConvertValue) => {
-  if (doNotConvertValue) {
-    return value;
-  }
   const isWithUnit = isValueWithUnknownUnit(value) || isValueWithUnit(value);
   const rawValue = getValue$1(value);
   const isInvalidInput = isWrongValue(rawValue);
@@ -70330,6 +70268,7 @@ const UnitInput = ({
   );
   const initDisplayLayer = convertedValue !== "" ? { value: convertedValue, unit: initDisplayUnit } : convertedAutoValue !== "" ? { value: convertedAutoValue, unit: initDisplayUnit } : { value: propValue, unit: propUnit };
   const [displayLayer, setDisplayLayer] = useState(initDisplayLayer);
+  const derivedAllowEmpty = (displayLayer == null ? void 0 : displayLayer.value) === void 0;
   const [predefinedOptionsMenuState, setPredefinedOptionsMenuState] = useState(
     initialPredefinedOption ? PredefinedOptionsMenuState.PREDEFINED : PredefinedOptionsMenuState.CUSTOM
   );
@@ -70527,7 +70466,7 @@ const UnitInput = ({
             error: error2 === null ? void 0 : error2,
             warning: warning2 === null ? void 0 : warning2,
             left: left2,
-            allowEmpty,
+            allowEmpty: derivedAllowEmpty,
             validationCallback: (_name, error22) => validationCallback(stringName, error22),
             enableCosmeticRounding,
             enableDisplayRounding,