n8n-editor-ui 1.62.2 → 1.63.1

package/dist/assets/@lezer/{common-CnY9etib.js → common-Bs5t-XhT.js}

@@ -1139,18 +1139,17 @@ class TreeCursor {
       return this._tree;
     let cache = this.bufferNode, result = null, depth = 0;
     if (cache && cache.context == this.buffer) {
-      scan:
-        for (let index = this.index, d = this.stack.length; d >= 0; ) {
-          for (let c = cache; c; c = c._parent)
-            if (c.index == index) {
-              if (index == this.index)
-                return c;
-              result = c;
-              depth = d + 1;
-              break scan;
-            }
-          index = this.stack[--d];
-        }
+      scan: for (let index = this.index, d = this.stack.length; d >= 0; ) {
+        for (let c = cache; c; c = c._parent)
+          if (c.index == index) {
+            if (index == this.index)
+              return c;
+            result = c;
+            depth = d + 1;
+            break scan;
+          }
+        index = this.stack[--d];
+      }
     }
     for (let i = depth; i < this.stack.length; i++)
       result = new BufferNode(this.buffer, result, this.stack[i]);
@@ -1323,39 +1322,38 @@ function buildTree(data) {
     let fork = cursor.fork();
     let size = 0, start = 0, skip = 0, minStart = fork.end - maxBufferLength;
     let result = { size: 0, start: 0, skip: 0 };
-    scan:
-      for (let minPos = fork.pos - maxSize; fork.pos > minPos; ) {
-        let nodeSize2 = fork.size;
-        if (fork.id == inRepeat && nodeSize2 >= 0) {
-          result.size = size;
-          result.start = start;
-          result.skip = skip;
-          skip += 4;
-          size += 4;
-          fork.next();
-          continue;
-        }
-        let startPos = fork.pos - nodeSize2;
-        if (nodeSize2 < 0 || startPos < minPos || fork.start < minStart)
-          break;
-        let localSkipped = fork.id >= minRepeatType ? 4 : 0;
-        let nodeStart = fork.start;
+    scan: for (let minPos = fork.pos - maxSize; fork.pos > minPos; ) {
+      let nodeSize2 = fork.size;
+      if (fork.id == inRepeat && nodeSize2 >= 0) {
+        result.size = size;
+        result.start = start;
+        result.skip = skip;
+        skip += 4;
+        size += 4;
         fork.next();
-        while (fork.pos > startPos) {
-          if (fork.size < 0) {
-            if (fork.size == -3)
-              localSkipped += 4;
-            else
-              break scan;
-          } else if (fork.id >= minRepeatType) {
+        continue;
+      }
+      let startPos = fork.pos - nodeSize2;
+      if (nodeSize2 < 0 || startPos < minPos || fork.start < minStart)
+        break;
+      let localSkipped = fork.id >= minRepeatType ? 4 : 0;
+      let nodeStart = fork.start;
+      fork.next();
+      while (fork.pos > startPos) {
+        if (fork.size < 0) {
+          if (fork.size == -3)
             localSkipped += 4;
-          }
-          fork.next();
+          else
+            break scan;
+        } else if (fork.id >= minRepeatType) {
+          localSkipped += 4;
         }
-        start = nodeStart;
-        size += nodeSize2;
-        skip += localSkipped;
+        fork.next();
       }
+      start = nodeStart;
+      size += nodeSize2;
+      skip += localSkipped;
+    }
     if (inRepeat < 0 || size == maxSize) {
       result.size = size;
       result.start = start;
@@ -1705,65 +1703,64 @@ class MixedParse {
     let overlay = null;
     let covered = null;
     let cursor = new TreeCursor(new TreeNode(this.baseTree, this.ranges[0].from, 0, null), IterMode.IncludeAnonymous | IterMode.IgnoreMounts);
-    scan:
-      for (let nest, isCovered; this.stoppedAt == null || cursor.from < this.stoppedAt; ) {
-        let enter = true, range;
-        if (fragmentCursor.hasNode(cursor)) {
-          if (overlay) {
-            let match = overlay.mounts.find((m) => m.frag.from <= cursor.from && m.frag.to >= cursor.to && m.mount.overlay);
-            if (match)
-              for (let r of match.mount.overlay) {
-                let from = r.from + match.pos, to = r.to + match.pos;
-                if (from >= cursor.from && to <= cursor.to && !overlay.ranges.some((r2) => r2.from < to && r2.to > from))
-                  overlay.ranges.push({ from, to });
-              }
-          }
-          enter = false;
-        } else if (covered && (isCovered = checkCover(covered.ranges, cursor.from, cursor.to))) {
-          enter = isCovered != 2;
-        } else if (!cursor.type.isAnonymous && cursor.from < cursor.to && (nest = this.nest(cursor, this.input))) {
-          if (!cursor.tree)
-            materialize(cursor);
-          let oldMounts = fragmentCursor.findMounts(cursor.from, nest.parser);
-          if (typeof nest.overlay == "function") {
-            overlay = new ActiveOverlay(nest.parser, nest.overlay, oldMounts, this.inner.length, cursor.from, cursor.tree, overlay);
-          } else {
-            let ranges = punchRanges(this.ranges, nest.overlay || [new Range(cursor.from, cursor.to)]);
-            if (ranges.length)
-              this.inner.push(new InnerParse(nest.parser, nest.parser.startParse(this.input, enterFragments(oldMounts, ranges), ranges), nest.overlay ? nest.overlay.map((r) => new Range(r.from - cursor.from, r.to - cursor.from)) : null, cursor.tree, ranges));
-            if (!nest.overlay)
-              enter = false;
-            else if (ranges.length)
-              covered = { ranges, depth: 0, prev: covered };
-          }
-        } else if (overlay && (range = overlay.predicate(cursor))) {
-          if (range === true)
-            range = new Range(cursor.from, cursor.to);
-          if (range.from < range.to)
-            overlay.ranges.push(range);
+    scan: for (let nest, isCovered; this.stoppedAt == null || cursor.from < this.stoppedAt; ) {
+      let enter = true, range;
+      if (fragmentCursor.hasNode(cursor)) {
+        if (overlay) {
+          let match = overlay.mounts.find((m) => m.frag.from <= cursor.from && m.frag.to >= cursor.to && m.mount.overlay);
+          if (match)
+            for (let r of match.mount.overlay) {
+              let from = r.from + match.pos, to = r.to + match.pos;
+              if (from >= cursor.from && to <= cursor.to && !overlay.ranges.some((r2) => r2.from < to && r2.to > from))
+                overlay.ranges.push({ from, to });
+            }
         }
-        if (enter && cursor.firstChild()) {
-          if (overlay)
-            overlay.depth++;
-          if (covered)
-            covered.depth++;
+        enter = false;
+      } else if (covered && (isCovered = checkCover(covered.ranges, cursor.from, cursor.to))) {
+        enter = isCovered != 2;
+      } else if (!cursor.type.isAnonymous && cursor.from < cursor.to && (nest = this.nest(cursor, this.input))) {
+        if (!cursor.tree)
+          materialize(cursor);
+        let oldMounts = fragmentCursor.findMounts(cursor.from, nest.parser);
+        if (typeof nest.overlay == "function") {
+          overlay = new ActiveOverlay(nest.parser, nest.overlay, oldMounts, this.inner.length, cursor.from, cursor.tree, overlay);
         } else {
-          for (; ; ) {
-            if (cursor.nextSibling())
-              break;
-            if (!cursor.parent())
-              break scan;
-            if (overlay && !--overlay.depth) {
-              let ranges = punchRanges(this.ranges, overlay.ranges);
-              if (ranges.length)
-                this.inner.splice(overlay.index, 0, new InnerParse(overlay.parser, overlay.parser.startParse(this.input, enterFragments(overlay.mounts, ranges), ranges), overlay.ranges.map((r) => new Range(r.from - overlay.start, r.to - overlay.start)), overlay.target, ranges));
-              overlay = overlay.prev;
-            }
-            if (covered && !--covered.depth)
-              covered = covered.prev;
+          let ranges = punchRanges(this.ranges, nest.overlay || [new Range(cursor.from, cursor.to)]);
+          if (ranges.length)
+            this.inner.push(new InnerParse(nest.parser, nest.parser.startParse(this.input, enterFragments(oldMounts, ranges), ranges), nest.overlay ? nest.overlay.map((r) => new Range(r.from - cursor.from, r.to - cursor.from)) : null, cursor.tree, ranges));
+          if (!nest.overlay)
+            enter = false;
+          else if (ranges.length)
+            covered = { ranges, depth: 0, prev: covered };
+        }
+      } else if (overlay && (range = overlay.predicate(cursor))) {
+        if (range === true)
+          range = new Range(cursor.from, cursor.to);
+        if (range.from < range.to)
+          overlay.ranges.push(range);
+      }
+      if (enter && cursor.firstChild()) {
+        if (overlay)
+          overlay.depth++;
+        if (covered)
+          covered.depth++;
+      } else {
+        for (; ; ) {
+          if (cursor.nextSibling())
+            break;
+          if (!cursor.parent())
+            break scan;
+          if (overlay && !--overlay.depth) {
+            let ranges = punchRanges(this.ranges, overlay.ranges);
+            if (ranges.length)
+              this.inner.splice(overlay.index, 0, new InnerParse(overlay.parser, overlay.parser.startParse(this.input, enterFragments(overlay.mounts, ranges), ranges), overlay.ranges.map((r) => new Range(r.from - overlay.start, r.to - overlay.start)), overlay.target, ranges));
+            overlay = overlay.prev;
           }
+          if (covered && !--covered.depth)
+            covered = covered.prev;
         }
       }
+    }
   }
 }
 function checkCover(covered, from, to) {
@@ -1822,8 +1819,7 @@ class StructureCursor {
   moveTo(pos) {
     let { cursor } = this, p = pos - this.offset;
     while (!this.done && cursor.from < p) {
-      if (cursor.to >= pos && cursor.enter(p, 1, IterMode.IgnoreOverlays | IterMode.ExcludeBuffers))
-        ;
+      if (cursor.to >= pos && cursor.enter(p, 1, IterMode.IgnoreOverlays | IterMode.ExcludeBuffers)) ;
       else if (!cursor.next(false))
         this.done = true;
     }

package/dist/assets/@n8n/api-types-Clq_Leox.js

@@ -0,0 +1 @@
+import "../n8n-o-6nV4eX.js";