@feathery/react 2.14.0 → 2.15.1

package/dist/{fthry_index.CdIRvNp8.js → fthry_index.y4j9reIZ.js}

@@ -634,7 +634,7 @@ function identifier (index) {
  * @return {object[]}
  */
 function compile (value) {
-	return dealloc(parse$1('', null, null, null, [''], value = alloc(value), 0, [0], value))
+	return dealloc(parse$2('', null, null, null, [''], value = alloc(value), 0, [0], value))
 }
 
 /**
@@ -649,7 +649,7 @@ function compile (value) {
  * @param {string[]} declarations
  * @return {object}
  */
-function parse$1 (value, root, parent, rule, rules, rulesets, pseudo, points, declarations) {
+function parse$2 (value, root, parent, rule, rules, rulesets, pseudo, points, declarations) {
 	var index = 0;
 	var offset = 0;
 	var length = pseudo;
@@ -718,15 +718,15 @@ function parse$1 (value, root, parent, rule, rules, rulesets, pseudo, points, de
 
 						if (character === 123)
 							if (offset === 0)
-								parse$1(characters, root, reference, reference, props, rulesets, length, points, children);
+								parse$2(characters, root, reference, reference, props, rulesets, length, points, children);
 							else
 								switch (atrule === 99 && charat(characters, 3) === 110 ? 100 : atrule) {
 									// d l m s
 									case 100: case 108: case 109: case 115:
-										parse$1(value, reference, reference, rule && append(ruleset(value, reference, reference, 0, 0, rules, points, type, rules, props = [], length), children), rules, children, length, points, rule ? props : children);
+										parse$2(value, reference, reference, rule && append(ruleset(value, reference, reference, 0, 0, rules, points, type, rules, props = [], length), children), rules, children, length, points, rule ? props : children);
 										break
 									default:
-										parse$1(characters, reference, reference, reference, [''], children, 0, points, children);
+										parse$2(characters, reference, reference, reference, [''], children, 0, points, children);
 								}
 				}
 
@@ -16482,7 +16482,8 @@ var stepElementTypes = [
     'servar_fields',
     'progress_bars',
     'images',
-    'videos'
+    'videos',
+    'tables'
 ];
 var getPositionKey = function (node) {
     if (!node.position)
@@ -16540,7 +16541,9 @@ function getVisiblePositions(step, internalId) {
     var typeIndex = elementTypes.indexOf('subgrids');
     elementTypes.splice(typeIndex, 1);
     elementTypes.forEach(function (elementType) {
-        step[elementType].forEach(function (el) {
+        var _a;
+        // TODO (table): remove backwards compatibility
+        (_a = step[elementType]) === null || _a === void 0 ? void 0 : _a.forEach(function (el) {
             _collectHideFlags(step, el, visiblePositions, hiddenPositions, repeatKeys, internalId);
         });
     });
@@ -20121,7 +20124,7 @@ var Element$1 = function (_a) {
     var _b, _c, _d, _e, _f, _g;
     var el = _a.node, form = _a.form;
     var type = el.type;
-    var userProgress = form.userProgress, curDepth = form.curDepth, maxDepth = form.maxDepth, elementProps = form.elementProps, activeStep = form.activeStep, buttonLoaders = form.buttonLoaders, customClickSelectionState = form.customClickSelectionState, runElementActions = form.runElementActions, buttonOnClick = form.buttonOnClick, fieldOnChange = form.fieldOnChange, inlineErrors = form.inlineErrors, setInlineErrors = form.setInlineErrors, changeValue = form.changeValue, updateFieldValues = form.updateFieldValues, elementOnView = form.elementOnView, onViewElements = form.onViewElements, formSettings = form.formSettings, formRef = form.formRef, focusRef = form.focusRef, setCardElement = form.setCardElement, visiblePositions = form.visiblePositions, featheryContext = form.featheryContext;
+    var userProgress = form.userProgress, curDepth = form.curDepth, maxDepth = form.maxDepth, elementProps = form.elementProps, activeStep = form.activeStep, buttonLoaders = form.buttonLoaders, customClickSelectionState = form.customClickSelectionState, runElementActions = form.runElementActions, buttonOnClick = form.buttonOnClick, tableOnClick = form.tableOnClick, fieldOnChange = form.fieldOnChange, inlineErrors = form.inlineErrors, setInlineErrors = form.setInlineErrors, changeValue = form.changeValue, updateFieldValues = form.updateFieldValues, elementOnView = form.elementOnView, onViewElements = form.onViewElements, formSettings = form.formSettings, formRef = form.formRef, focusRef = form.focusRef, setCardElement = form.setCardElement, visiblePositions = form.visiblePositions, featheryContext = form.featheryContext;
     var readOnly = formSettings.readOnly || initState.collaboratorReview === 'readOnly';
     var basicProps = {
         componentOnly: false,
@@ -20140,6 +20143,8 @@ var Element$1 = function (_a) {
         return jsx$1(Elements.ImageElement, __assign({}, basicProps));
     else if (type === 'video')
         return jsx$1(Elements.VideoElement, __assign({}, basicProps));
+    else if (type === 'table')
+        return (jsx$1(Elements.TableElement, __assign({}, basicProps, { onClick: function (payload) { return tableOnClick(el, payload); } })));
     else if (type === 'text')
         return (jsx$1(Elements.TextElement, __assign({ textSpanOnClick: function (textSpanStart, textSpanEnd) {
                 var _a;
@@ -21965,7 +21970,9 @@ var buildStepGrid = function (step, viewport, visiblePositions) {
 };
 var convertStepToViewport = function (step, viewport) {
     stepElementTypes.forEach(function (type) {
-        step[type].forEach(function (obj, i) {
+        // TODO (table): remove backwards compatibility
+        var _a;
+        (_a = step[type]) === null || _a === void 0 ? void 0 : _a.forEach(function (obj, i) {
             step[type][i] =
                 type === 'subgrids'
                     ? convertToViewport(obj, viewport, viewportProperties.subgrids)
@@ -21998,7 +22005,8 @@ var typeMap = {
     texts: 'text',
     buttons: 'button',
     servar_fields: 'field',
-    videos: 'video'
+    videos: 'video',
+    tables: 'table'
 };
 var buildGridMap = function (step) {
     var map = {};
@@ -35602,10 +35610,1637 @@ Parser.acorn = {
 //
 // [estree]: https://github.com/estree/estree
 
-function parse(input, options) {
+function parse$1(input, options) {
   return Parser.parse(input, options)
 }
 
+var dummyValue = "✖";
+
+function isDummy(node) { return node.name === dummyValue }
+
+function noop() {}
+
+var LooseParser = function LooseParser(input, options) {
+  if ( options === void 0 ) options = {};
+
+  this.toks = this.constructor.BaseParser.tokenizer(input, options);
+  this.options = this.toks.options;
+  this.input = this.toks.input;
+  this.tok = this.last = {type: types$1.eof, start: 0, end: 0};
+  this.tok.validateRegExpFlags = noop;
+  this.tok.validateRegExpPattern = noop;
+  if (this.options.locations) {
+    var here = this.toks.curPosition();
+    this.tok.loc = new SourceLocation(this.toks, here, here);
+  }
+  this.ahead = []; // Tokens ahead
+  this.context = []; // Indentation contexted
+  this.curIndent = 0;
+  this.curLineStart = 0;
+  this.nextLineStart = this.lineEnd(this.curLineStart) + 1;
+  this.inAsync = false;
+  this.inGenerator = false;
+  this.inFunction = false;
+};
+
+LooseParser.prototype.startNode = function startNode () {
+  return new Node(this.toks, this.tok.start, this.options.locations ? this.tok.loc.start : null)
+};
+
+LooseParser.prototype.storeCurrentPos = function storeCurrentPos () {
+  return this.options.locations ? [this.tok.start, this.tok.loc.start] : this.tok.start
+};
+
+LooseParser.prototype.startNodeAt = function startNodeAt (pos) {
+  if (this.options.locations) {
+    return new Node(this.toks, pos[0], pos[1])
+  } else {
+    return new Node(this.toks, pos)
+  }
+};
+
+LooseParser.prototype.finishNode = function finishNode (node, type) {
+  node.type = type;
+  node.end = this.last.end;
+  if (this.options.locations)
+    { node.loc.end = this.last.loc.end; }
+  if (this.options.ranges)
+    { node.range[1] = this.last.end; }
+  return node
+};
+
+LooseParser.prototype.dummyNode = function dummyNode (type) {
+  var dummy = this.startNode();
+  dummy.type = type;
+  dummy.end = dummy.start;
+  if (this.options.locations)
+    { dummy.loc.end = dummy.loc.start; }
+  if (this.options.ranges)
+    { dummy.range[1] = dummy.start; }
+  this.last = {type: types$1.name, start: dummy.start, end: dummy.start, loc: dummy.loc};
+  return dummy
+};
+
+LooseParser.prototype.dummyIdent = function dummyIdent () {
+  var dummy = this.dummyNode("Identifier");
+  dummy.name = dummyValue;
+  return dummy
+};
+
+LooseParser.prototype.dummyString = function dummyString () {
+  var dummy = this.dummyNode("Literal");
+  dummy.value = dummy.raw = dummyValue;
+  return dummy
+};
+
+LooseParser.prototype.eat = function eat (type) {
+  if (this.tok.type === type) {
+    this.next();
+    return true
+  } else {
+    return false
+  }
+};
+
+LooseParser.prototype.isContextual = function isContextual (name) {
+  return this.tok.type === types$1.name && this.tok.value === name
+};
+
+LooseParser.prototype.eatContextual = function eatContextual (name) {
+  return this.tok.value === name && this.eat(types$1.name)
+};
+
+LooseParser.prototype.canInsertSemicolon = function canInsertSemicolon () {
+  return this.tok.type === types$1.eof || this.tok.type === types$1.braceR ||
+    lineBreak.test(this.input.slice(this.last.end, this.tok.start))
+};
+
+LooseParser.prototype.semicolon = function semicolon () {
+  return this.eat(types$1.semi)
+};
+
+LooseParser.prototype.expect = function expect (type) {
+  if (this.eat(type)) { return true }
+  for (var i = 1; i <= 2; i++) {
+    if (this.lookAhead(i).type === type) {
+      for (var j = 0; j < i; j++) { this.next(); }
+      return true
+    }
+  }
+};
+
+LooseParser.prototype.pushCx = function pushCx () {
+  this.context.push(this.curIndent);
+};
+
+LooseParser.prototype.popCx = function popCx () {
+  this.curIndent = this.context.pop();
+};
+
+LooseParser.prototype.lineEnd = function lineEnd (pos) {
+  while (pos < this.input.length && !isNewLine(this.input.charCodeAt(pos))) { ++pos; }
+  return pos
+};
+
+LooseParser.prototype.indentationAfter = function indentationAfter (pos) {
+  for (var count = 0;; ++pos) {
+    var ch = this.input.charCodeAt(pos);
+    if (ch === 32) { ++count; }
+    else if (ch === 9) { count += this.options.tabSize; }
+    else { return count }
+  }
+};
+
+LooseParser.prototype.closes = function closes (closeTok, indent, line, blockHeuristic) {
+  if (this.tok.type === closeTok || this.tok.type === types$1.eof) { return true }
+  return line !== this.curLineStart && this.curIndent < indent && this.tokenStartsLine() &&
+    (!blockHeuristic || this.nextLineStart >= this.input.length ||
+     this.indentationAfter(this.nextLineStart) < indent)
+};
+
+LooseParser.prototype.tokenStartsLine = function tokenStartsLine () {
+  for (var p = this.tok.start - 1; p >= this.curLineStart; --p) {
+    var ch = this.input.charCodeAt(p);
+    if (ch !== 9 && ch !== 32) { return false }
+  }
+  return true
+};
+
+LooseParser.prototype.extend = function extend (name, f) {
+  this[name] = f(this[name]);
+};
+
+LooseParser.prototype.parse = function parse () {
+  this.next();
+  return this.parseTopLevel()
+};
+
+LooseParser.extend = function extend () {
+    var plugins = [], len = arguments.length;
+    while ( len-- ) plugins[ len ] = arguments[ len ];
+
+  var cls = this;
+  for (var i = 0; i < plugins.length; i++) { cls = plugins[i](cls); }
+  return cls
+};
+
+LooseParser.parse = function parse (input, options) {
+  return new this(input, options).parse()
+};
+
+// Allows plugins to extend the base parser / tokenizer used
+LooseParser.BaseParser = Parser;
+
+var lp$2 = LooseParser.prototype;
+
+function isSpace(ch) {
+  return (ch < 14 && ch > 8) || ch === 32 || ch === 160 || isNewLine(ch)
+}
+
+lp$2.next = function() {
+  this.last = this.tok;
+  if (this.ahead.length)
+    { this.tok = this.ahead.shift(); }
+  else
+    { this.tok = this.readToken(); }
+
+  if (this.tok.start >= this.nextLineStart) {
+    while (this.tok.start >= this.nextLineStart) {
+      this.curLineStart = this.nextLineStart;
+      this.nextLineStart = this.lineEnd(this.curLineStart) + 1;
+    }
+    this.curIndent = this.indentationAfter(this.curLineStart);
+  }
+};
+
+lp$2.readToken = function() {
+  for (;;) {
+    try {
+      this.toks.next();
+      if (this.toks.type === types$1.dot &&
+          this.input.substr(this.toks.end, 1) === "." &&
+          this.options.ecmaVersion >= 6) {
+        this.toks.end++;
+        this.toks.type = types$1.ellipsis;
+      }
+      return new Token(this.toks)
+    } catch (e) {
+      if (!(e instanceof SyntaxError)) { throw e }
+
+      // Try to skip some text, based on the error message, and then continue
+      var msg = e.message, pos = e.raisedAt, replace = true;
+      if (/unterminated/i.test(msg)) {
+        pos = this.lineEnd(e.pos + 1);
+        if (/string/.test(msg)) {
+          replace = {start: e.pos, end: pos, type: types$1.string, value: this.input.slice(e.pos + 1, pos)};
+        } else if (/regular expr/i.test(msg)) {
+          var re = this.input.slice(e.pos, pos);
+          try { re = new RegExp(re); } catch (e$1) { /* ignore compilation error due to new syntax */ }
+          replace = {start: e.pos, end: pos, type: types$1.regexp, value: re};
+        } else if (/template/.test(msg)) {
+          replace = {
+            start: e.pos,
+            end: pos,
+            type: types$1.template,
+            value: this.input.slice(e.pos, pos)
+          };
+        } else {
+          replace = false;
+        }
+      } else if (/invalid (unicode|regexp|number)|expecting unicode|octal literal|is reserved|directly after number|expected number in radix|numeric separator/i.test(msg)) {
+        while (pos < this.input.length && !isSpace(this.input.charCodeAt(pos))) { ++pos; }
+      } else if (/character escape|expected hexadecimal/i.test(msg)) {
+        while (pos < this.input.length) {
+          var ch = this.input.charCodeAt(pos++);
+          if (ch === 34 || ch === 39 || isNewLine(ch)) { break }
+        }
+      } else if (/unexpected character/i.test(msg)) {
+        pos++;
+        replace = false;
+      } else if (/regular expression/i.test(msg)) {
+        replace = true;
+      } else {
+        throw e
+      }
+      this.resetTo(pos);
+      if (replace === true) { replace = {start: pos, end: pos, type: types$1.name, value: dummyValue}; }
+      if (replace) {
+        if (this.options.locations)
+          { replace.loc = new SourceLocation(
+            this.toks,
+            getLineInfo(this.input, replace.start),
+            getLineInfo(this.input, replace.end)); }
+        return replace
+      }
+    }
+  }
+};
+
+lp$2.resetTo = function(pos) {
+  this.toks.pos = pos;
+  this.toks.containsEsc = false;
+  var ch = this.input.charAt(pos - 1);
+  this.toks.exprAllowed = !ch || /[[{(,;:?/*=+\-~!|&%^<>]/.test(ch) ||
+    /[enwfd]/.test(ch) &&
+    /\b(case|else|return|throw|new|in|(instance|type)?of|delete|void)$/.test(this.input.slice(pos - 10, pos));
+
+  if (this.options.locations) {
+    this.toks.curLine = 1;
+    this.toks.lineStart = lineBreakG.lastIndex = 0;
+    var match;
+    while ((match = lineBreakG.exec(this.input)) && match.index < pos) {
+      ++this.toks.curLine;
+      this.toks.lineStart = match.index + match[0].length;
+    }
+  }
+};
+
+lp$2.lookAhead = function(n) {
+  while (n > this.ahead.length)
+    { this.ahead.push(this.readToken()); }
+  return this.ahead[n - 1]
+};
+
+var lp$1 = LooseParser.prototype;
+
+lp$1.parseTopLevel = function() {
+  var node = this.startNodeAt(this.options.locations ? [0, getLineInfo(this.input, 0)] : 0);
+  node.body = [];
+  while (this.tok.type !== types$1.eof) { node.body.push(this.parseStatement()); }
+  this.toks.adaptDirectivePrologue(node.body);
+  this.last = this.tok;
+  node.sourceType = this.options.sourceType === "commonjs" ? "script" : this.options.sourceType;
+  return this.finishNode(node, "Program")
+};
+
+lp$1.parseStatement = function() {
+  var starttype = this.tok.type, node = this.startNode(), kind;
+
+  if (this.toks.isLet()) {
+    starttype = types$1._var;
+    kind = "let";
+  }
+
+  switch (starttype) {
+  case types$1._break: case types$1._continue:
+    this.next();
+    var isBreak = starttype === types$1._break;
+    if (this.semicolon() || this.canInsertSemicolon()) {
+      node.label = null;
+    } else {
+      node.label = this.tok.type === types$1.name ? this.parseIdent() : null;
+      this.semicolon();
+    }
+    return this.finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement")
+
+  case types$1._debugger:
+    this.next();
+    this.semicolon();
+    return this.finishNode(node, "DebuggerStatement")
+
+  case types$1._do:
+    this.next();
+    node.body = this.parseStatement();
+    node.test = this.eat(types$1._while) ? this.parseParenExpression() : this.dummyIdent();
+    this.semicolon();
+    return this.finishNode(node, "DoWhileStatement")
+
+  case types$1._for:
+    this.next(); // `for` keyword
+    var isAwait = this.options.ecmaVersion >= 9 && this.eatContextual("await");
+
+    this.pushCx();
+    this.expect(types$1.parenL);
+    if (this.tok.type === types$1.semi) { return this.parseFor(node, null) }
+    var isLet = this.toks.isLet();
+    var isAwaitUsing = this.toks.isAwaitUsing(true);
+    var isUsing = !isAwaitUsing && this.toks.isUsing(true);
+
+    if (isLet || this.tok.type === types$1._var || this.tok.type === types$1._const || isUsing || isAwaitUsing) {
+      var kind$1 = isLet ? "let" : isUsing ? "using" : isAwaitUsing ? "await using" : this.tok.value;
+      var init$1 = this.startNode();
+      if (isUsing || isAwaitUsing) {
+        if (isAwaitUsing) { this.next(); }
+        this.parseVar(init$1, true, kind$1);
+      } else {
+        init$1 = this.parseVar(init$1, true, kind$1);
+      }
+
+      if (init$1.declarations.length === 1 && (this.tok.type === types$1._in || this.isContextual("of"))) {
+        if (this.options.ecmaVersion >= 9 && this.tok.type !== types$1._in) {
+          node.await = isAwait;
+        }
+        return this.parseForIn(node, init$1)
+      }
+      return this.parseFor(node, init$1)
+    }
+    var init = this.parseExpression(true);
+    if (this.tok.type === types$1._in || this.isContextual("of")) {
+      if (this.options.ecmaVersion >= 9 && this.tok.type !== types$1._in) {
+        node.await = isAwait;
+      }
+      return this.parseForIn(node, this.toAssignable(init))
+    }
+    return this.parseFor(node, init)
+
+  case types$1._function:
+    this.next();
+    return this.parseFunction(node, true)
+
+  case types$1._if:
+    this.next();
+    node.test = this.parseParenExpression();
+    node.consequent = this.parseStatement();
+    node.alternate = this.eat(types$1._else) ? this.parseStatement() : null;
+    return this.finishNode(node, "IfStatement")
+
+  case types$1._return:
+    this.next();
+    if (this.eat(types$1.semi) || this.canInsertSemicolon()) { node.argument = null; }
+    else { node.argument = this.parseExpression(); this.semicolon(); }
+    return this.finishNode(node, "ReturnStatement")
+
+  case types$1._switch:
+    var blockIndent = this.curIndent, line = this.curLineStart;
+    this.next();
+    node.discriminant = this.parseParenExpression();
+    node.cases = [];
+    this.pushCx();
+    this.expect(types$1.braceL);
+
+    var cur;
+    while (!this.closes(types$1.braceR, blockIndent, line, true)) {
+      if (this.tok.type === types$1._case || this.tok.type === types$1._default) {
+        var isCase = this.tok.type === types$1._case;
+        if (cur) { this.finishNode(cur, "SwitchCase"); }
+        node.cases.push(cur = this.startNode());
+        cur.consequent = [];
+        this.next();
+        if (isCase) { cur.test = this.parseExpression(); }
+        else { cur.test = null; }
+        this.expect(types$1.colon);
+      } else {
+        if (!cur) {
+          node.cases.push(cur = this.startNode());
+          cur.consequent = [];
+          cur.test = null;
+        }
+        cur.consequent.push(this.parseStatement());
+      }
+    }
+    if (cur) { this.finishNode(cur, "SwitchCase"); }
+    this.popCx();
+    this.eat(types$1.braceR);
+    return this.finishNode(node, "SwitchStatement")
+
+  case types$1._throw:
+    this.next();
+    node.argument = this.parseExpression();
+    this.semicolon();
+    return this.finishNode(node, "ThrowStatement")
+
+  case types$1._try:
+    this.next();
+    node.block = this.parseBlock();
+    node.handler = null;
+    if (this.tok.type === types$1._catch) {
+      var clause = this.startNode();
+      this.next();
+      if (this.eat(types$1.parenL)) {
+        clause.param = this.toAssignable(this.parseExprAtom(), true);
+        this.expect(types$1.parenR);
+      } else {
+        clause.param = null;
+      }
+      clause.body = this.parseBlock();
+      node.handler = this.finishNode(clause, "CatchClause");
+    }
+    node.finalizer = this.eat(types$1._finally) ? this.parseBlock() : null;
+    if (!node.handler && !node.finalizer) { return node.block }
+    return this.finishNode(node, "TryStatement")
+
+  case types$1._var:
+  case types$1._const:
+    return this.parseVar(node, false, kind || this.tok.value)
+
+  case types$1._while:
+    this.next();
+    node.test = this.parseParenExpression();
+    node.body = this.parseStatement();
+    return this.finishNode(node, "WhileStatement")
+
+  case types$1._with:
+    this.next();
+    node.object = this.parseParenExpression();
+    node.body = this.parseStatement();
+    return this.finishNode(node, "WithStatement")
+
+  case types$1.braceL:
+    return this.parseBlock()
+
+  case types$1.semi:
+    this.next();
+    return this.finishNode(node, "EmptyStatement")
+
+  case types$1._class:
+    return this.parseClass(true)
+
+  case types$1._import:
+    if (this.options.ecmaVersion > 10) {
+      var nextType = this.lookAhead(1).type;
+      if (nextType === types$1.parenL || nextType === types$1.dot) {
+        node.expression = this.parseExpression();
+        this.semicolon();
+        return this.finishNode(node, "ExpressionStatement")
+      }
+    }
+
+    return this.parseImport()
+
+  case types$1._export:
+    return this.parseExport()
+
+  default:
+    if (this.toks.isAsyncFunction()) {
+      this.next();
+      this.next();
+      return this.parseFunction(node, true, true)
+    }
+
+    if (this.toks.isUsing(false)) {
+      return this.parseVar(node, false, "using")
+    }
+
+    if (this.toks.isAwaitUsing(false)) {
+      this.next();
+      return this.parseVar(node, false, "await using")
+    }
+
+    var expr = this.parseExpression();
+    if (isDummy(expr)) {
+      this.next();
+      if (this.tok.type === types$1.eof) { return this.finishNode(node, "EmptyStatement") }
+      return this.parseStatement()
+    } else if (starttype === types$1.name && expr.type === "Identifier" && this.eat(types$1.colon)) {
+      node.body = this.parseStatement();
+      node.label = expr;
+      return this.finishNode(node, "LabeledStatement")
+    } else {
+      node.expression = expr;
+      this.semicolon();
+      return this.finishNode(node, "ExpressionStatement")
+    }
+  }
+};
+
+lp$1.parseBlock = function() {
+  var node = this.startNode();
+  this.pushCx();
+  this.expect(types$1.braceL);
+  var blockIndent = this.curIndent, line = this.curLineStart;
+  node.body = [];
+  while (!this.closes(types$1.braceR, blockIndent, line, true))
+    { node.body.push(this.parseStatement()); }
+  this.popCx();
+  this.eat(types$1.braceR);
+  return this.finishNode(node, "BlockStatement")
+};
+
+lp$1.parseFor = function(node, init) {
+  node.init = init;
+  node.test = node.update = null;
+  if (this.eat(types$1.semi) && this.tok.type !== types$1.semi) { node.test = this.parseExpression(); }
+  if (this.eat(types$1.semi) && this.tok.type !== types$1.parenR) { node.update = this.parseExpression(); }
+  this.popCx();
+  this.expect(types$1.parenR);
+  node.body = this.parseStatement();
+  return this.finishNode(node, "ForStatement")
+};
+
+lp$1.parseForIn = function(node, init) {
+  var type = this.tok.type === types$1._in ? "ForInStatement" : "ForOfStatement";
+  this.next();
+  node.left = init;
+  node.right = this.parseExpression();
+  this.popCx();
+  this.expect(types$1.parenR);
+  node.body = this.parseStatement();
+  return this.finishNode(node, type)
+};
+
+lp$1.parseVar = function(node, noIn, kind) {
+  node.kind = kind;
+  this.next();
+  node.declarations = [];
+  do {
+    var decl = this.startNode();
+    decl.id = this.options.ecmaVersion >= 6 ? this.toAssignable(this.parseExprAtom(), true) : this.parseIdent();
+    decl.init = this.eat(types$1.eq) ? this.parseMaybeAssign(noIn) : null;
+    node.declarations.push(this.finishNode(decl, "VariableDeclarator"));
+  } while (this.eat(types$1.comma))
+  if (!node.declarations.length) {
+    var decl$1 = this.startNode();
+    decl$1.id = this.dummyIdent();
+    node.declarations.push(this.finishNode(decl$1, "VariableDeclarator"));
+  }
+  if (!noIn) { this.semicolon(); }
+  return this.finishNode(node, "VariableDeclaration")
+};
+
+lp$1.parseClass = function(isStatement) {
+  var node = this.startNode();
+  this.next();
+  if (this.tok.type === types$1.name) { node.id = this.parseIdent(); }
+  else if (isStatement === true) { node.id = this.dummyIdent(); }
+  else { node.id = null; }
+  node.superClass = this.eat(types$1._extends) ? this.parseExpression() : null;
+  node.body = this.startNode();
+  node.body.body = [];
+  this.pushCx();
+  var indent = this.curIndent + 1, line = this.curLineStart;
+  this.eat(types$1.braceL);
+  if (this.curIndent + 1 < indent) { indent = this.curIndent; line = this.curLineStart; }
+  while (!this.closes(types$1.braceR, indent, line)) {
+    var element = this.parseClassElement();
+    if (element) { node.body.body.push(element); }
+  }
+  this.popCx();
+  if (!this.eat(types$1.braceR)) {
+    // If there is no closing brace, make the node span to the start
+    // of the next token (this is useful for Tern)
+    this.last.end = this.tok.start;
+    if (this.options.locations) { this.last.loc.end = this.tok.loc.start; }
+  }
+  this.semicolon();
+  this.finishNode(node.body, "ClassBody");
+  return this.finishNode(node, isStatement ? "ClassDeclaration" : "ClassExpression")
+};
+
+lp$1.parseClassElement = function() {
+  if (this.eat(types$1.semi)) { return null }
+
+  var ref = this.options;
+  var ecmaVersion = ref.ecmaVersion;
+  var locations = ref.locations;
+  var indent = this.curIndent;
+  var line = this.curLineStart;
+  var node = this.startNode();
+  var keyName = "";
+  var isGenerator = false;
+  var isAsync = false;
+  var kind = "method";
+  var isStatic = false;
+
+  if (this.eatContextual("static")) {
+    // Parse static init block
+    if (ecmaVersion >= 13 && this.eat(types$1.braceL)) {
+      this.parseClassStaticBlock(node);
+      return node
+    }
+    if (this.isClassElementNameStart() || this.toks.type === types$1.star) {
+      isStatic = true;
+    } else {
+      keyName = "static";
+    }
+  }
+  node.static = isStatic;
+  if (!keyName && ecmaVersion >= 8 && this.eatContextual("async")) {
+    if ((this.isClassElementNameStart() || this.toks.type === types$1.star) && !this.canInsertSemicolon()) {
+      isAsync = true;
+    } else {
+      keyName = "async";
+    }
+  }
+  if (!keyName) {
+    isGenerator = this.eat(types$1.star);
+    var lastValue = this.toks.value;
+    if (this.eatContextual("get") || this.eatContextual("set")) {
+      if (this.isClassElementNameStart()) {
+        kind = lastValue;
+      } else {
+        keyName = lastValue;
+      }
+    }
+  }
+
+  // Parse element name
+  if (keyName) {
+    // 'async', 'get', 'set', or 'static' were not a keyword contextually.
+    // The last token is any of those. Make it the element name.
+    node.computed = false;
+    node.key = this.startNodeAt(locations ? [this.toks.lastTokStart, this.toks.lastTokStartLoc] : this.toks.lastTokStart);
+    node.key.name = keyName;
+    this.finishNode(node.key, "Identifier");
+  } else {
+    this.parseClassElementName(node);
+
+    // From https://github.com/acornjs/acorn/blob/7deba41118d6384a2c498c61176b3cf434f69590/acorn-loose/src/statement.js#L291
+    // Skip broken stuff.
+    if (isDummy(node.key)) {
+      if (isDummy(this.parseMaybeAssign())) { this.next(); }
+      this.eat(types$1.comma);
+      return null
+    }
+  }
+
+  // Parse element value
+  if (ecmaVersion < 13 || this.toks.type === types$1.parenL || kind !== "method" || isGenerator || isAsync) {
+    // Method
+    var isConstructor =
+      !node.computed &&
+      !node.static &&
+      !isGenerator &&
+      !isAsync &&
+      kind === "method" && (
+        node.key.type === "Identifier" && node.key.name === "constructor" ||
+        node.key.type === "Literal" && node.key.value === "constructor"
+      );
+    node.kind = isConstructor ? "constructor" : kind;
+    node.value = this.parseMethod(isGenerator, isAsync);
+    this.finishNode(node, "MethodDefinition");
+  } else {
+    // Field
+    if (this.eat(types$1.eq)) {
+      if (this.curLineStart !== line && this.curIndent <= indent && this.tokenStartsLine()) {
+        // Estimated the next line is the next class element by indentations.
+        node.value = null;
+      } else {
+        var oldInAsync = this.inAsync;
+        var oldInGenerator = this.inGenerator;
+        this.inAsync = false;
+        this.inGenerator = false;
+        node.value = this.parseMaybeAssign();
+        this.inAsync = oldInAsync;
+        this.inGenerator = oldInGenerator;
+      }
+    } else {
+      node.value = null;
+    }
+    this.semicolon();
+    this.finishNode(node, "PropertyDefinition");
+  }
+
+  return node
+};
+
+lp$1.parseClassStaticBlock = function(node) {
+  var blockIndent = this.curIndent, line = this.curLineStart;
+  node.body = [];
+  this.pushCx();
+  while (!this.closes(types$1.braceR, blockIndent, line, true))
+    { node.body.push(this.parseStatement()); }
+  this.popCx();
+  this.eat(types$1.braceR);
+
+  return this.finishNode(node, "StaticBlock")
+};
+
+lp$1.isClassElementNameStart = function() {
+  return this.toks.isClassElementNameStart()
+};
+
+lp$1.parseClassElementName = function(element) {
+  if (this.toks.type === types$1.privateId) {
+    element.computed = false;
+    element.key = this.parsePrivateIdent();
+  } else {
+    this.parsePropertyName(element);
+  }
+};
+
+lp$1.parseFunction = function(node, isStatement, isAsync) {
+  var oldInAsync = this.inAsync, oldInGenerator = this.inGenerator, oldInFunction = this.inFunction;
+  this.initFunction(node);
+  if (this.options.ecmaVersion >= 6) {
+    node.generator = this.eat(types$1.star);
+  }
+  if (this.options.ecmaVersion >= 8) {
+    node.async = !!isAsync;
+  }
+  if (this.tok.type === types$1.name) { node.id = this.parseIdent(); }
+  else if (isStatement === true) { node.id = this.dummyIdent(); }
+  this.inAsync = node.async;
+  this.inGenerator = node.generator;
+  this.inFunction = true;
+  node.params = this.parseFunctionParams();
+  node.body = this.parseBlock();
+  this.toks.adaptDirectivePrologue(node.body.body);
+  this.inAsync = oldInAsync;
+  this.inGenerator = oldInGenerator;
+  this.inFunction = oldInFunction;
+  return this.finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression")
+};
+
+lp$1.parseExport = function() {
+  var node = this.startNode();
+  this.next();
+  if (this.eat(types$1.star)) {
+    if (this.options.ecmaVersion >= 11) {
+      if (this.eatContextual("as")) {
+        node.exported = this.parseExprAtom();
+      } else {
+        node.exported = null;
+      }
+    }
+    node.source = this.eatContextual("from") ? this.parseExprAtom() : this.dummyString();
+    if (this.options.ecmaVersion >= 16)
+      { node.attributes = this.parseWithClause(); }
+    this.semicolon();
+    return this.finishNode(node, "ExportAllDeclaration")
+  }
+  if (this.eat(types$1._default)) {
+    // export default (function foo() {}) // This is FunctionExpression.
+    var isAsync;
+    if (this.tok.type === types$1._function || (isAsync = this.toks.isAsyncFunction())) {
+      var fNode = this.startNode();
+      this.next();
+      if (isAsync) { this.next(); }
+      node.declaration = this.parseFunction(fNode, "nullableID", isAsync);
+    } else if (this.tok.type === types$1._class) {
+      node.declaration = this.parseClass("nullableID");
+    } else {
+      node.declaration = this.parseMaybeAssign();
+      this.semicolon();
+    }
+    return this.finishNode(node, "ExportDefaultDeclaration")
+  }
+  if (this.tok.type.keyword || this.toks.isLet() || this.toks.isAsyncFunction()) {
+    node.declaration = this.parseStatement();
+    node.specifiers = [];
+    node.source = null;
+  } else {
+    node.declaration = null;
+    node.specifiers = this.parseExportSpecifierList();
+    node.source = this.eatContextual("from") ? this.parseExprAtom() : null;
+    if (this.options.ecmaVersion >= 16)
+      { node.attributes = this.parseWithClause(); }
+    this.semicolon();
+  }
+  return this.finishNode(node, "ExportNamedDeclaration")
+};
+
+lp$1.parseImport = function() {
+  var node = this.startNode();
+  this.next();
+  if (this.tok.type === types$1.string) {
+    node.specifiers = [];
+    node.source = this.parseExprAtom();
+  } else {
+    var elt;
+    if (this.tok.type === types$1.name && this.tok.value !== "from") {
+      elt = this.startNode();
+      elt.local = this.parseIdent();
+      this.finishNode(elt, "ImportDefaultSpecifier");
+      this.eat(types$1.comma);
+    }
+    node.specifiers = this.parseImportSpecifiers();
+    node.source = this.eatContextual("from") && this.tok.type === types$1.string ? this.parseExprAtom() : this.dummyString();
+    if (elt) { node.specifiers.unshift(elt); }
+  }
+  if (this.options.ecmaVersion >= 16)
+    { node.attributes = this.parseWithClause(); }
+  this.semicolon();
+  return this.finishNode(node, "ImportDeclaration")
+};
+
+lp$1.parseImportSpecifiers = function() {
+  var elts = [];
+  if (this.tok.type === types$1.star) {
+    var elt = this.startNode();
+    this.next();
+    elt.local = this.eatContextual("as") ? this.parseIdent() : this.dummyIdent();
+    elts.push(this.finishNode(elt, "ImportNamespaceSpecifier"));
+  } else {
+    var indent = this.curIndent, line = this.curLineStart, continuedLine = this.nextLineStart;
+    this.pushCx();
+    this.eat(types$1.braceL);
+    if (this.curLineStart > continuedLine) { continuedLine = this.curLineStart; }
+    while (!this.closes(types$1.braceR, indent + (this.curLineStart <= continuedLine ? 1 : 0), line)) {
+      var elt$1 = this.startNode();
+      if (this.eat(types$1.star)) {
+        elt$1.local = this.eatContextual("as") ? this.parseModuleExportName() : this.dummyIdent();
+        this.finishNode(elt$1, "ImportNamespaceSpecifier");
+      } else {
+        if (this.isContextual("from")) { break }
+        elt$1.imported = this.parseModuleExportName();
+        if (isDummy(elt$1.imported)) { break }
+        elt$1.local = this.eatContextual("as") ? this.parseModuleExportName() : elt$1.imported;
+        this.finishNode(elt$1, "ImportSpecifier");
+      }
+      elts.push(elt$1);
+      this.eat(types$1.comma);
+    }
+    this.eat(types$1.braceR);
+    this.popCx();
+  }
+  return elts
+};
+
+lp$1.parseWithClause = function() {
+  var nodes = [];
+  if (!this.eat(types$1._with)) {
+    return nodes
+  }
+
+  var indent = this.curIndent, line = this.curLineStart, continuedLine = this.nextLineStart;
+  this.pushCx();
+  this.eat(types$1.braceL);
+  if (this.curLineStart > continuedLine) { continuedLine = this.curLineStart; }
+  while (!this.closes(types$1.braceR, indent + (this.curLineStart <= continuedLine ? 1 : 0), line)) {
+    var attr = this.startNode();
+    attr.key = this.tok.type === types$1.string ? this.parseExprAtom() : this.parseIdent();
+    if (this.eat(types$1.colon)) {
+      if (this.tok.type === types$1.string)
+        { attr.value = this.parseExprAtom(); }
+      else { attr.value = this.dummyString(); }
+    } else {
+      if (isDummy(attr.key)) { break }
+      if (this.tok.type === types$1.string)
+        { attr.value = this.parseExprAtom(); }
+      else { break }
+    }
+    nodes.push(this.finishNode(attr, "ImportAttribute"));
+    this.eat(types$1.comma);
+  }
+  this.eat(types$1.braceR);
+  this.popCx();
+  return nodes
+};
+
+lp$1.parseExportSpecifierList = function() {
+  var elts = [];
+  var indent = this.curIndent, line = this.curLineStart, continuedLine = this.nextLineStart;
+  this.pushCx();
+  this.eat(types$1.braceL);
+  if (this.curLineStart > continuedLine) { continuedLine = this.curLineStart; }
+  while (!this.closes(types$1.braceR, indent + (this.curLineStart <= continuedLine ? 1 : 0), line)) {
+    if (this.isContextual("from")) { break }
+    var elt = this.startNode();
+    elt.local = this.parseModuleExportName();
+    if (isDummy(elt.local)) { break }
+    elt.exported = this.eatContextual("as") ? this.parseModuleExportName() : elt.local;
+    this.finishNode(elt, "ExportSpecifier");
+    elts.push(elt);
+    this.eat(types$1.comma);
+  }
+  this.eat(types$1.braceR);
+  this.popCx();
+  return elts
+};
+
+lp$1.parseModuleExportName = function() {
+  return this.options.ecmaVersion >= 13 && this.tok.type === types$1.string
+    ? this.parseExprAtom()
+    : this.parseIdent()
+};
+
+var lp = LooseParser.prototype;
+
+lp.checkLVal = function(expr) {
+  if (!expr) { return expr }
+  switch (expr.type) {
+  case "Identifier":
+  case "MemberExpression":
+    return expr
+
+  case "ParenthesizedExpression":
+    expr.expression = this.checkLVal(expr.expression);
+    return expr
+
+  default:
+    return this.dummyIdent()
+  }
+};
+
+lp.parseExpression = function(noIn) {
+  var start = this.storeCurrentPos();
+  var expr = this.parseMaybeAssign(noIn);
+  if (this.tok.type === types$1.comma) {
+    var node = this.startNodeAt(start);
+    node.expressions = [expr];
+    while (this.eat(types$1.comma)) { node.expressions.push(this.parseMaybeAssign(noIn)); }
+    return this.finishNode(node, "SequenceExpression")
+  }
+  return expr
+};
+
+lp.parseParenExpression = function() {
+  this.pushCx();
+  this.expect(types$1.parenL);
+  var val = this.parseExpression();
+  this.popCx();
+  this.expect(types$1.parenR);
+  return val
+};
+
+lp.parseMaybeAssign = function(noIn) {
+  // `yield` should be an identifier reference if it's not in generator functions.
+  if (this.inGenerator && this.toks.isContextual("yield")) {
+    var node = this.startNode();
+    this.next();
+    if (this.semicolon() || this.canInsertSemicolon() || (this.tok.type !== types$1.star && !this.tok.type.startsExpr)) {
+      node.delegate = false;
+      node.argument = null;
+    } else {
+      node.delegate = this.eat(types$1.star);
+      node.argument = this.parseMaybeAssign();
+    }
+    return this.finishNode(node, "YieldExpression")
+  }
+
+  var start = this.storeCurrentPos();
+  var left = this.parseMaybeConditional(noIn);
+  if (this.tok.type.isAssign) {
+    var node$1 = this.startNodeAt(start);
+    node$1.operator = this.tok.value;
+    node$1.left = this.tok.type === types$1.eq ? this.toAssignable(left) : this.checkLVal(left);
+    this.next();
+    node$1.right = this.parseMaybeAssign(noIn);
+    return this.finishNode(node$1, "AssignmentExpression")
+  }
+  return left
+};
+
+lp.parseMaybeConditional = function(noIn) {
+  var start = this.storeCurrentPos();
+  var expr = this.parseExprOps(noIn);
+  if (this.eat(types$1.question)) {
+    var node = this.startNodeAt(start);
+    node.test = expr;
+    node.consequent = this.parseMaybeAssign();
+    node.alternate = this.expect(types$1.colon) ? this.parseMaybeAssign(noIn) : this.dummyIdent();
+    return this.finishNode(node, "ConditionalExpression")
+  }
+  return expr
+};
+
+lp.parseExprOps = function(noIn) {
+  var start = this.storeCurrentPos();
+  var indent = this.curIndent, line = this.curLineStart;
+  return this.parseExprOp(this.parseMaybeUnary(false), start, -1, noIn, indent, line)
+};
+
+lp.parseExprOp = function(left, start, minPrec, noIn, indent, line) {
+  if (this.curLineStart !== line && this.curIndent < indent && this.tokenStartsLine()) { return left }
+  var prec = this.tok.type.binop;
+  if (prec != null && (!noIn || this.tok.type !== types$1._in)) {
+    if (prec > minPrec) {
+      var node = this.startNodeAt(start);
+      node.left = left;
+      node.operator = this.tok.value;
+      this.next();
+      if (this.curLineStart !== line && this.curIndent < indent && this.tokenStartsLine()) {
+        node.right = this.dummyIdent();
+      } else {
+        var rightStart = this.storeCurrentPos();
+        node.right = this.parseExprOp(this.parseMaybeUnary(false), rightStart, prec, noIn, indent, line);
+      }
+      this.finishNode(node, /&&|\|\||\?\?/.test(node.operator) ? "LogicalExpression" : "BinaryExpression");
+      return this.parseExprOp(node, start, minPrec, noIn, indent, line)
+    }
+  }
+  return left
+};
+
+lp.parseMaybeUnary = function(sawUnary) {
+  var start = this.storeCurrentPos(), expr;
+  if (this.options.ecmaVersion >= 8 && this.toks.isContextual("await") &&
+      (this.inAsync || (this.toks.inModule && this.options.ecmaVersion >= 13) ||
+       (!this.inFunction && this.options.allowAwaitOutsideFunction))) {
+    expr = this.parseAwait();
+    sawUnary = true;
+  } else if (this.tok.type.prefix) {
+    var node = this.startNode(), update = this.tok.type === types$1.incDec;
+    if (!update) { sawUnary = true; }
+    node.operator = this.tok.value;
+    node.prefix = true;
+    this.next();
+    node.argument = this.parseMaybeUnary(true);
+    if (update) { node.argument = this.checkLVal(node.argument); }
+    expr = this.finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
+  } else if (this.tok.type === types$1.ellipsis) {
+    var node$1 = this.startNode();
+    this.next();
+    node$1.argument = this.parseMaybeUnary(sawUnary);
+    expr = this.finishNode(node$1, "SpreadElement");
+  } else if (!sawUnary && this.tok.type === types$1.privateId) {
+    expr = this.parsePrivateIdent();
+  } else {
+    expr = this.parseExprSubscripts();
+    while (this.tok.type.postfix && !this.canInsertSemicolon()) {
+      var node$2 = this.startNodeAt(start);
+      node$2.operator = this.tok.value;
+      node$2.prefix = false;
+      node$2.argument = this.checkLVal(expr);
+      this.next();
+      expr = this.finishNode(node$2, "UpdateExpression");
+    }
+  }
+
+  if (!sawUnary && this.eat(types$1.starstar)) {
+    var node$3 = this.startNodeAt(start);
+    node$3.operator = "**";
+    node$3.left = expr;
+    node$3.right = this.parseMaybeUnary(false);
+    return this.finishNode(node$3, "BinaryExpression")
+  }
+
+  return expr
+};
+
+lp.parseExprSubscripts = function() {
+  var start = this.storeCurrentPos();
+  return this.parseSubscripts(this.parseExprAtom(), start, false, this.curIndent, this.curLineStart)
+};
+
+lp.parseSubscripts = function(base, start, noCalls, startIndent, line) {
+  var optionalSupported = this.options.ecmaVersion >= 11;
+  var optionalChained = false;
+  for (;;) {
+    if (this.curLineStart !== line && this.curIndent <= startIndent && this.tokenStartsLine()) {
+      if (this.tok.type === types$1.dot && this.curIndent === startIndent)
+        { --startIndent; }
+      else
+        { break }
+    }
+
+    var maybeAsyncArrow = base.type === "Identifier" && base.name === "async" && !this.canInsertSemicolon();
+    var optional = optionalSupported && this.eat(types$1.questionDot);
+    if (optional) {
+      optionalChained = true;
+    }
+
+    if ((optional && this.tok.type !== types$1.parenL && this.tok.type !== types$1.bracketL && this.tok.type !== types$1.backQuote) || this.eat(types$1.dot)) {
+      var node = this.startNodeAt(start);
+      node.object = base;
+      if (this.curLineStart !== line && this.curIndent <= startIndent && this.tokenStartsLine())
+        { node.property = this.dummyIdent(); }
+      else
+        { node.property = this.parsePropertyAccessor() || this.dummyIdent(); }
+      node.computed = false;
+      if (optionalSupported) {
+        node.optional = optional;
+      }
+      base = this.finishNode(node, "MemberExpression");
+    } else if (this.tok.type === types$1.bracketL) {
+      this.pushCx();
+      this.next();
+      var node$1 = this.startNodeAt(start);
+      node$1.object = base;
+      node$1.property = this.parseExpression();
+      node$1.computed = true;
+      if (optionalSupported) {
+        node$1.optional = optional;
+      }
+      this.popCx();
+      this.expect(types$1.bracketR);
+      base = this.finishNode(node$1, "MemberExpression");
+    } else if (!noCalls && this.tok.type === types$1.parenL) {
+      var exprList = this.parseExprList(types$1.parenR);
+      if (maybeAsyncArrow && this.eat(types$1.arrow))
+        { return this.parseArrowExpression(this.startNodeAt(start), exprList, true) }
+      var node$2 = this.startNodeAt(start);
+      node$2.callee = base;
+      node$2.arguments = exprList;
+      if (optionalSupported) {
+        node$2.optional = optional;
+      }
+      base = this.finishNode(node$2, "CallExpression");
+    } else if (this.tok.type === types$1.backQuote) {
+      var node$3 = this.startNodeAt(start);
+      node$3.tag = base;
+      node$3.quasi = this.parseTemplate();
+      base = this.finishNode(node$3, "TaggedTemplateExpression");
+    } else {
+      break
+    }
+  }
+
+  if (optionalChained) {
+    var chainNode = this.startNodeAt(start);
+    chainNode.expression = base;
+    base = this.finishNode(chainNode, "ChainExpression");
+  }
+  return base
+};
+
+lp.parseExprAtom = function() {
+  var node;
+  switch (this.tok.type) {
+  case types$1._this:
+  case types$1._super:
+    var type = this.tok.type === types$1._this ? "ThisExpression" : "Super";
+    node = this.startNode();
+    this.next();
+    return this.finishNode(node, type)
+
+  case types$1.name:
+    var start = this.storeCurrentPos();
+    var id = this.parseIdent();
+    var isAsync = false;
+    if (id.name === "async" && !this.canInsertSemicolon()) {
+      if (this.eat(types$1._function)) {
+        this.toks.overrideContext(types.f_expr);
+        return this.parseFunction(this.startNodeAt(start), false, true)
+      }
+      if (this.tok.type === types$1.name) {
+        id = this.parseIdent();
+        isAsync = true;
+      }
+    }
+    return this.eat(types$1.arrow) ? this.parseArrowExpression(this.startNodeAt(start), [id], isAsync) : id
+
+  case types$1.regexp:
+    node = this.startNode();
+    var val = this.tok.value;
+    node.regex = {pattern: val.pattern, flags: val.flags};
+    node.value = val.value;
+    node.raw = this.input.slice(this.tok.start, this.tok.end);
+    this.next();
+    return this.finishNode(node, "Literal")
+
+  case types$1.num: case types$1.string:
+    node = this.startNode();
+    node.value = this.tok.value;
+    node.raw = this.input.slice(this.tok.start, this.tok.end);
+    if (this.tok.type === types$1.num && node.raw.charCodeAt(node.raw.length - 1) === 110)
+      { node.bigint = node.value != null ? node.value.toString() : node.raw.slice(0, -1).replace(/_/g, ""); }
+    this.next();
+    return this.finishNode(node, "Literal")
+
+  case types$1._null: case types$1._true: case types$1._false:
+    node = this.startNode();
+    node.value = this.tok.type === types$1._null ? null : this.tok.type === types$1._true;
+    node.raw = this.tok.type.keyword;
+    this.next();
+    return this.finishNode(node, "Literal")
+
+  case types$1.parenL:
+    var parenStart = this.storeCurrentPos();
+    this.next();
+    var inner = this.parseExpression();
+    this.expect(types$1.parenR);
+    if (this.eat(types$1.arrow)) {
+      // (a,)=>a // SequenceExpression makes dummy in the last hole. Drop the dummy.
+      var params = inner.expressions || [inner];
+      if (params.length && isDummy(params[params.length - 1]))
+        { params.pop(); }
+      return this.parseArrowExpression(this.startNodeAt(parenStart), params)
+    }
+    if (this.options.preserveParens) {
+      var par = this.startNodeAt(parenStart);
+      par.expression = inner;
+      inner = this.finishNode(par, "ParenthesizedExpression");
+    }
+    return inner
+
+  case types$1.bracketL:
+    node = this.startNode();
+    node.elements = this.parseExprList(types$1.bracketR, true);
+    return this.finishNode(node, "ArrayExpression")
+
+  case types$1.braceL:
+    this.toks.overrideContext(types.b_expr);
+    return this.parseObj()
+
+  case types$1._class:
+    return this.parseClass(false)
+
+  case types$1._function:
+    node = this.startNode();
+    this.next();
+    return this.parseFunction(node, false)
+
+  case types$1._new:
+    return this.parseNew()
+
+  case types$1.backQuote:
+    return this.parseTemplate()
+
+  case types$1._import:
+    if (this.options.ecmaVersion >= 11) {
+      return this.parseExprImport()
+    } else {
+      return this.dummyIdent()
+    }
+
+  default:
+    return this.dummyIdent()
+  }
+};
+
+lp.parseExprImport = function() {
+  var node = this.startNode();
+  var meta = this.parseIdent(true);
+  switch (this.tok.type) {
+  case types$1.parenL:
+    return this.parseDynamicImport(node)
+  case types$1.dot:
+    node.meta = meta;
+    return this.parseImportMeta(node)
+  default:
+    node.name = "import";
+    return this.finishNode(node, "Identifier")
+  }
+};
+
+lp.parseDynamicImport = function(node) {
+  var list = this.parseExprList(types$1.parenR);
+  node.source = list[0] || this.dummyString();
+  node.options = list[1] || null;
+  return this.finishNode(node, "ImportExpression")
+};
+
+lp.parseImportMeta = function(node) {
+  this.next(); // skip '.'
+  node.property = this.parseIdent(true);
+  return this.finishNode(node, "MetaProperty")
+};
+
+lp.parseNew = function() {
+  var node = this.startNode(), startIndent = this.curIndent, line = this.curLineStart;
+  var meta = this.parseIdent(true);
+  if (this.options.ecmaVersion >= 6 && this.eat(types$1.dot)) {
+    node.meta = meta;
+    node.property = this.parseIdent(true);
+    return this.finishNode(node, "MetaProperty")
+  }
+  var start = this.storeCurrentPos();
+  node.callee = this.parseSubscripts(this.parseExprAtom(), start, true, startIndent, line);
+  if (this.tok.type === types$1.parenL) {
+    node.arguments = this.parseExprList(types$1.parenR);
+  } else {
+    node.arguments = [];
+  }
+  return this.finishNode(node, "NewExpression")
+};
+
+lp.parseTemplateElement = function() {
+  var elem = this.startNode();
+
+  // The loose parser accepts invalid unicode escapes even in untagged templates.
+  if (this.tok.type === types$1.invalidTemplate) {
+    elem.value = {
+      raw: this.tok.value,
+      cooked: null
+    };
+  } else {
+    elem.value = {
+      raw: this.input.slice(this.tok.start, this.tok.end).replace(/\r\n?/g, "\n"),
+      cooked: this.tok.value
+    };
+  }
+  this.next();
+  elem.tail = this.tok.type === types$1.backQuote;
+  return this.finishNode(elem, "TemplateElement")
+};
+
+lp.parseTemplate = function() {
+  var node = this.startNode();
+  this.next();
+  node.expressions = [];
+  var curElt = this.parseTemplateElement();
+  node.quasis = [curElt];
+  while (!curElt.tail) {
+    this.next();
+    node.expressions.push(this.parseExpression());
+    if (this.expect(types$1.braceR)) {
+      curElt = this.parseTemplateElement();
+    } else {
+      curElt = this.startNode();
+      curElt.value = {cooked: "", raw: ""};
+      curElt.tail = true;
+      this.finishNode(curElt, "TemplateElement");
+    }
+    node.quasis.push(curElt);
+  }
+  this.expect(types$1.backQuote);
+  return this.finishNode(node, "TemplateLiteral")
+};
+
+lp.parseObj = function() {
+  var node = this.startNode();
+  node.properties = [];
+  this.pushCx();
+  var indent = this.curIndent + 1, line = this.curLineStart;
+  this.eat(types$1.braceL);
+  if (this.curIndent + 1 < indent) { indent = this.curIndent; line = this.curLineStart; }
+  while (!this.closes(types$1.braceR, indent, line)) {
+    var prop = this.startNode(), isGenerator = (void 0), isAsync = (void 0), start = (void 0);
+    if (this.options.ecmaVersion >= 9 && this.eat(types$1.ellipsis)) {
+      prop.argument = this.parseMaybeAssign();
+      node.properties.push(this.finishNode(prop, "SpreadElement"));
+      this.eat(types$1.comma);
+      continue
+    }
+    if (this.options.ecmaVersion >= 6) {
+      start = this.storeCurrentPos();
+      prop.method = false;
+      prop.shorthand = false;
+      isGenerator = this.eat(types$1.star);
+    }
+    this.parsePropertyName(prop);
+    if (this.toks.isAsyncProp(prop)) {
+      isAsync = true;
+      isGenerator = this.options.ecmaVersion >= 9 && this.eat(types$1.star);
+      this.parsePropertyName(prop);
+    } else {
+      isAsync = false;
+    }
+    if (isDummy(prop.key)) { if (isDummy(this.parseMaybeAssign())) { this.next(); } this.eat(types$1.comma); continue }
+    if (this.eat(types$1.colon)) {
+      prop.kind = "init";
+      prop.value = this.parseMaybeAssign();
+    } else if (this.options.ecmaVersion >= 6 && (this.tok.type === types$1.parenL || this.tok.type === types$1.braceL)) {
+      prop.kind = "init";
+      prop.method = true;
+      prop.value = this.parseMethod(isGenerator, isAsync);
+    } else if (this.options.ecmaVersion >= 5 && prop.key.type === "Identifier" &&
+               !prop.computed && (prop.key.name === "get" || prop.key.name === "set") &&
+               (this.tok.type !== types$1.comma && this.tok.type !== types$1.braceR && this.tok.type !== types$1.eq)) {
+      prop.kind = prop.key.name;
+      this.parsePropertyName(prop);
+      prop.value = this.parseMethod(false);
+    } else {
+      prop.kind = "init";
+      if (this.options.ecmaVersion >= 6) {
+        if (this.eat(types$1.eq)) {
+          var assign = this.startNodeAt(start);
+          assign.operator = "=";
+          assign.left = prop.key;
+          assign.right = this.parseMaybeAssign();
+          prop.value = this.finishNode(assign, "AssignmentExpression");
+        } else {
+          prop.value = prop.key;
+        }
+      } else {
+        prop.value = this.dummyIdent();
+      }
+      prop.shorthand = true;
+    }
+    node.properties.push(this.finishNode(prop, "Property"));
+    this.eat(types$1.comma);
+  }
+  this.popCx();
+  if (!this.eat(types$1.braceR)) {
+    // If there is no closing brace, make the node span to the start
+    // of the next token (this is useful for Tern)
+    this.last.end = this.tok.start;
+    if (this.options.locations) { this.last.loc.end = this.tok.loc.start; }
+  }
+  return this.finishNode(node, "ObjectExpression")
+};
+
+lp.parsePropertyName = function(prop) {
+  if (this.options.ecmaVersion >= 6) {
+    if (this.eat(types$1.bracketL)) {
+      prop.computed = true;
+      prop.key = this.parseExpression();
+      this.expect(types$1.bracketR);
+      return
+    } else {
+      prop.computed = false;
+    }
+  }
+  var key = (this.tok.type === types$1.num || this.tok.type === types$1.string) ? this.parseExprAtom() : this.parseIdent();
+  prop.key = key || this.dummyIdent();
+};
+
+lp.parsePropertyAccessor = function() {
+  if (this.tok.type === types$1.name || this.tok.type.keyword) { return this.parseIdent() }
+  if (this.tok.type === types$1.privateId) { return this.parsePrivateIdent() }
+};
+
+lp.parseIdent = function() {
+  var name = this.tok.type === types$1.name ? this.tok.value : this.tok.type.keyword;
+  if (!name) { return this.dummyIdent() }
+  if (this.tok.type.keyword) { this.toks.type = types$1.name; }
+  var node = this.startNode();
+  this.next();
+  node.name = name;
+  return this.finishNode(node, "Identifier")
+};
+
+lp.parsePrivateIdent = function() {
+  var node = this.startNode();
+  node.name = this.tok.value;
+  this.next();
+  return this.finishNode(node, "PrivateIdentifier")
+};
+
+lp.initFunction = function(node) {
+  node.id = null;
+  node.params = [];
+  if (this.options.ecmaVersion >= 6) {
+    node.generator = false;
+    node.expression = false;
+  }
+  if (this.options.ecmaVersion >= 8)
+    { node.async = false; }
+};
+
+// Convert existing expression atom to assignable pattern
+// if possible.
+
+lp.toAssignable = function(node, binding) {
+  if (!node || node.type === "Identifier" || (node.type === "MemberExpression" && !binding)) ; else if (node.type === "ParenthesizedExpression") {
+    this.toAssignable(node.expression, binding);
+  } else if (this.options.ecmaVersion < 6) {
+    return this.dummyIdent()
+  } else if (node.type === "ObjectExpression") {
+    node.type = "ObjectPattern";
+    for (var i = 0, list = node.properties; i < list.length; i += 1)
+      {
+      var prop = list[i];
+
+      this.toAssignable(prop, binding);
+    }
+  } else if (node.type === "ArrayExpression") {
+    node.type = "ArrayPattern";
+    this.toAssignableList(node.elements, binding);
+  } else if (node.type === "Property") {
+    this.toAssignable(node.value, binding);
+  } else if (node.type === "SpreadElement") {
+    node.type = "RestElement";
+    this.toAssignable(node.argument, binding);
+  } else if (node.type === "AssignmentExpression") {
+    node.type = "AssignmentPattern";
+    delete node.operator;
+  } else {
+    return this.dummyIdent()
+  }
+  return node
+};
+
+lp.toAssignableList = function(exprList, binding) {
+  for (var i = 0, list = exprList; i < list.length; i += 1)
+    {
+    var expr = list[i];
+
+    this.toAssignable(expr, binding);
+  }
+  return exprList
+};
+
+lp.parseFunctionParams = function(params) {
+  params = this.parseExprList(types$1.parenR);
+  return this.toAssignableList(params, true)
+};
+
+lp.parseMethod = function(isGenerator, isAsync) {
+  var node = this.startNode(), oldInAsync = this.inAsync, oldInGenerator = this.inGenerator, oldInFunction = this.inFunction;
+  this.initFunction(node);
+  if (this.options.ecmaVersion >= 6)
+    { node.generator = !!isGenerator; }
+  if (this.options.ecmaVersion >= 8)
+    { node.async = !!isAsync; }
+  this.inAsync = node.async;
+  this.inGenerator = node.generator;
+  this.inFunction = true;
+  node.params = this.parseFunctionParams();
+  node.body = this.parseBlock();
+  this.toks.adaptDirectivePrologue(node.body.body);
+  this.inAsync = oldInAsync;
+  this.inGenerator = oldInGenerator;
+  this.inFunction = oldInFunction;
+  return this.finishNode(node, "FunctionExpression")
+};
+
+lp.parseArrowExpression = function(node, params, isAsync) {
+  var oldInAsync = this.inAsync, oldInGenerator = this.inGenerator, oldInFunction = this.inFunction;
+  this.initFunction(node);
+  if (this.options.ecmaVersion >= 8)
+    { node.async = !!isAsync; }
+  this.inAsync = node.async;
+  this.inGenerator = false;
+  this.inFunction = true;
+  node.params = this.toAssignableList(params, true);
+  node.expression = this.tok.type !== types$1.braceL;
+  if (node.expression) {
+    node.body = this.parseMaybeAssign();
+  } else {
+    node.body = this.parseBlock();
+    this.toks.adaptDirectivePrologue(node.body.body);
+  }
+  this.inAsync = oldInAsync;
+  this.inGenerator = oldInGenerator;
+  this.inFunction = oldInFunction;
+  return this.finishNode(node, "ArrowFunctionExpression")
+};
+
+lp.parseExprList = function(close, allowEmpty) {
+  this.pushCx();
+  var indent = this.curIndent, line = this.curLineStart, elts = [];
+  this.next(); // Opening bracket
+  while (!this.closes(close, indent + 1, line)) {
+    if (this.eat(types$1.comma)) {
+      elts.push(allowEmpty ? null : this.dummyIdent());
+      continue
+    }
+    var elt = this.parseMaybeAssign();
+    if (isDummy(elt)) {
+      if (this.closes(close, indent, line)) { break }
+      this.next();
+    } else {
+      elts.push(elt);
+    }
+    this.eat(types$1.comma);
+  }
+  this.popCx();
+  if (!this.eat(close)) {
+    // If there is no closing brace, make the node span to the start
+    // of the next token (this is useful for Tern)
+    this.last.end = this.tok.start;
+    if (this.options.locations) { this.last.loc.end = this.tok.loc.start; }
+  }
+  return elts
+};
+
+lp.parseAwait = function() {
+  var node = this.startNode();
+  this.next();
+  node.argument = this.parseMaybeUnary();
+  return this.finishNode(node, "AwaitExpression")
+};
+
+// Acorn: Loose parser
+//
+// This module provides an alternative parser that exposes that same
+// interface as the main module's `parse` function, but will try to
+// parse anything as JavaScript, repairing syntax error the best it
+// can. There are circumstances in which it will raise an error and
+// give up, but they are very rare. The resulting AST will be a mostly
+// valid JavaScript AST (as per the [ESTree spec][estree], except
+// that:
+//
+// - Return outside functions is allowed
+//
+// - Label consistency (no conflicts, break only to existing labels)
+//   is not enforced.
+//
+// - Bogus Identifier nodes with a name of `"✖"` are inserted whenever
+//   the parser got too confused to return anything meaningful.
+//
+// [estree]: https://github.com/estree/estree
+//
+// The expected use for this is to *first* try `acorn.parse`, and only
+// if that fails switch to the loose parser. The loose parser might
+// parse badly indented code incorrectly, so **don't** use it as your
+// default parser.
+//
+// Quite a lot of acorn.js is duplicated here. The alternative was to
+// add a *lot* of extra cruft to that file, making it less readable
+// and slower. Copying and editing the code allowed me to make
+// invasive changes and simplifications without creating a complicated
+// tangle.
+
+
+defaultOptions.tabSize = 4;
+
+function parse(input, options) {
+  return LooseParser.parse(input, options)
+}
+
 // AST walker module for ESTree compatible trees
 
 // A simple walk is one where you simply specify callbacks to be
@@ -35893,13 +37528,24 @@ base.MethodDefinition = base.PropertyDefinition = base.Property = function (node
 function getAcornParsedNodes(input) {
     var parsedNode = null;
     try {
-        parsedNode = parse(input, {
+        parsedNode = parse$1(input, {
             ecmaVersion: 'latest',
             sourceType: 'module',
             locations: true
         });
     }
-    catch (_a) { }
+    catch (_a) {
+        // attempt parse with more error-tolerant parser.
+        // handles rules with both shared code and top-level
+        // return, which is technically invalid syntax
+        try {
+            parsedNode = parse(input, {
+                ecmaVersion: 'latest',
+                locations: true
+            });
+        }
+        catch (_b) { }
+    }
     return parsedNode;
 }
 function extractReferencedIdentifiers(bodyNode) {
@@ -36043,8 +37689,10 @@ function extractJsElements(code) {
     var exportFunctions = [];
     var exportVariables = [];
     var parsedNodes = getAcornParsedNodes(code);
-    if (!parsedNodes)
+    if (!parsedNodes) {
+        console.warn('Failed to parse logic rule code');
         return { exportVariables: exportVariables, exportFunctions: exportFunctions };
+    }
     // Helper: turn a param node into its original text
     var paramText = function (p) { return code.slice(p.start, p.end); };
     // Helper: build function signature and body from FunctionExpression or ArrowFunctionExpression
@@ -38498,13 +40146,28 @@ function Form(_a) {
             }
         });
     }); };
+    var tableOnClick = function (table, payload) { return __awaiter$2(_this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, runElementActions({
+                        actions: [],
+                        element: table,
+                        elementType: 'table',
+                        triggerPayload: payload
+                    })];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); };
     // Orchestrates all actions triggered by a button/element click.
     // Runs validations and submission first (if submit=true), then executes click actions in order.
     // Prevents race conditions by locking element during execution and tracking global button state.
     // Some actions (Persona, Plaid, etc) require special handling: they pause execution and
     // provide a callback for continuing to the next action once they complete.
     var runElementActions = function (_a) {
-        var actions = _a.actions, element = _a.element, elementType = _a.elementType, _b = _a.submit, submit = _b === void 0 ? false : _b, _c = _a.setElementError, setElementError = _c === void 0 ? function () { } : _c, _d = _a.onAsyncEnd, onAsyncEnd = _d === void 0 ? function () { } : _d, textSpanStart = _a.textSpanStart, textSpanEnd = _a.textSpanEnd;
+        var actions = _a.actions, element = _a.element, elementType = _a.elementType, _b = _a.submit, submit = _b === void 0 ? false : _b, _c = _a.setElementError, setElementError = _c === void 0 ? function () { } : _c, _d = _a.onAsyncEnd, onAsyncEnd = _d === void 0 ? function () { } : _d, textSpanStart = _a.textSpanStart, textSpanEnd = _a.textSpanEnd, triggerPayload = _a.triggerPayload;
         return __awaiter$2(_this, void 0, void 0, function () {
             var id, metadata, trigger, submitPromise, pendingFileKeys, invalid, hasNext, submissionResult, error_3, _e, stepPromise, flowOnSuccess, actionTypes, runAction, i, hasExtractions, hasEnvelopeGeneration, _loop_1, state_1;
             var _this = this;
@@ -38528,7 +40191,7 @@ function Form(_a) {
                             start: textSpanStart,
                             end: textSpanEnd
                         };
-                        trigger = __assign(__assign({}, lookUpTrigger(activeStep, elementType === 'container' ? element.key : element.id, elementType)), { repeatIndex: element.repeat });
+                        trigger = __assign(__assign({}, lookUpTrigger(activeStep, elementType === 'container' ? element.key : element.id, elementType, triggerPayload)), { repeatIndex: element.repeat });
                         submitPromise = Promise.resolve();
                         if (!(submit && !readOnly)) return [3 /*break*/, 7];
                         // Do not proceed until user has gone through required flows
@@ -38629,7 +40292,8 @@ function Form(_a) {
                                                 setElementError: setElementError,
                                                 onAsyncEnd: onAsyncEnd,
                                                 textSpanStart: textSpanStart,
-                                                textSpanEnd: textSpanEnd
+                                                textSpanEnd: textSpanEnd,
+                                                triggerPayload: triggerPayload
                                             })];
                                     case 1:
                                         running = _a.sent();
@@ -39404,6 +41068,7 @@ function Form(_a) {
         customClickSelectionState: customClickSelectionState,
         runElementActions: runElementActions,
         buttonOnClick: buttonOnClick,
+        tableOnClick: tableOnClick,
         fieldOnChange: fieldOnChange,
         buttonLoaders: buttonLoaders,
         inlineErrors: inlineErrors,
@@ -42286,6 +43951,112 @@ function loadQRScanner() {
     qrPromise = dynamicImport(QR_SCANNER_LIB_URL);
 }
 
+/**
+ * Event queue for holding events before user interaction
+ */
+var EventQueue = /** @class */ (function () {
+    function EventQueue() {
+        this.queue = [];
+        this.isReplaying = false;
+    }
+    EventQueue.prototype.enqueue = function (eventData) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            _this.queue.push({
+                eventData: eventData,
+                timestamp: Date.now(),
+                resolve: resolve,
+                reject: reject
+            });
+        });
+    };
+    EventQueue.prototype.getAll = function () {
+        return this.queue;
+    };
+    EventQueue.prototype.clear = function () {
+        this.queue = [];
+    };
+    EventQueue.prototype.isEmpty = function () {
+        return this.queue.length === 0;
+    };
+    EventQueue.prototype.size = function () {
+        return this.queue.length;
+    };
+    EventQueue.prototype.isReplayingEvents = function () {
+        return this.isReplaying;
+    };
+    EventQueue.prototype.setReplayState = function (replaying) {
+        this.isReplaying = replaying;
+    };
+    /**
+     * Apply replay function to all queued events
+     * @param replayFn Function to call for each event
+     */
+    EventQueue.prototype.replayAll = function (replayFn) {
+        return __awaiter$2(this, void 0, void 0, function () {
+            var eventsToReplay, eventsToReplay_1, eventsToReplay_1_1, queuedEvent, result, error_1, e_1_1;
+            var e_1, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (this.isEmpty())
+                            return [2 /*return*/];
+                        this.setReplayState(true);
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, , 14, 15]);
+                        _b.label = 2;
+                    case 2:
+                        if (!!this.isEmpty()) return [3 /*break*/, 13];
+                        eventsToReplay = __spreadArray([], __read(this.queue), false);
+                        this.queue = [];
+                        _b.label = 3;
+                    case 3:
+                        _b.trys.push([3, 10, 11, 12]);
+                        eventsToReplay_1 = (e_1 = void 0, __values(eventsToReplay)), eventsToReplay_1_1 = eventsToReplay_1.next();
+                        _b.label = 4;
+                    case 4:
+                        if (!!eventsToReplay_1_1.done) return [3 /*break*/, 9];
+                        queuedEvent = eventsToReplay_1_1.value;
+                        _b.label = 5;
+                    case 5:
+                        _b.trys.push([5, 7, , 8]);
+                        return [4 /*yield*/, replayFn(queuedEvent.eventData)];
+                    case 6:
+                        result = _b.sent();
+                        queuedEvent.resolve(result);
+                        return [3 /*break*/, 8];
+                    case 7:
+                        error_1 = _b.sent();
+                        queuedEvent.reject(error_1);
+                        return [3 /*break*/, 8];
+                    case 8:
+                        eventsToReplay_1_1 = eventsToReplay_1.next();
+                        return [3 /*break*/, 4];
+                    case 9: return [3 /*break*/, 12];
+                    case 10:
+                        e_1_1 = _b.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 12];
+                    case 11:
+                        try {
+                            if (eventsToReplay_1_1 && !eventsToReplay_1_1.done && (_a = eventsToReplay_1.return)) _a.call(eventsToReplay_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                        return [7 /*endfinally*/];
+                    case 12: return [3 /*break*/, 2];
+                    case 13: return [3 /*break*/, 15];
+                    case 14:
+                        this.setReplayState(false);
+                        return [7 /*endfinally*/];
+                    case 15: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return EventQueue;
+}());
+
 var API_URL_OPTIONS = {
     local: 'http://localhost:8006/api/',
     staging: 'https://staging.feathery.io/api/',
@@ -42360,6 +44131,10 @@ var FeatheryClient = /** @class */ (function (_super) {
         var _this = this;
         var _a, _b;
         _this = _super.call(this, formKey, ignoreNetworkErrors, draft, bypassCDN) || this;
+        /**
+         * Queue for events triggered before user interaction
+         */
+        _this.userEventQueue = new EventQueue();
         /**
          * `beforeunload` event handler that flushes the pending submit custom changes
          * when a user is attempting to exit the page.
@@ -42395,8 +44170,39 @@ var FeatheryClient = /** @class */ (function (_super) {
         var _a, _b;
         return __awaiter$2(this, void 0, void 0, function () {
             return __generator(this, function (_c) {
-                (_b = (_a = featheryWindow()).removeEventListener) === null || _b === void 0 ? void 0 : _b.call(_a, FEATHERY_INTERACTION_EVENT, this.handleInteraction);
-                return [2 /*return*/, this.submitCustom({}, { shouldFlush: true })];
+                switch (_c.label) {
+                    case 0:
+                        (_b = (_a = featheryWindow()).removeEventListener) === null || _b === void 0 ? void 0 : _b.call(_a, FEATHERY_INTERACTION_EVENT, this.handleInteraction);
+                        // replay queued events, then flush fields
+                        return [4 /*yield*/, this.replayQueuedEvents()];
+                    case 1:
+                        // replay queued events, then flush fields
+                        _c.sent();
+                        return [4 /*yield*/, this.submitCustom({}, { shouldFlush: true })];
+                    case 2:
+                        _c.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    FeatheryClient.prototype.replayQueuedEvents = function () {
+        return __awaiter$2(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.userEventQueue.isEmpty())
+                            return [2 /*return*/];
+                        return [4 /*yield*/, this.userEventQueue.replayAll(function (eventData) { return __awaiter$2(_this, void 0, void 0, function () {
+                                return __generator(this, function (_a) {
+                                    return [2 /*return*/, this._registerEventInternal(eventData)];
+                                });
+                            }); })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
             });
         });
     };
@@ -43087,15 +44893,24 @@ var FeatheryClient = /** @class */ (function (_super) {
         });
     };
     FeatheryClient.prototype.registerEvent = function (eventData) {
+        return __awaiter$2(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (this.draft)
+                    return [2 /*return*/];
+                if (!isInteractionDetected() || this.userEventQueue.isReplayingEvents()) {
+                    return [2 /*return*/, this.userEventQueue.enqueue(eventData)];
+                }
+                return [2 /*return*/, this._registerEventInternal(eventData)];
+            });
+        });
+    };
+    FeatheryClient.prototype._registerEventInternal = function (eventData) {
         return __awaiter$2(this, void 0, void 0, function () {
             var _a, userId, collaboratorId, url, data, options, prom, stepKey, triggerEvent, eventPromise;
             var _this = this;
             return __generator(this, function (_b) {
                 switch (_b.label) {
-                    case 0:
-                        if (this.draft)
-                            return [2 /*return*/];
-                        return [4 /*yield*/, initFormsPromise];
+                    case 0: return [4 /*yield*/, initFormsPromise];
                     case 1:
                         _b.sent();
                         _a = initInfo(), userId = _a.userId, collaboratorId = _a.collaboratorId;
@@ -43607,9 +45422,9 @@ function init(sdkKey, options) {
     if (runningInClient()) {
         // Dynamically load libraries that must be client side
         global.scriptjsLoadPromise = import(
-        /* webpackChunkName: "scriptjs" */ './fthry_script.B1ROwso4.js').then(function (n) { return n.s; });
+        /* webpackChunkName: "scriptjs" */ './fthry_script.C5O1ZNQQ.js').then(function (n) { return n.s; });
         global.webfontloaderPromise = import(
-        /* webpackChunkName: "webfontloader" */ './fthry_webfontloader.ChgT0Ifr.js').then(function (n) { return n.w; });
+        /* webpackChunkName: "webfontloader" */ './fthry_webfontloader.DAANkO2-.js').then(function (n) { return n.w; });
         // Client-side tracking logic
         if (initState.userTracking === 'cookie') {
             var cookieKey = "feathery-user-id-".concat(sdkKey);
@@ -43755,7 +45570,7 @@ function getFieldValues() {
     return __assign({}, fieldValues);
 }
 function logFeatheryBadge() {
-    console.log('%c Feathery %c v' + "2.14.0" + ' ', // replaced with real version during build
+    console.log('%c Feathery %c v' + "2.15.1" + ' ', // replaced with real version during build
     'background: #e2626e; color: white; padding: 2px 6px; border-radius: 3px 0 0 3px; font-weight: bold;', 'background: #fce7e9; color: #c5495a; padding: 2px 6px; border-radius: 0 3px 3px 0;');
 }
 
@@ -43791,9 +45606,10 @@ var getABVariant = function (stepRes) {
     return stepRes;
 };
 var getAllElements = function (step) {
-    return __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], __read(step.progress_bars.map(function (e) { return [e, 'progress_bar']; })), false), __read(step.images.map(function (e) { return [e, 'image']; })), false), __read(step.videos.map(function (e) { return [e, 'video']; })), false), __read(step.texts.map(function (e) { return [e, 'text']; })), false), __read(step.buttons.map(function (e) { return [e, 'button']; })), false), __read(step.servar_fields.map(function (e) { return [e, 'field']; })), false), __read(step.subgrids.map(function (e) { return [e, 'subgrid']; })), false);
+    var _a, _b;
+    return __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], __read(step.progress_bars.map(function (e) { return [e, 'progress_bar']; })), false), __read(step.images.map(function (e) { return [e, 'image']; })), false), __read(step.videos.map(function (e) { return [e, 'video']; })), false), __read(((_b = (_a = step.tables) === null || _a === void 0 ? void 0 : _a.map(function (e) { return [e, 'table']; })) !== null && _b !== void 0 ? _b : [])), false), __read(step.texts.map(function (e) { return [e, 'text']; })), false), __read(step.buttons.map(function (e) { return [e, 'button']; })), false), __read(step.servar_fields.map(function (e) { return [e, 'field']; })), false), __read(step.subgrids.map(function (e) { return [e, 'subgrid']; })), false);
 };
-var lookUpTrigger = function (step, elementID, type) {
+var lookUpTrigger = function (step, elementID, type, additionalPayload) {
     var _a, _b;
     var payload = {};
     if (type === 'button') {
@@ -43813,7 +45629,12 @@ var lookUpTrigger = function (step, elementID, type) {
             text: element.servar.name
         };
     }
-    return __assign({ id: elementID, type: type }, payload);
+    else if (type === 'table') {
+        // For tables, we don't look up additional properties from the step
+        // All table-specific data is provided via additionalPayload
+        payload = {};
+    }
+    return __assign(__assign({ id: elementID, type: type }, payload), additionalPayload);
 };
 /** Update the fieldValues cache with a backend session */
 function updateSessionValues(session) {
@@ -45227,39 +47048,39 @@ breakpoint) {
     return styles.getTarget('inner-container', undefined, viewport === 'mobile');
 };
 
-var AddressLine1 = lazy(function () { return import(/* webpackChunkName: "AddressField" */ './fthry_index.DtttVU-B.js'); });
-var ButtonGroupField = lazy(function () { return import(/* webpackChunkName: "ButtonGroupField" */ './fthry_index.BE1aEx2n.js'); });
-var CheckboxField = lazy(function () { return import(/* webpackChunkName: "CheckboxField" */ './fthry_index.BpsK3TYO.js'); });
+var AddressLine1 = lazy(function () { return import(/* webpackChunkName: "AddressField" */ './fthry_index.BEZmvsoo.js'); });
+var ButtonGroupField = lazy(function () { return import(/* webpackChunkName: "ButtonGroupField" */ './fthry_index.m7CZv4YY.js'); });
+var CheckboxField = lazy(function () { return import(/* webpackChunkName: "CheckboxField" */ './fthry_index.Dy4nSWZa.js'); });
 var CheckboxGroupField = lazy(function () {
-    return import(/* webpackChunkName: "CheckboxGroupField" */ './fthry_index.BKbx2qxD.js');
+    return import(/* webpackChunkName: "CheckboxGroupField" */ './fthry_index.t4v0qqgv.js');
 });
-var ColorPickerField = lazy(function () { return import(/* webpackChunkName: "ColorPickerField" */ './fthry_index.DEU7NBKU.js'); });
-var CustomField = lazy(function () { return import(/* webpackChunkName: "CustomField" */ './fthry_index.CzHuSmWc.js'); });
+var ColorPickerField = lazy(function () { return import(/* webpackChunkName: "ColorPickerField" */ './fthry_index.D9VjMJ_U.js'); });
+var CustomField = lazy(function () { return import(/* webpackChunkName: "CustomField" */ './fthry_index.Bz07r-AM.js'); });
 var DateSelectorField = lazy(function () {
-    return import(/* webpackChunkName: "DateSelectorField" */ './fthry_index.RwhYSoEm.js');
+    return import(/* webpackChunkName: "DateSelectorField" */ './fthry_index.NOuMR_hq.js');
 });
-var DropdownField = lazy(function () { return import(/* webpackChunkName: "DropdownField" */ './fthry_index.DsHJmYgu.js'); });
+var DropdownField = lazy(function () { return import(/* webpackChunkName: "DropdownField" */ './fthry_index.B7VWXvgC.js'); });
 var DropdownMultiField = lazy(function () {
-    return import(/* webpackChunkName: "DropdownMultiField" */ './fthry_index.g8xB96Yo.js');
+    return import(/* webpackChunkName: "DropdownMultiField" */ './fthry_index.DhU16s57.js');
 });
-var FileUploadField = lazy(function () { return import(/* webpackChunkName: "FileUploadField" */ './fthry_index.DQuVxHkp.js'); });
-var MatrixField = lazy(function () { return import(/* webpackChunkName: "MatrixField" */ './fthry_index.Cfn3D1XZ.js'); });
-var PasswordField = lazy(function () { return import(/* webpackChunkName: "PasswordField" */ './fthry_index.Be8xdrui.js'); });
+var FileUploadField = lazy(function () { return import(/* webpackChunkName: "FileUploadField" */ './fthry_index.B84L3MVC.js'); });
+var MatrixField = lazy(function () { return import(/* webpackChunkName: "MatrixField" */ './fthry_index.DH2fsNWG.js'); });
+var PasswordField = lazy(function () { return import(/* webpackChunkName: "PasswordField" */ './fthry_index.Fs86Fy9Y.js'); });
 var PaymentMethodField = lazy(function () {
-    return import(/* webpackChunkName: "PaymentMethodField" */ './fthry_PaymentMethodField.PRJIHswh.js');
+    return import(/* webpackChunkName: "PaymentMethodField" */ './fthry_PaymentMethodField.BpA_xhqt.js');
 });
-var PhoneField = lazy(function () { return import(/* webpackChunkName: "PhoneField" */ './fthry_index.sXNItbKY.js'); });
-var PinInputField = lazy(function () { return import(/* webpackChunkName: "PinInputField" */ './fthry_index.DMTSFPNS.js'); });
-var QRScanner = lazy(function () { return import(/* webpackChunkName: "QRScanner" */ './fthry_index.DQhKI62v.js'); });
+var PhoneField = lazy(function () { return import(/* webpackChunkName: "PhoneField" */ './fthry_index.BsNCOSBE.js'); });
+var PinInputField = lazy(function () { return import(/* webpackChunkName: "PinInputField" */ './fthry_index.D9AKkBzu.js'); });
+var QRScanner = lazy(function () { return import(/* webpackChunkName: "QRScanner" */ './fthry_index.B-oHlMGi.js'); });
 var RadioButtonGroupField = lazy(function () {
     return import(
-    /* webpackChunkName: "RadioButtonGroupField" */ './fthry_index.CxH24rcl.js');
+    /* webpackChunkName: "RadioButtonGroupField" */ './fthry_index.Dgmpm9wy.js');
 });
-var RatingField = lazy(function () { return import(/* webpackChunkName: "RatingField" */ './fthry_index.Dd5mpmpk.js'); });
-var SignatureField = lazy(function () { return import(/* webpackChunkName: "SignatureField" */ './fthry_index.Df-7wyL2.js'); });
-var SliderField = lazy(function () { return import(/* webpackChunkName: "SliderField" */ './fthry_index.D6sWBKuA.js'); });
-var TextField = lazy(function () { return import(/* webpackChunkName: "TextField" */ './fthry_index.BdbDXIuj.js'); });
-var TextArea = lazy(function () { return import(/* webpackChunkName: "TextArea" */ './fthry_index.DgIPpVNk.js'); });
+var RatingField = lazy(function () { return import(/* webpackChunkName: "RatingField" */ './fthry_index.DoP7RwIP.js'); });
+var SignatureField = lazy(function () { return import(/* webpackChunkName: "SignatureField" */ './fthry_index.CJKGRCG-.js'); });
+var SliderField = lazy(function () { return import(/* webpackChunkName: "SliderField" */ './fthry_index.BSEfDQAc.js'); });
+var TextField = lazy(function () { return import(/* webpackChunkName: "TextField" */ './fthry_index.BsEfTy-x.js'); });
+var TextArea = lazy(function () { return import(/* webpackChunkName: "TextArea" */ './fthry_index.BzrcCLzO.js'); });
 var Fields = {
     AddressLine1: AddressLine1,
     ButtonGroupField: ButtonGroupField,
@@ -45299,7 +47120,7 @@ var defaultBorderFields = [
     'file_upload'
 ];
 var DROPDOWN_Z_INDEX = 10;
-function applyFieldStyles$1(field, styles) {
+function applyFieldStyles(field, styles) {
     var type = field.servar.type;
     styles.addTargets('fc', 'sub-fc', 'field', 'error', 'active', 'hover', 'disabled', 'tooltipIcon');
     // For these fields, selector font colors
@@ -45634,7 +47455,7 @@ Object.entries(Fields).map(function (_a) {
                 whiteSpace: 'pre-wrap',
                 overflowWrap: 'anywhere'
             } }, { children: servar.name }))) : null;
-        var styles = useMemo(function () { return applyFieldStyles$1(element, responsiveStyles); }, [element]);
+        var styles = useMemo(function () { return applyFieldStyles(element, responsiveStyles); }, [element]);
         return (jsx$1(Field, __assign({ element: element, fieldLabel: fieldLabel, responsiveStyles: styles }, props)));
     });
 });
@@ -46028,7 +47849,7 @@ function ProgressBarElement(_a) {
     var element = _a.element, responsiveStyles = _a.responsiveStyles, progress = _a.progress, _d = _a.curDepth, curDepth = _d === void 0 ? 1 : _d, _e = _a.maxDepth, maxDepth = _e === void 0 ? 1 : _e, _f = _a.elementProps, elementProps = _f === void 0 ? {} : _f, children = _a.children;
     var styles = useMemo(function () { return applyProgressBarStyles(responsiveStyles); }, [responsiveStyles]);
     var userProgress, userSegments;
-    if (progress) {
+    if (![null, undefined].includes(progress)) {
         if (typeof progress === 'number') {
             userProgress = progress;
         }
@@ -46061,7 +47882,8 @@ var shimmerFields = [
     'select',
     'button_group',
     'slider',
-    'rating'
+    'rating',
+    'table_element'
 ];
 var shimmer = keyframes$1(templateObject_1 || (templateObject_1 = __makeTemplateObject(["\n  100% {\n    transform: translateX(100%);\n  }\n"], ["\n  100% {\n    transform: translateX(100%);\n  }\n"])));
 var shimmerStyles = {
@@ -46080,8 +47902,8 @@ var shimmerStyles = {
         animation: "".concat(shimmer, " 5s infinite")
     }
 };
-function applyFieldStyles(field, styles) {
-    var type = field.servar.type;
+function applyStyles(element, styles) {
+    var type = element._type;
     styles.addTargets('fc', 'sub-fc', 'field');
     styles.applyFontStyles('fc', false, true);
     switch (type) {
@@ -46153,11 +47975,11 @@ function applyFieldStyles(field, styles) {
     }
     return styles;
 }
-function FieldSkeleton(_a) {
+function ElementSkeleton(_a) {
     var _b, _c, _d;
     var responsiveStyles = _a.responsiveStyles, element = _a.element;
-    var type = element.servar.type;
-    var styles = useMemo(function () { return applyFieldStyles(element, responsiveStyles); }, [element, responsiveStyles]);
+    var type = element._type;
+    var styles = useMemo(function () { return applyStyles(element, responsiveStyles); }, [element, responsiveStyles]);
     var renderPinInput = function () {
         var maxLength = element.servar.max_length || 6;
         var pinDivs = [];
@@ -46181,6 +48003,15 @@ function FieldSkeleton(_a) {
     else if (type === 'qr_scanner') {
         heightAdjust.height = '166px'; // hardcode qr scanner height
     }
+    if (!element.servar) {
+        return (jsx$1("div", __assign({ css: {
+                maxWidth: '100%',
+                width: '100%',
+                height: '100%',
+                position: 'relative',
+                boxSizing: 'border-box'
+            } }, { children: jsx$1("div", { css: __assign(__assign({ width: '100%', boxSizing: 'border-box' }, heightAdjust), shimmerStyles) }) })));
+    }
     return (jsx$1("div", __assign({ css: __assign({ maxWidth: '100%', width: '100%', height: '100%', position: 'relative', boxSizing: 'border-box' }, styles.getTarget('fc')) }, { children: type === 'pin_input' ? (jsx$1("div", __assign({ css: {
                 display: 'flex',
                 alignItems: 'center',
@@ -46189,12 +48020,14 @@ function FieldSkeleton(_a) {
 }
 var templateObject_1;
 
+var TableElement = lazy(function () { return import(/* webpackChunkName: "TableElement" */ './fthry_index.BAhh3Pz6.js'); });
 var Basic = {
     ImageElement: ImageElement,
     VideoElement: VideoElement,
     TextElement: TextElement,
     ButtonElement: ButtonElement,
-    ProgressBarElement: ProgressBarElement
+    ProgressBarElement: ProgressBarElement,
+    TableElement: TableElement
 };
 var Elements = __assign(__assign({}, Basic), Fields);
 Object.entries(Elements).map(function (_a) {
@@ -46205,7 +48038,7 @@ Object.entries(Elements).map(function (_a) {
         var responsiveStyles = useMemo(function () {
             return new ResponsiveStyles(element, ['container'], !componentOnly, formSettings === null || formSettings === void 0 ? void 0 : formSettings.mobileBreakpoint);
         }, [element, componentOnly, formSettings]);
-        var featheryElement = (jsx$1(Suspense, __assign({ fallback: jsx$1(FieldSkeleton, { element: element, responsiveStyles: responsiveStyles }) }, { children: jsx$1(Element, __assign({ element: element, responsiveStyles: responsiveStyles }, props)) })));
+        var featheryElement = (jsx$1(Suspense, __assign({ fallback: jsx$1(ElementSkeleton, { element: element, responsiveStyles: responsiveStyles }) }, { children: jsx$1(Element, __assign({ element: element, responsiveStyles: responsiveStyles }, props)) })));
         var e = onView ? (jsx$1(InView, __assign({ onChange: onView }, { children: featheryElement }))) : (featheryElement);
         if (componentOnly) {
             return (jsxs(Fragment, { children: [children, e] }));
@@ -46484,4 +48317,4 @@ var Feathery = {
     renderAt: renderAt
 };
 
-export { peek as $, middleware as A, combine as B, COMMENT as C, DROPDOWN_Z_INDEX as D, ErrorInput as E, FeatheryClient as F, Global as G, match as H, serialize as I, copy as J, replace as K, MS as L, MOZ as M, KEYFRAMES as N, DECLARATION as O, dealloc as P, alloc as Q, RULESET as R, hash as S, charat as T, strlen as U, indexof as V, WEBKIT as W, next as X, token as Y, from as Z, __read as _, __assign as a, delimit as a0, slice as a1, position as a2, compile as a3, __spreadArray as a4, __values as a5, isEmptyArray as a6, toList as a7, useThumbnailData as a8, downloadFile as a9, setFieldValues as aA, getFieldValues as aB, renderAt as aC, LoginForm as aD, useAuthClient as aE, Feathery as aF, StyledContainer as aG, CloseIcon as aa, justRemove as ab, getStripe as ac, filterKeys as ad, ERROR_COLOR as ae, authState as af, firebaseSMSCountries as ag, phoneLibPromise as ah, isNum as ai, loadQRScanner as aj, throttle as ak, qrPromise as al, devicePixelRatio as am, toBase64 as an, MODAL_Z_INDEX as ao, dataURLToFile as ap, cls as aq, getFieldValue$1 as ar, stringifyWithNull as as, emailPatternStr as at, replaceTextVariables as au, ReactForm as av, Elements as aw, init as ax, updateUserId as ay, updateTheme as az, jsx$1 as b, __awaiter$2 as c, __generator as d, debounce as e, imgMaxSizeStyles as f, getDefaultExportFromCjs as g, hoverStylesGuard as h, iosScrollOnFocus as i, jsxs as j, FORM_Z_INDEX as k, featheryWindow as l, Fragment as m, noTextSelectStyles as n, css as o, __makeTemplateObject as p, isMobile as q, resetStyles as r, featheryDoc as s, __rest$1 as t, useBorder as u, formatDateString as v, countryData as w, fieldValues as x, stringify$2 as y, rulesheet as z };
+export { next as $, countryData as A, stringify$2 as B, rulesheet as C, DROPDOWN_Z_INDEX as D, ErrorInput as E, Fragment as F, Global as G, COMMENT as H, middleware as I, combine as J, match as K, serialize as L, copy as M, replace as N, MOZ as O, MS as P, KEYFRAMES as Q, RULESET as R, DECLARATION as S, dealloc as T, alloc as U, hash as V, WEBKIT as W, charat as X, strlen as Y, indexof as Z, __assign as _, jsxs as a, token as a0, from as a1, peek as a2, delimit as a3, slice as a4, position as a5, compile as a6, isEmptyArray as a7, toList as a8, useThumbnailData as a9, setFieldValues as aA, getFieldValues as aB, renderAt as aC, LoginForm as aD, useAuthClient as aE, Feathery as aF, StyledContainer as aG, downloadFile as aa, CloseIcon as ab, justRemove as ac, getStripe as ad, filterKeys as ae, ERROR_COLOR as af, authState as ag, firebaseSMSCountries as ah, phoneLibPromise as ai, isNum as aj, loadQRScanner as ak, throttle as al, qrPromise as am, devicePixelRatio as an, toBase64 as ao, MODAL_Z_INDEX as ap, dataURLToFile as aq, cls as ar, getFieldValue$1 as as, emailPatternStr as at, replaceTextVariables as au, ReactForm as av, Elements as aw, init as ax, updateUserId as ay, updateTheme as az, __read as b, fieldValues as c, __values as d, __spreadArray as e, featheryDoc as f, getDefaultExportFromCjs as g, hoverStylesGuard as h, iosScrollOnFocus as i, jsx$1 as j, __awaiter$2 as k, __generator as l, FeatheryClient as m, debounce as n, imgMaxSizeStyles as o, noTextSelectStyles as p, FORM_Z_INDEX as q, resetStyles as r, stringifyWithNull as s, featheryWindow as t, useBorder as u, css as v, __makeTemplateObject as w, isMobile as x, __rest$1 as y, formatDateString as z };