@uipath/flow-tool 1.199.0-preview.104 → 1.199.0-preview.106

package/dist/tool.js

@@ -176967,1540 +176967,6 @@ var init_zh_TW_PHOEUN3F = __esm(() => {
   };
 });
 
-// ../../node_modules/sax/lib/sax.js
-var require_sax = __commonJS((exports) => {
-  (function(sax) {
-    sax.parser = function(strict, opt) {
-      return new SAXParser(strict, opt);
-    };
-    sax.SAXParser = SAXParser;
-    sax.SAXStream = SAXStream;
-    sax.createStream = createStream;
-    sax.MAX_BUFFER_LENGTH = 64 * 1024;
-    var buffers = [
-      "comment",
-      "sgmlDecl",
-      "textNode",
-      "tagName",
-      "doctype",
-      "procInstName",
-      "procInstBody",
-      "entity",
-      "attribName",
-      "attribValue",
-      "cdata",
-      "script"
-    ];
-    sax.EVENTS = [
-      "text",
-      "processinginstruction",
-      "sgmldeclaration",
-      "doctype",
-      "comment",
-      "opentagstart",
-      "attribute",
-      "opentag",
-      "closetag",
-      "opencdata",
-      "cdata",
-      "closecdata",
-      "error",
-      "end",
-      "ready",
-      "script",
-      "opennamespace",
-      "closenamespace"
-    ];
-    function SAXParser(strict, opt) {
-      if (!(this instanceof SAXParser)) {
-        return new SAXParser(strict, opt);
-      }
-      var parser = this;
-      clearBuffers(parser);
-      parser.q = parser.c = "";
-      parser.bufferCheckPosition = sax.MAX_BUFFER_LENGTH;
-      parser.encoding = null;
-      parser.opt = opt || {};
-      parser.opt.lowercase = parser.opt.lowercase || parser.opt.lowercasetags;
-      parser.looseCase = parser.opt.lowercase ? "toLowerCase" : "toUpperCase";
-      parser.opt.maxEntityCount = parser.opt.maxEntityCount || 512;
-      parser.opt.maxEntityDepth = parser.opt.maxEntityDepth || 4;
-      parser.entityCount = parser.entityDepth = 0;
-      parser.tags = [];
-      parser.closed = parser.closedRoot = parser.sawRoot = false;
-      parser.tag = parser.error = null;
-      parser.strict = !!strict;
-      parser.noscript = !!(strict || parser.opt.noscript);
-      parser.state = S2.BEGIN;
-      parser.strictEntities = parser.opt.strictEntities;
-      parser.ENTITIES = parser.strictEntities ? Object.create(sax.XML_ENTITIES) : Object.create(sax.ENTITIES);
-      parser.attribList = [];
-      if (parser.opt.xmlns) {
-        parser.ns = Object.create(rootNS);
-      }
-      if (parser.opt.unquotedAttributeValues === undefined) {
-        parser.opt.unquotedAttributeValues = !strict;
-      }
-      parser.trackPosition = parser.opt.position !== false;
-      if (parser.trackPosition) {
-        parser.position = parser.line = parser.column = 0;
-      }
-      emit(parser, "onready");
-    }
-    if (!Object.create) {
-      Object.create = function(o2) {
-        function F2() {}
-        F2.prototype = o2;
-        var newf = new F2;
-        return newf;
-      };
-    }
-    if (!Object.keys) {
-      Object.keys = function(o2) {
-        var a2 = [];
-        for (var i3 in o2)
-          if (o2.hasOwnProperty(i3))
-            a2.push(i3);
-        return a2;
-      };
-    }
-    function checkBufferLength(parser) {
-      var maxAllowed = Math.max(sax.MAX_BUFFER_LENGTH, 10);
-      var maxActual = 0;
-      for (var i3 = 0, l2 = buffers.length;i3 < l2; i3++) {
-        var len = parser[buffers[i3]].length;
-        if (len > maxAllowed) {
-          switch (buffers[i3]) {
-            case "textNode":
-              closeText(parser);
-              break;
-            case "cdata":
-              emitNode(parser, "oncdata", parser.cdata);
-              parser.cdata = "";
-              break;
-            case "script":
-              emitNode(parser, "onscript", parser.script);
-              parser.script = "";
-              break;
-            default:
-              error95(parser, "Max buffer length exceeded: " + buffers[i3]);
-          }
-        }
-        maxActual = Math.max(maxActual, len);
-      }
-      var m2 = sax.MAX_BUFFER_LENGTH - maxActual;
-      parser.bufferCheckPosition = m2 + parser.position;
-    }
-    function clearBuffers(parser) {
-      for (var i3 = 0, l2 = buffers.length;i3 < l2; i3++) {
-        parser[buffers[i3]] = "";
-      }
-    }
-    function flushBuffers(parser) {
-      closeText(parser);
-      if (parser.cdata !== "") {
-        emitNode(parser, "oncdata", parser.cdata);
-        parser.cdata = "";
-      }
-      if (parser.script !== "") {
-        emitNode(parser, "onscript", parser.script);
-        parser.script = "";
-      }
-    }
-    SAXParser.prototype = {
-      end: function() {
-        end(this);
-      },
-      write,
-      resume: function() {
-        this.error = null;
-        return this;
-      },
-      close: function() {
-        return this.write(null);
-      },
-      flush: function() {
-        flushBuffers(this);
-      }
-    };
-    var Stream;
-    try {
-      Stream = __require("stream").Stream;
-    } catch (ex) {
-      Stream = function() {};
-    }
-    if (!Stream)
-      Stream = function() {};
-    var streamWraps = sax.EVENTS.filter(function(ev) {
-      return ev !== "error" && ev !== "end";
-    });
-    function createStream(strict, opt) {
-      return new SAXStream(strict, opt);
-    }
-    function determineBufferEncoding(data, isEnd) {
-      if (data.length >= 2) {
-        if (data[0] === 255 && data[1] === 254) {
-          return "utf-16le";
-        }
-        if (data[0] === 254 && data[1] === 255) {
-          return "utf-16be";
-        }
-      }
-      if (data.length >= 3 && data[0] === 239 && data[1] === 187 && data[2] === 191) {
-        return "utf8";
-      }
-      if (data.length >= 4) {
-        if (data[0] === 60 && data[1] === 0 && data[2] === 63 && data[3] === 0) {
-          return "utf-16le";
-        }
-        if (data[0] === 0 && data[1] === 60 && data[2] === 0 && data[3] === 63) {
-          return "utf-16be";
-        }
-        return "utf8";
-      }
-      return isEnd ? "utf8" : null;
-    }
-    function SAXStream(strict, opt) {
-      if (!(this instanceof SAXStream)) {
-        return new SAXStream(strict, opt);
-      }
-      Stream.apply(this);
-      this._parser = new SAXParser(strict, opt);
-      this.writable = true;
-      this.readable = true;
-      var me2 = this;
-      this._parser.onend = function() {
-        me2.emit("end");
-      };
-      this._parser.onerror = function(er2) {
-        me2.emit("error", er2);
-        me2._parser.error = null;
-      };
-      this._decoder = null;
-      this._decoderBuffer = null;
-      streamWraps.forEach(function(ev) {
-        Object.defineProperty(me2, "on" + ev, {
-          get: function() {
-            return me2._parser["on" + ev];
-          },
-          set: function(h2) {
-            if (!h2) {
-              me2.removeAllListeners(ev);
-              me2._parser["on" + ev] = h2;
-              return h2;
-            }
-            me2.on(ev, h2);
-          },
-          enumerable: true,
-          configurable: false
-        });
-      });
-    }
-    SAXStream.prototype = Object.create(Stream.prototype, {
-      constructor: {
-        value: SAXStream
-      }
-    });
-    SAXStream.prototype._decodeBuffer = function(data, isEnd) {
-      if (this._decoderBuffer) {
-        data = Buffer.concat([this._decoderBuffer, data]);
-        this._decoderBuffer = null;
-      }
-      if (!this._decoder) {
-        var encoding = determineBufferEncoding(data, isEnd);
-        if (!encoding) {
-          this._decoderBuffer = data;
-          return "";
-        }
-        this._parser.encoding = encoding;
-        this._decoder = new TextDecoder(encoding);
-      }
-      return this._decoder.decode(data, { stream: !isEnd });
-    };
-    SAXStream.prototype.write = function(data) {
-      if (typeof Buffer === "function" && typeof Buffer.isBuffer === "function" && Buffer.isBuffer(data)) {
-        data = this._decodeBuffer(data, false);
-      } else if (this._decoderBuffer) {
-        var remaining = this._decodeBuffer(Buffer.alloc(0), true);
-        if (remaining) {
-          this._parser.write(remaining);
-          this.emit("data", remaining);
-        }
-      }
-      this._parser.write(data.toString());
-      this.emit("data", data);
-      return true;
-    };
-    SAXStream.prototype.end = function(chunk) {
-      if (chunk && chunk.length) {
-        this.write(chunk);
-      }
-      if (this._decoderBuffer) {
-        var finalChunk = this._decodeBuffer(Buffer.alloc(0), true);
-        if (finalChunk) {
-          this._parser.write(finalChunk);
-          this.emit("data", finalChunk);
-        }
-      } else if (this._decoder) {
-        var remaining = this._decoder.decode();
-        if (remaining) {
-          this._parser.write(remaining);
-          this.emit("data", remaining);
-        }
-      }
-      this._parser.end();
-      return true;
-    };
-    SAXStream.prototype.on = function(ev, handler) {
-      var me2 = this;
-      if (!me2._parser["on" + ev] && streamWraps.indexOf(ev) !== -1) {
-        me2._parser["on" + ev] = function() {
-          var args = arguments.length === 1 ? [arguments[0]] : Array.apply(null, arguments);
-          args.splice(0, 0, ev);
-          me2.emit.apply(me2, args);
-        };
-      }
-      return Stream.prototype.on.call(me2, ev, handler);
-    };
-    var CDATA = "[CDATA[";
-    var DOCTYPE = "DOCTYPE";
-    var XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace";
-    var XMLNS_NAMESPACE = "http://www.w3.org/2000/xmlns/";
-    var rootNS = { xml: XML_NAMESPACE, xmlns: XMLNS_NAMESPACE };
-    var nameStart = /[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/;
-    var nameBody = /[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040.\d-]/;
-    var entityStart = /[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/;
-    var entityBody = /[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040.\d-]/;
-    function isWhitespace(c2) {
-      return c2 === " " || c2 === `
-` || c2 === "\r" || c2 === "\t";
-    }
-    function isQuote(c2) {
-      return c2 === '"' || c2 === "'";
-    }
-    function isAttribEnd(c2) {
-      return c2 === ">" || isWhitespace(c2);
-    }
-    function isMatch(regex, c2) {
-      return regex.test(c2);
-    }
-    function notMatch(regex, c2) {
-      return !isMatch(regex, c2);
-    }
-    var S2 = 0;
-    sax.STATE = {
-      BEGIN: S2++,
-      BEGIN_WHITESPACE: S2++,
-      TEXT: S2++,
-      TEXT_ENTITY: S2++,
-      OPEN_WAKA: S2++,
-      SGML_DECL: S2++,
-      SGML_DECL_QUOTED: S2++,
-      DOCTYPE: S2++,
-      DOCTYPE_QUOTED: S2++,
-      DOCTYPE_DTD: S2++,
-      DOCTYPE_DTD_QUOTED: S2++,
-      COMMENT_STARTING: S2++,
-      COMMENT: S2++,
-      COMMENT_ENDING: S2++,
-      COMMENT_ENDED: S2++,
-      CDATA: S2++,
-      CDATA_ENDING: S2++,
-      CDATA_ENDING_2: S2++,
-      PROC_INST: S2++,
-      PROC_INST_BODY: S2++,
-      PROC_INST_ENDING: S2++,
-      OPEN_TAG: S2++,
-      OPEN_TAG_SLASH: S2++,
-      ATTRIB: S2++,
-      ATTRIB_NAME: S2++,
-      ATTRIB_NAME_SAW_WHITE: S2++,
-      ATTRIB_VALUE: S2++,
-      ATTRIB_VALUE_QUOTED: S2++,
-      ATTRIB_VALUE_CLOSED: S2++,
-      ATTRIB_VALUE_UNQUOTED: S2++,
-      ATTRIB_VALUE_ENTITY_Q: S2++,
-      ATTRIB_VALUE_ENTITY_U: S2++,
-      CLOSE_TAG: S2++,
-      CLOSE_TAG_SAW_WHITE: S2++,
-      SCRIPT: S2++,
-      SCRIPT_ENDING: S2++
-    };
-    sax.XML_ENTITIES = {
-      amp: "&",
-      gt: ">",
-      lt: "<",
-      quot: '"',
-      apos: "'"
-    };
-    sax.ENTITIES = {
-      amp: "&",
-      gt: ">",
-      lt: "<",
-      quot: '"',
-      apos: "'",
-      AElig: 198,
-      Aacute: 193,
-      Acirc: 194,
-      Agrave: 192,
-      Aring: 197,
-      Atilde: 195,
-      Auml: 196,
-      Ccedil: 199,
-      ETH: 208,
-      Eacute: 201,
-      Ecirc: 202,
-      Egrave: 200,
-      Euml: 203,
-      Iacute: 205,
-      Icirc: 206,
-      Igrave: 204,
-      Iuml: 207,
-      Ntilde: 209,
-      Oacute: 211,
-      Ocirc: 212,
-      Ograve: 210,
-      Oslash: 216,
-      Otilde: 213,
-      Ouml: 214,
-      THORN: 222,
-      Uacute: 218,
-      Ucirc: 219,
-      Ugrave: 217,
-      Uuml: 220,
-      Yacute: 221,
-      aacute: 225,
-      acirc: 226,
-      aelig: 230,
-      agrave: 224,
-      aring: 229,
-      atilde: 227,
-      auml: 228,
-      ccedil: 231,
-      eacute: 233,
-      ecirc: 234,
-      egrave: 232,
-      eth: 240,
-      euml: 235,
-      iacute: 237,
-      icirc: 238,
-      igrave: 236,
-      iuml: 239,
-      ntilde: 241,
-      oacute: 243,
-      ocirc: 244,
-      ograve: 242,
-      oslash: 248,
-      otilde: 245,
-      ouml: 246,
-      szlig: 223,
-      thorn: 254,
-      uacute: 250,
-      ucirc: 251,
-      ugrave: 249,
-      uuml: 252,
-      yacute: 253,
-      yuml: 255,
-      copy: 169,
-      reg: 174,
-      nbsp: 160,
-      iexcl: 161,
-      cent: 162,
-      pound: 163,
-      curren: 164,
-      yen: 165,
-      brvbar: 166,
-      sect: 167,
-      uml: 168,
-      ordf: 170,
-      laquo: 171,
-      not: 172,
-      shy: 173,
-      macr: 175,
-      deg: 176,
-      plusmn: 177,
-      sup1: 185,
-      sup2: 178,
-      sup3: 179,
-      acute: 180,
-      micro: 181,
-      para: 182,
-      middot: 183,
-      cedil: 184,
-      ordm: 186,
-      raquo: 187,
-      frac14: 188,
-      frac12: 189,
-      frac34: 190,
-      iquest: 191,
-      times: 215,
-      divide: 247,
-      OElig: 338,
-      oelig: 339,
-      Scaron: 352,
-      scaron: 353,
-      Yuml: 376,
-      fnof: 402,
-      circ: 710,
-      tilde: 732,
-      Alpha: 913,
-      Beta: 914,
-      Gamma: 915,
-      Delta: 916,
-      Epsilon: 917,
-      Zeta: 918,
-      Eta: 919,
-      Theta: 920,
-      Iota: 921,
-      Kappa: 922,
-      Lambda: 923,
-      Mu: 924,
-      Nu: 925,
-      Xi: 926,
-      Omicron: 927,
-      Pi: 928,
-      Rho: 929,
-      Sigma: 931,
-      Tau: 932,
-      Upsilon: 933,
-      Phi: 934,
-      Chi: 935,
-      Psi: 936,
-      Omega: 937,
-      alpha: 945,
-      beta: 946,
-      gamma: 947,
-      delta: 948,
-      epsilon: 949,
-      zeta: 950,
-      eta: 951,
-      theta: 952,
-      iota: 953,
-      kappa: 954,
-      lambda: 955,
-      mu: 956,
-      nu: 957,
-      xi: 958,
-      omicron: 959,
-      pi: 960,
-      rho: 961,
-      sigmaf: 962,
-      sigma: 963,
-      tau: 964,
-      upsilon: 965,
-      phi: 966,
-      chi: 967,
-      psi: 968,
-      omega: 969,
-      thetasym: 977,
-      upsih: 978,
-      piv: 982,
-      ensp: 8194,
-      emsp: 8195,
-      thinsp: 8201,
-      zwnj: 8204,
-      zwj: 8205,
-      lrm: 8206,
-      rlm: 8207,
-      ndash: 8211,
-      mdash: 8212,
-      lsquo: 8216,
-      rsquo: 8217,
-      sbquo: 8218,
-      ldquo: 8220,
-      rdquo: 8221,
-      bdquo: 8222,
-      dagger: 8224,
-      Dagger: 8225,
-      bull: 8226,
-      hellip: 8230,
-      permil: 8240,
-      prime: 8242,
-      Prime: 8243,
-      lsaquo: 8249,
-      rsaquo: 8250,
-      oline: 8254,
-      frasl: 8260,
-      euro: 8364,
-      image: 8465,
-      weierp: 8472,
-      real: 8476,
-      trade: 8482,
-      alefsym: 8501,
-      larr: 8592,
-      uarr: 8593,
-      rarr: 8594,
-      darr: 8595,
-      harr: 8596,
-      crarr: 8629,
-      lArr: 8656,
-      uArr: 8657,
-      rArr: 8658,
-      dArr: 8659,
-      hArr: 8660,
-      forall: 8704,
-      part: 8706,
-      exist: 8707,
-      empty: 8709,
-      nabla: 8711,
-      isin: 8712,
-      notin: 8713,
-      ni: 8715,
-      prod: 8719,
-      sum: 8721,
-      minus: 8722,
-      lowast: 8727,
-      radic: 8730,
-      prop: 8733,
-      infin: 8734,
-      ang: 8736,
-      and: 8743,
-      or: 8744,
-      cap: 8745,
-      cup: 8746,
-      int: 8747,
-      there4: 8756,
-      sim: 8764,
-      cong: 8773,
-      asymp: 8776,
-      ne: 8800,
-      equiv: 8801,
-      le: 8804,
-      ge: 8805,
-      sub: 8834,
-      sup: 8835,
-      nsub: 8836,
-      sube: 8838,
-      supe: 8839,
-      oplus: 8853,
-      otimes: 8855,
-      perp: 8869,
-      sdot: 8901,
-      lceil: 8968,
-      rceil: 8969,
-      lfloor: 8970,
-      rfloor: 8971,
-      lang: 9001,
-      rang: 9002,
-      loz: 9674,
-      spades: 9824,
-      clubs: 9827,
-      hearts: 9829,
-      diams: 9830
-    };
-    Object.keys(sax.ENTITIES).forEach(function(key) {
-      var e3 = sax.ENTITIES[key];
-      var s3 = typeof e3 === "number" ? String.fromCharCode(e3) : e3;
-      sax.ENTITIES[key] = s3;
-    });
-    for (var s2 in sax.STATE) {
-      sax.STATE[sax.STATE[s2]] = s2;
-    }
-    S2 = sax.STATE;
-    function emit(parser, event, data) {
-      parser[event] && parser[event](data);
-    }
-    function getDeclaredEncoding(body) {
-      var match = body && body.match(/(?:^|\s)encoding\s*=\s*(['"])([^'"]+)\1/i);
-      return match ? match[2] : null;
-    }
-    function normalizeEncodingName(encoding) {
-      if (!encoding) {
-        return null;
-      }
-      return encoding.toLowerCase().replace(/[^a-z0-9]/g, "");
-    }
-    function encodingsMatch(detectedEncoding, declaredEncoding) {
-      const detected = normalizeEncodingName(detectedEncoding);
-      const declared = normalizeEncodingName(declaredEncoding);
-      if (!detected || !declared) {
-        return true;
-      }
-      if (declared === "utf16") {
-        return detected === "utf16le" || detected === "utf16be";
-      }
-      return detected === declared;
-    }
-    function validateXmlDeclarationEncoding(parser, data) {
-      if (!parser.strict || !parser.encoding || !data || data.name !== "xml") {
-        return;
-      }
-      var declaredEncoding = getDeclaredEncoding(data.body);
-      if (declaredEncoding && !encodingsMatch(parser.encoding, declaredEncoding)) {
-        strictFail(parser, "XML declaration encoding " + declaredEncoding + " does not match detected stream encoding " + parser.encoding.toUpperCase());
-      }
-    }
-    function emitNode(parser, nodeType, data) {
-      if (parser.textNode)
-        closeText(parser);
-      emit(parser, nodeType, data);
-    }
-    function closeText(parser) {
-      parser.textNode = textopts(parser.opt, parser.textNode);
-      if (parser.textNode)
-        emit(parser, "ontext", parser.textNode);
-      parser.textNode = "";
-    }
-    function textopts(opt, text) {
-      if (opt.trim)
-        text = text.trim();
-      if (opt.normalize)
-        text = text.replace(/\s+/g, " ");
-      return text;
-    }
-    function error95(parser, er2) {
-      closeText(parser);
-      if (parser.trackPosition) {
-        er2 += `
-Line: ` + parser.line + `
-Column: ` + parser.column + `
-Char: ` + parser.c;
-      }
-      er2 = new Error(er2);
-      parser.error = er2;
-      emit(parser, "onerror", er2);
-      return parser;
-    }
-    function end(parser) {
-      if (parser.sawRoot && !parser.closedRoot)
-        strictFail(parser, "Unclosed root tag");
-      if (parser.state !== S2.BEGIN && parser.state !== S2.BEGIN_WHITESPACE && parser.state !== S2.TEXT) {
-        error95(parser, "Unexpected end");
-      }
-      closeText(parser);
-      parser.c = "";
-      parser.closed = true;
-      emit(parser, "onend");
-      SAXParser.call(parser, parser.strict, parser.opt);
-      return parser;
-    }
-    function strictFail(parser, message) {
-      if (typeof parser !== "object" || !(parser instanceof SAXParser)) {
-        throw new Error("bad call to strictFail");
-      }
-      if (parser.strict) {
-        error95(parser, message);
-      }
-    }
-    function newTag(parser) {
-      if (!parser.strict)
-        parser.tagName = parser.tagName[parser.looseCase]();
-      var parent = parser.tags[parser.tags.length - 1] || parser;
-      var tag = parser.tag = { name: parser.tagName, attributes: {} };
-      if (parser.opt.xmlns) {
-        tag.ns = parent.ns;
-      }
-      parser.attribList.length = 0;
-      emitNode(parser, "onopentagstart", tag);
-    }
-    function qname(name2, attribute) {
-      var i3 = name2.indexOf(":");
-      var qualName = i3 < 0 ? ["", name2] : name2.split(":");
-      var prefix2 = qualName[0];
-      var local = qualName[1];
-      if (attribute && name2 === "xmlns") {
-        prefix2 = "xmlns";
-        local = "";
-      }
-      return { prefix: prefix2, local };
-    }
-    function attrib(parser) {
-      if (!parser.strict) {
-        parser.attribName = parser.attribName[parser.looseCase]();
-      }
-      if (parser.attribList.indexOf(parser.attribName) !== -1 || parser.tag.attributes.hasOwnProperty(parser.attribName)) {
-        parser.attribName = parser.attribValue = "";
-        return;
-      }
-      if (parser.opt.xmlns) {
-        var qn2 = qname(parser.attribName, true);
-        var prefix2 = qn2.prefix;
-        var local = qn2.local;
-        if (prefix2 === "xmlns") {
-          if (local === "xml" && parser.attribValue !== XML_NAMESPACE) {
-            strictFail(parser, "xml: prefix must be bound to " + XML_NAMESPACE + `
-` + "Actual: " + parser.attribValue);
-          } else if (local === "xmlns" && parser.attribValue !== XMLNS_NAMESPACE) {
-            strictFail(parser, "xmlns: prefix must be bound to " + XMLNS_NAMESPACE + `
-` + "Actual: " + parser.attribValue);
-          } else {
-            var tag = parser.tag;
-            var parent = parser.tags[parser.tags.length - 1] || parser;
-            if (tag.ns === parent.ns) {
-              tag.ns = Object.create(parent.ns);
-            }
-            tag.ns[local] = parser.attribValue;
-          }
-        }
-        parser.attribList.push([parser.attribName, parser.attribValue]);
-      } else {
-        parser.tag.attributes[parser.attribName] = parser.attribValue;
-        emitNode(parser, "onattribute", {
-          name: parser.attribName,
-          value: parser.attribValue
-        });
-      }
-      parser.attribName = parser.attribValue = "";
-    }
-    function openTag(parser, selfClosing) {
-      if (parser.opt.xmlns) {
-        var tag = parser.tag;
-        var qn2 = qname(parser.tagName);
-        tag.prefix = qn2.prefix;
-        tag.local = qn2.local;
-        tag.uri = tag.ns[qn2.prefix] || "";
-        if (tag.prefix && !tag.uri) {
-          strictFail(parser, "Unbound namespace prefix: " + JSON.stringify(parser.tagName));
-          tag.uri = qn2.prefix;
-        }
-        var parent = parser.tags[parser.tags.length - 1] || parser;
-        if (tag.ns && parent.ns !== tag.ns) {
-          Object.keys(tag.ns).forEach(function(p2) {
-            emitNode(parser, "onopennamespace", {
-              prefix: p2,
-              uri: tag.ns[p2]
-            });
-          });
-        }
-        for (var i3 = 0, l2 = parser.attribList.length;i3 < l2; i3++) {
-          var nv = parser.attribList[i3];
-          var name2 = nv[0];
-          var value = nv[1];
-          var qualName = qname(name2, true);
-          var prefix2 = qualName.prefix;
-          var local = qualName.local;
-          var uri2 = prefix2 === "" ? "" : tag.ns[prefix2] || "";
-          var a2 = {
-            name: name2,
-            value,
-            prefix: prefix2,
-            local,
-            uri: uri2
-          };
-          if (prefix2 && prefix2 !== "xmlns" && !uri2) {
-            strictFail(parser, "Unbound namespace prefix: " + JSON.stringify(prefix2));
-            a2.uri = prefix2;
-          }
-          parser.tag.attributes[name2] = a2;
-          emitNode(parser, "onattribute", a2);
-        }
-        parser.attribList.length = 0;
-      }
-      parser.tag.isSelfClosing = !!selfClosing;
-      parser.sawRoot = true;
-      parser.tags.push(parser.tag);
-      emitNode(parser, "onopentag", parser.tag);
-      if (!selfClosing) {
-        if (!parser.noscript && parser.tagName.toLowerCase() === "script") {
-          parser.state = S2.SCRIPT;
-        } else {
-          parser.state = S2.TEXT;
-        }
-        parser.tag = null;
-        parser.tagName = "";
-      }
-      parser.attribName = parser.attribValue = "";
-      parser.attribList.length = 0;
-    }
-    function closeTag(parser) {
-      if (!parser.tagName) {
-        strictFail(parser, "Weird empty close tag.");
-        parser.textNode += "</>";
-        parser.state = S2.TEXT;
-        return;
-      }
-      if (parser.script) {
-        if (parser.tagName !== "script") {
-          parser.script += "</" + parser.tagName + ">";
-          parser.tagName = "";
-          parser.state = S2.SCRIPT;
-          return;
-        }
-        emitNode(parser, "onscript", parser.script);
-        parser.script = "";
-      }
-      var t13 = parser.tags.length;
-      var tagName = parser.tagName;
-      if (!parser.strict) {
-        tagName = tagName[parser.looseCase]();
-      }
-      var closeTo = tagName;
-      while (t13--) {
-        var close = parser.tags[t13];
-        if (close.name !== closeTo) {
-          strictFail(parser, "Unexpected close tag");
-        } else {
-          break;
-        }
-      }
-      if (t13 < 0) {
-        strictFail(parser, "Unmatched closing tag: " + parser.tagName);
-        parser.textNode += "</" + parser.tagName + ">";
-        parser.state = S2.TEXT;
-        return;
-      }
-      parser.tagName = tagName;
-      var s3 = parser.tags.length;
-      while (s3-- > t13) {
-        var tag = parser.tag = parser.tags.pop();
-        parser.tagName = parser.tag.name;
-        emitNode(parser, "onclosetag", parser.tagName);
-        var x3 = {};
-        for (var i3 in tag.ns) {
-          x3[i3] = tag.ns[i3];
-        }
-        var parent = parser.tags[parser.tags.length - 1] || parser;
-        if (parser.opt.xmlns && tag.ns !== parent.ns) {
-          Object.keys(tag.ns).forEach(function(p2) {
-            var n = tag.ns[p2];
-            emitNode(parser, "onclosenamespace", { prefix: p2, uri: n });
-          });
-        }
-      }
-      if (t13 === 0)
-        parser.closedRoot = true;
-      parser.tagName = parser.attribValue = parser.attribName = "";
-      parser.attribList.length = 0;
-      parser.state = S2.TEXT;
-    }
-    function parseEntity(parser) {
-      var entity = parser.entity;
-      var entityLC = entity.toLowerCase();
-      var num;
-      var numStr = "";
-      if (parser.ENTITIES[entity]) {
-        return parser.ENTITIES[entity];
-      }
-      if (parser.ENTITIES[entityLC]) {
-        return parser.ENTITIES[entityLC];
-      }
-      entity = entityLC;
-      if (entity.charAt(0) === "#") {
-        if (entity.charAt(1) === "x") {
-          entity = entity.slice(2);
-          num = parseInt(entity, 16);
-          numStr = num.toString(16);
-        } else {
-          entity = entity.slice(1);
-          num = parseInt(entity, 10);
-          numStr = num.toString(10);
-        }
-      }
-      entity = entity.replace(/^0+/, "");
-      if (isNaN(num) || numStr.toLowerCase() !== entity || num < 0 || num > 1114111) {
-        strictFail(parser, "Invalid character entity");
-        return "&" + parser.entity + ";";
-      }
-      return String.fromCodePoint(num);
-    }
-    function beginWhiteSpace(parser, c2) {
-      if (c2 === "<") {
-        parser.state = S2.OPEN_WAKA;
-        parser.startTagPosition = parser.position;
-      } else if (!isWhitespace(c2)) {
-        strictFail(parser, "Non-whitespace before first tag.");
-        parser.textNode = c2;
-        parser.state = S2.TEXT;
-      }
-    }
-    function charAt(chunk, i3) {
-      var result = "";
-      if (i3 < chunk.length) {
-        result = chunk.charAt(i3);
-      }
-      return result;
-    }
-    function write(chunk) {
-      var parser = this;
-      if (this.error) {
-        throw this.error;
-      }
-      if (parser.closed) {
-        return error95(parser, "Cannot write after close. Assign an onready handler.");
-      }
-      if (chunk === null) {
-        return end(parser);
-      }
-      if (typeof chunk === "object") {
-        chunk = chunk.toString();
-      }
-      var i3 = 0;
-      var c2 = "";
-      while (true) {
-        c2 = charAt(chunk, i3++);
-        parser.c = c2;
-        if (!c2) {
-          break;
-        }
-        if (parser.trackPosition) {
-          parser.position++;
-          if (c2 === `
-`) {
-            parser.line++;
-            parser.column = 0;
-          } else {
-            parser.column++;
-          }
-        }
-        switch (parser.state) {
-          case S2.BEGIN:
-            parser.state = S2.BEGIN_WHITESPACE;
-            if (c2 === "\uFEFF") {
-              continue;
-            }
-            beginWhiteSpace(parser, c2);
-            continue;
-          case S2.BEGIN_WHITESPACE:
-            beginWhiteSpace(parser, c2);
-            continue;
-          case S2.TEXT:
-            if (parser.sawRoot && !parser.closedRoot) {
-              var starti = i3 - 1;
-              while (c2 && c2 !== "<" && c2 !== "&") {
-                c2 = charAt(chunk, i3++);
-                if (c2 && parser.trackPosition) {
-                  parser.position++;
-                  if (c2 === `
-`) {
-                    parser.line++;
-                    parser.column = 0;
-                  } else {
-                    parser.column++;
-                  }
-                }
-              }
-              parser.textNode += chunk.substring(starti, i3 - 1);
-            }
-            if (c2 === "<" && !(parser.sawRoot && parser.closedRoot && !parser.strict)) {
-              parser.state = S2.OPEN_WAKA;
-              parser.startTagPosition = parser.position;
-            } else {
-              if (!isWhitespace(c2) && (!parser.sawRoot || parser.closedRoot)) {
-                strictFail(parser, "Text data outside of root node.");
-              }
-              if (c2 === "&") {
-                parser.state = S2.TEXT_ENTITY;
-              } else {
-                parser.textNode += c2;
-              }
-            }
-            continue;
-          case S2.SCRIPT:
-            if (c2 === "<") {
-              parser.state = S2.SCRIPT_ENDING;
-            } else {
-              parser.script += c2;
-            }
-            continue;
-          case S2.SCRIPT_ENDING:
-            if (c2 === "/") {
-              parser.state = S2.CLOSE_TAG;
-            } else {
-              parser.script += "<" + c2;
-              parser.state = S2.SCRIPT;
-            }
-            continue;
-          case S2.OPEN_WAKA:
-            if (c2 === "!") {
-              parser.state = S2.SGML_DECL;
-              parser.sgmlDecl = "";
-            } else if (isWhitespace(c2)) {} else if (isMatch(nameStart, c2)) {
-              parser.state = S2.OPEN_TAG;
-              parser.tagName = c2;
-            } else if (c2 === "/") {
-              parser.state = S2.CLOSE_TAG;
-              parser.tagName = "";
-            } else if (c2 === "?") {
-              parser.state = S2.PROC_INST;
-              parser.procInstName = parser.procInstBody = "";
-            } else {
-              strictFail(parser, "Unencoded <");
-              if (parser.startTagPosition + 1 < parser.position) {
-                var pad = parser.position - parser.startTagPosition;
-                c2 = new Array(pad).join(" ") + c2;
-              }
-              parser.textNode += "<" + c2;
-              parser.state = S2.TEXT;
-            }
-            continue;
-          case S2.SGML_DECL:
-            if (parser.sgmlDecl + c2 === "--") {
-              parser.state = S2.COMMENT;
-              parser.comment = "";
-              parser.sgmlDecl = "";
-              continue;
-            }
-            if (parser.doctype && parser.doctype !== true && parser.sgmlDecl) {
-              parser.state = S2.DOCTYPE_DTD;
-              parser.doctype += "<!" + parser.sgmlDecl + c2;
-              parser.sgmlDecl = "";
-            } else if ((parser.sgmlDecl + c2).toUpperCase() === CDATA) {
-              emitNode(parser, "onopencdata");
-              parser.state = S2.CDATA;
-              parser.sgmlDecl = "";
-              parser.cdata = "";
-            } else if ((parser.sgmlDecl + c2).toUpperCase() === DOCTYPE) {
-              parser.state = S2.DOCTYPE;
-              if (parser.doctype || parser.sawRoot) {
-                strictFail(parser, "Inappropriately located doctype declaration");
-              }
-              parser.doctype = "";
-              parser.sgmlDecl = "";
-            } else if (c2 === ">") {
-              emitNode(parser, "onsgmldeclaration", parser.sgmlDecl);
-              parser.sgmlDecl = "";
-              parser.state = S2.TEXT;
-            } else if (isQuote(c2)) {
-              parser.state = S2.SGML_DECL_QUOTED;
-              parser.sgmlDecl += c2;
-            } else {
-              parser.sgmlDecl += c2;
-            }
-            continue;
-          case S2.SGML_DECL_QUOTED:
-            if (c2 === parser.q) {
-              parser.state = S2.SGML_DECL;
-              parser.q = "";
-            }
-            parser.sgmlDecl += c2;
-            continue;
-          case S2.DOCTYPE:
-            if (c2 === ">") {
-              parser.state = S2.TEXT;
-              emitNode(parser, "ondoctype", parser.doctype);
-              parser.doctype = true;
-            } else {
-              parser.doctype += c2;
-              if (c2 === "[") {
-                parser.state = S2.DOCTYPE_DTD;
-              } else if (isQuote(c2)) {
-                parser.state = S2.DOCTYPE_QUOTED;
-                parser.q = c2;
-              }
-            }
-            continue;
-          case S2.DOCTYPE_QUOTED:
-            parser.doctype += c2;
-            if (c2 === parser.q) {
-              parser.q = "";
-              parser.state = S2.DOCTYPE;
-            }
-            continue;
-          case S2.DOCTYPE_DTD:
-            if (c2 === "]") {
-              parser.doctype += c2;
-              parser.state = S2.DOCTYPE;
-            } else if (c2 === "<") {
-              parser.state = S2.OPEN_WAKA;
-              parser.startTagPosition = parser.position;
-            } else if (isQuote(c2)) {
-              parser.doctype += c2;
-              parser.state = S2.DOCTYPE_DTD_QUOTED;
-              parser.q = c2;
-            } else {
-              parser.doctype += c2;
-            }
-            continue;
-          case S2.DOCTYPE_DTD_QUOTED:
-            parser.doctype += c2;
-            if (c2 === parser.q) {
-              parser.state = S2.DOCTYPE_DTD;
-              parser.q = "";
-            }
-            continue;
-          case S2.COMMENT:
-            if (c2 === "-") {
-              parser.state = S2.COMMENT_ENDING;
-            } else {
-              parser.comment += c2;
-            }
-            continue;
-          case S2.COMMENT_ENDING:
-            if (c2 === "-") {
-              parser.state = S2.COMMENT_ENDED;
-              parser.comment = textopts(parser.opt, parser.comment);
-              if (parser.comment) {
-                emitNode(parser, "oncomment", parser.comment);
-              }
-              parser.comment = "";
-            } else {
-              parser.comment += "-" + c2;
-              parser.state = S2.COMMENT;
-            }
-            continue;
-          case S2.COMMENT_ENDED:
-            if (c2 !== ">") {
-              strictFail(parser, "Malformed comment");
-              parser.comment += "--" + c2;
-              parser.state = S2.COMMENT;
-            } else if (parser.doctype && parser.doctype !== true) {
-              parser.state = S2.DOCTYPE_DTD;
-            } else {
-              parser.state = S2.TEXT;
-            }
-            continue;
-          case S2.CDATA:
-            var starti = i3 - 1;
-            while (c2 && c2 !== "]") {
-              c2 = charAt(chunk, i3++);
-              if (c2 && parser.trackPosition) {
-                parser.position++;
-                if (c2 === `
-`) {
-                  parser.line++;
-                  parser.column = 0;
-                } else {
-                  parser.column++;
-                }
-              }
-            }
-            parser.cdata += chunk.substring(starti, i3 - 1);
-            if (c2 === "]") {
-              parser.state = S2.CDATA_ENDING;
-            }
-            continue;
-          case S2.CDATA_ENDING:
-            if (c2 === "]") {
-              parser.state = S2.CDATA_ENDING_2;
-            } else {
-              parser.cdata += "]" + c2;
-              parser.state = S2.CDATA;
-            }
-            continue;
-          case S2.CDATA_ENDING_2:
-            if (c2 === ">") {
-              if (parser.cdata) {
-                emitNode(parser, "oncdata", parser.cdata);
-              }
-              emitNode(parser, "onclosecdata");
-              parser.cdata = "";
-              parser.state = S2.TEXT;
-            } else if (c2 === "]") {
-              parser.cdata += "]";
-            } else {
-              parser.cdata += "]]" + c2;
-              parser.state = S2.CDATA;
-            }
-            continue;
-          case S2.PROC_INST:
-            if (c2 === "?") {
-              parser.state = S2.PROC_INST_ENDING;
-            } else if (isWhitespace(c2)) {
-              parser.state = S2.PROC_INST_BODY;
-            } else {
-              parser.procInstName += c2;
-            }
-            continue;
-          case S2.PROC_INST_BODY:
-            if (!parser.procInstBody && isWhitespace(c2)) {
-              continue;
-            } else if (c2 === "?") {
-              parser.state = S2.PROC_INST_ENDING;
-            } else {
-              parser.procInstBody += c2;
-            }
-            continue;
-          case S2.PROC_INST_ENDING:
-            if (c2 === ">") {
-              const procInstEndData = {
-                name: parser.procInstName,
-                body: parser.procInstBody
-              };
-              validateXmlDeclarationEncoding(parser, procInstEndData);
-              emitNode(parser, "onprocessinginstruction", procInstEndData);
-              parser.procInstName = parser.procInstBody = "";
-              parser.state = S2.TEXT;
-            } else {
-              parser.procInstBody += "?" + c2;
-              parser.state = S2.PROC_INST_BODY;
-            }
-            continue;
-          case S2.OPEN_TAG:
-            if (isMatch(nameBody, c2)) {
-              parser.tagName += c2;
-            } else {
-              newTag(parser);
-              if (c2 === ">") {
-                openTag(parser);
-              } else if (c2 === "/") {
-                parser.state = S2.OPEN_TAG_SLASH;
-              } else {
-                if (!isWhitespace(c2)) {
-                  strictFail(parser, "Invalid character in tag name");
-                }
-                parser.state = S2.ATTRIB;
-              }
-            }
-            continue;
-          case S2.OPEN_TAG_SLASH:
-            if (c2 === ">") {
-              openTag(parser, true);
-              closeTag(parser);
-            } else {
-              strictFail(parser, "Forward-slash in opening tag not followed by >");
-              parser.state = S2.ATTRIB;
-            }
-            continue;
-          case S2.ATTRIB:
-            if (isWhitespace(c2)) {
-              continue;
-            } else if (c2 === ">") {
-              openTag(parser);
-            } else if (c2 === "/") {
-              parser.state = S2.OPEN_TAG_SLASH;
-            } else if (isMatch(nameStart, c2)) {
-              parser.attribName = c2;
-              parser.attribValue = "";
-              parser.state = S2.ATTRIB_NAME;
-            } else {
-              strictFail(parser, "Invalid attribute name");
-            }
-            continue;
-          case S2.ATTRIB_NAME:
-            if (c2 === "=") {
-              parser.state = S2.ATTRIB_VALUE;
-            } else if (c2 === ">") {
-              strictFail(parser, "Attribute without value");
-              parser.attribValue = parser.attribName;
-              attrib(parser);
-              openTag(parser);
-            } else if (isWhitespace(c2)) {
-              parser.state = S2.ATTRIB_NAME_SAW_WHITE;
-            } else if (isMatch(nameBody, c2)) {
-              parser.attribName += c2;
-            } else {
-              strictFail(parser, "Invalid attribute name");
-            }
-            continue;
-          case S2.ATTRIB_NAME_SAW_WHITE:
-            if (c2 === "=") {
-              parser.state = S2.ATTRIB_VALUE;
-            } else if (isWhitespace(c2)) {
-              continue;
-            } else {
-              strictFail(parser, "Attribute without value");
-              parser.tag.attributes[parser.attribName] = "";
-              parser.attribValue = "";
-              emitNode(parser, "onattribute", {
-                name: parser.attribName,
-                value: ""
-              });
-              parser.attribName = "";
-              if (c2 === ">") {
-                openTag(parser);
-              } else if (isMatch(nameStart, c2)) {
-                parser.attribName = c2;
-                parser.state = S2.ATTRIB_NAME;
-              } else {
-                strictFail(parser, "Invalid attribute name");
-                parser.state = S2.ATTRIB;
-              }
-            }
-            continue;
-          case S2.ATTRIB_VALUE:
-            if (isWhitespace(c2)) {
-              continue;
-            } else if (isQuote(c2)) {
-              parser.q = c2;
-              parser.state = S2.ATTRIB_VALUE_QUOTED;
-            } else {
-              if (!parser.opt.unquotedAttributeValues) {
-                error95(parser, "Unquoted attribute value");
-              }
-              parser.state = S2.ATTRIB_VALUE_UNQUOTED;
-              parser.attribValue = c2;
-            }
-            continue;
-          case S2.ATTRIB_VALUE_QUOTED:
-            if (c2 !== parser.q) {
-              if (c2 === "&") {
-                parser.state = S2.ATTRIB_VALUE_ENTITY_Q;
-              } else {
-                parser.attribValue += c2;
-              }
-              continue;
-            }
-            attrib(parser);
-            parser.q = "";
-            parser.state = S2.ATTRIB_VALUE_CLOSED;
-            continue;
-          case S2.ATTRIB_VALUE_CLOSED:
-            if (isWhitespace(c2)) {
-              parser.state = S2.ATTRIB;
-            } else if (c2 === ">") {
-              openTag(parser);
-            } else if (c2 === "/") {
-              parser.state = S2.OPEN_TAG_SLASH;
-            } else if (isMatch(nameStart, c2)) {
-              strictFail(parser, "No whitespace between attributes");
-              parser.attribName = c2;
-              parser.attribValue = "";
-              parser.state = S2.ATTRIB_NAME;
-            } else {
-              strictFail(parser, "Invalid attribute name");
-            }
-            continue;
-          case S2.ATTRIB_VALUE_UNQUOTED:
-            if (!isAttribEnd(c2)) {
-              if (c2 === "&") {
-                parser.state = S2.ATTRIB_VALUE_ENTITY_U;
-              } else {
-                parser.attribValue += c2;
-              }
-              continue;
-            }
-            attrib(parser);
-            if (c2 === ">") {
-              openTag(parser);
-            } else {
-              parser.state = S2.ATTRIB;
-            }
-            continue;
-          case S2.CLOSE_TAG:
-            if (!parser.tagName) {
-              if (isWhitespace(c2)) {
-                continue;
-              } else if (notMatch(nameStart, c2)) {
-                if (parser.script) {
-                  parser.script += "</" + c2;
-                  parser.state = S2.SCRIPT;
-                } else {
-                  strictFail(parser, "Invalid tagname in closing tag.");
-                }
-              } else {
-                parser.tagName = c2;
-              }
-            } else if (c2 === ">") {
-              closeTag(parser);
-            } else if (isMatch(nameBody, c2)) {
-              parser.tagName += c2;
-            } else if (parser.script) {
-              parser.script += "</" + parser.tagName + c2;
-              parser.tagName = "";
-              parser.state = S2.SCRIPT;
-            } else {
-              if (!isWhitespace(c2)) {
-                strictFail(parser, "Invalid tagname in closing tag");
-              }
-              parser.state = S2.CLOSE_TAG_SAW_WHITE;
-            }
-            continue;
-          case S2.CLOSE_TAG_SAW_WHITE:
-            if (isWhitespace(c2)) {
-              continue;
-            }
-            if (c2 === ">") {
-              closeTag(parser);
-            } else {
-              strictFail(parser, "Invalid characters in closing tag");
-            }
-            continue;
-          case S2.TEXT_ENTITY:
-          case S2.ATTRIB_VALUE_ENTITY_Q:
-          case S2.ATTRIB_VALUE_ENTITY_U:
-            var returnState;
-            var buffer;
-            switch (parser.state) {
-              case S2.TEXT_ENTITY:
-                returnState = S2.TEXT;
-                buffer = "textNode";
-                break;
-              case S2.ATTRIB_VALUE_ENTITY_Q:
-                returnState = S2.ATTRIB_VALUE_QUOTED;
-                buffer = "attribValue";
-                break;
-              case S2.ATTRIB_VALUE_ENTITY_U:
-                returnState = S2.ATTRIB_VALUE_UNQUOTED;
-                buffer = "attribValue";
-                break;
-            }
-            if (c2 === ";") {
-              var parsedEntity = parseEntity(parser);
-              if (parser.opt.unparsedEntities && !Object.values(sax.XML_ENTITIES).includes(parsedEntity)) {
-                if ((parser.entityCount += 1) > parser.opt.maxEntityCount) {
-                  error95(parser, "Parsed entity count exceeds max entity count");
-                }
-                if ((parser.entityDepth += 1) > parser.opt.maxEntityDepth) {
-                  error95(parser, "Parsed entity depth exceeds max entity depth");
-                }
-                parser.entity = "";
-                parser.state = returnState;
-                parser.write(parsedEntity);
-                parser.entityDepth -= 1;
-              } else {
-                parser[buffer] += parsedEntity;
-                parser.entity = "";
-                parser.state = returnState;
-              }
-            } else if (isMatch(parser.entity.length ? entityBody : entityStart, c2)) {
-              parser.entity += c2;
-            } else {
-              strictFail(parser, "Invalid character in entity name");
-              parser[buffer] += "&" + parser.entity + c2;
-              parser.entity = "";
-              parser.state = returnState;
-            }
-            continue;
-          default: {
-            throw new Error(parser, "Unknown state: " + parser.state);
-          }
-        }
-      }
-      if (parser.position >= parser.bufferCheckPosition) {
-        checkBufferLength(parser);
-      }
-      return parser;
-    }
-    /*! http://mths.be/fromcodepoint v0.1.0 by @mathias */
-    if (!String.fromCodePoint) {
-      (function() {
-        var stringFromCharCode = String.fromCharCode;
-        var floor = Math.floor;
-        var fromCodePoint = function() {
-          var MAX_SIZE = 16384;
-          var codeUnits = [];
-          var highSurrogate;
-          var lowSurrogate;
-          var index = -1;
-          var length = arguments.length;
-          if (!length) {
-            return "";
-          }
-          var result = "";
-          while (++index < length) {
-            var codePoint = Number(arguments[index]);
-            if (!isFinite(codePoint) || codePoint < 0 || codePoint > 1114111 || floor(codePoint) !== codePoint) {
-              throw RangeError("Invalid code point: " + codePoint);
-            }
-            if (codePoint <= 65535) {
-              codeUnits.push(codePoint);
-            } else {
-              codePoint -= 65536;
-              highSurrogate = (codePoint >> 10) + 55296;
-              lowSurrogate = codePoint % 1024 + 56320;
-              codeUnits.push(highSurrogate, lowSurrogate);
-            }
-            if (index + 1 === length || codeUnits.length > MAX_SIZE) {
-              result += stringFromCharCode.apply(null, codeUnits);
-              codeUnits.length = 0;
-            }
-          }
-          return result;
-        };
-        if (Object.defineProperty) {
-          Object.defineProperty(String, "fromCodePoint", {
-            value: fromCodePoint,
-            configurable: true,
-            writable: true
-          });
-        } else {
-          String.fromCodePoint = fromCodePoint;
-        }
-      })();
-    }
-  })(typeof exports === "undefined" ? exports.sax = {} : exports);
-});
-
 // ../auth/src/catch-error.ts
 function isPromiseLike2(value) {
   return value !== null && typeof value === "object" && typeof value.then === "function";
@@ -209496,7 +207962,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
   package_default7 = {
     name: "@uipath/project-packager",
     license: "MIT",
-    version: "1.199.0-preview.104",
+    version: "1.199.0-preview.106",
     description: "UiPath Project Packager - core library for packing individual UiPath projects",
     type: "module",
     main: "./dist/index.js",
@@ -301372,7 +299838,7 @@ import"./packager-tool.js";
 var package_default = {
   name: "@uipath/flow-tool",
   license: "MIT",
-  version: "1.199.0-preview.104",
+  version: "1.199.0-preview.106",
   description: "Create, debug, and run UiPath Flow projects and jobs.",
   private: false,
   repository: {
@@ -310014,7 +308480,7 @@ init_dist3();
 // ../packager/packager-tool-flow/package.json
 var package_default2 = {
   name: "@uipath/packager-tool-flow",
-  version: "1.199.0-preview.104",
+  version: "1.199.0-preview.106",
   description: "UiPath Flow tool implementation",
   type: "module",
   exports: {
@@ -323309,9 +321775,6 @@ async function findProjectFlowFile(projectPath, mainFile, preferredBaseName) {
 
 // src/services/node-service.ts
 init_src();
-
-// ../maestro-sdk/src/bpmn-validation/canvas/canvas-validator.ts
-var import_sax = __toESM(require_sax(), 1);
 // ../maestro-sdk/src/manifest/bpmn-spec.json
 var bpmn_spec_default = {
   version: "1.0.0",
@@ -326262,392 +324725,6 @@ var SUPPORTED_UIPATH_EXTENSION_TAG_NAMES = Object.freeze([
 ].sort());
 var SUPPORTED_UIPATH_EXTENSION_TAGS = Object.freeze(SUPPORTED_UIPATH_EXTENSION_TAG_NAMES.map((tag) => `uipath:${tag}`));
 
-// ../maestro-sdk/src/bpmn-validation/canvas/model.ts
-var ABSTRACT_ACTIVITY = new Set([
-  "bpmn:Task",
-  "bpmn:ServiceTask",
-  "bpmn:UserTask",
-  "bpmn:ScriptTask",
-  "bpmn:SendTask",
-  "bpmn:ReceiveTask",
-  "bpmn:BusinessRuleTask",
-  "bpmn:ManualTask",
-  "bpmn:CallActivity",
-  "bpmn:SubProcess",
-  "bpmn:AdHocSubProcess",
-  "bpmn:Transaction"
-]);
-var ABSTRACT_EVENT = new Set([
-  "bpmn:StartEvent",
-  "bpmn:EndEvent",
-  "bpmn:IntermediateCatchEvent",
-  "bpmn:IntermediateThrowEvent",
-  "bpmn:BoundaryEvent"
-]);
-var FLOW_EDGE_TYPES = new Set([
-  "bpmn:SequenceFlow",
-  "bpmn:MessageFlow",
-  "bpmn:Association"
-]);
-
-// ../maestro-sdk/src/bpmn-validation/canvas/known-methods.json
-var known_methods_default = [
-  "Abs",
-  "Acos",
-  "AcosPi",
-  "Acosh",
-  "Add",
-  "AddDays",
-  "AddHours",
-  "AddMicroseconds",
-  "AddMilliseconds",
-  "AddMinutes",
-  "AddMonths",
-  "AddSeconds",
-  "AddTicks",
-  "AddYears",
-  "Asin",
-  "AsinPi",
-  "Asinh",
-  "Atan",
-  "Atan2",
-  "Atan2Pi",
-  "AtanPi",
-  "Atanh",
-  "BigMul",
-  "BitDecrement",
-  "BitIncrement",
-  "Cbrt",
-  "Ceiling",
-  "ChangeType",
-  "Clamp",
-  "Clone",
-  "Compare",
-  "CompareOrdinal",
-  "CompareTo",
-  "Concat",
-  "Contains",
-  "ConvertFromUtf32",
-  "ConvertToInteger",
-  "ConvertToIntegerNative",
-  "Copy",
-  "CopySign",
-  "CopyTo",
-  "Cos",
-  "CosPi",
-  "Cosh",
-  "Create",
-  "CreateChecked",
-  "CreateSaturating",
-  "CreateTruncating",
-  "CreateVersion7",
-  "DaysInMonth",
-  "Deconstruct",
-  "DegreesToRadians",
-  "DivRem",
-  "Divide",
-  "Duration",
-  "EndsWith",
-  "Equals",
-  "Exp",
-  "Exp10",
-  "Exp10M1",
-  "Exp2",
-  "Exp2M1",
-  "ExpM1",
-  "Finalize",
-  "Floor",
-  "Format",
-  "FromBase64CharArray",
-  "FromBase64String",
-  "FromBinary",
-  "FromDays",
-  "FromFileTime",
-  "FromFileTimeUtc",
-  "FromHexString",
-  "FromHours",
-  "FromMicroseconds",
-  "FromMilliseconds",
-  "FromMinutes",
-  "FromOACurrency",
-  "FromOADate",
-  "FromSeconds",
-  "FromTicks",
-  "FusedMultiplyAdd",
-  "GetBits",
-  "GetDateTimeFormats",
-  "GetEnumerator",
-  "GetHashCode",
-  "GetNumericValue",
-  "GetPinnableReference",
-  "GetType",
-  "GetTypeCode",
-  "GetUnicodeCategory",
-  "Hypot",
-  "IEEERemainder",
-  "ILogB",
-  "Ieee754Remainder",
-  "IndexOf",
-  "IndexOfAny",
-  "Insert",
-  "Intern",
-  "IsAscii",
-  "IsAsciiDigit",
-  "IsAsciiHexDigit",
-  "IsAsciiHexDigitLower",
-  "IsAsciiHexDigitUpper",
-  "IsAsciiLetter",
-  "IsAsciiLetterLower",
-  "IsAsciiLetterOrDigit",
-  "IsAsciiLetterUpper",
-  "IsBetween",
-  "IsCanonical",
-  "IsControl",
-  "IsDBNull",
-  "IsDaylightSavingTime",
-  "IsDigit",
-  "IsEvenInteger",
-  "IsFinite",
-  "IsHighSurrogate",
-  "IsInfinity",
-  "IsInteger",
-  "IsInterned",
-  "IsLeapYear",
-  "IsLetter",
-  "IsLetterOrDigit",
-  "IsLowSurrogate",
-  "IsLower",
-  "IsNaN",
-  "IsNegative",
-  "IsNegativeInfinity",
-  "IsNormal",
-  "IsNormalized",
-  "IsNullOrEmpty",
-  "IsNullOrWhiteSpace",
-  "IsNumber",
-  "IsOddInteger",
-  "IsPositive",
-  "IsPositiveInfinity",
-  "IsPow2",
-  "IsPunctuation",
-  "IsRealNumber",
-  "IsSeparator",
-  "IsSubnormal",
-  "IsSurrogate",
-  "IsSurrogatePair",
-  "IsSymbol",
-  "IsUpper",
-  "IsWhiteSpace",
-  "Join",
-  "LastIndexOf",
-  "LastIndexOfAny",
-  "LeadingZeroCount",
-  "Lerp",
-  "Log",
-  "Log10",
-  "Log10P1",
-  "Log2",
-  "Log2P1",
-  "LogP1",
-  "Max",
-  "MaxMagnitude",
-  "MaxMagnitudeNumber",
-  "MaxNumber",
-  "MemberwiseClone",
-  "Min",
-  "MinMagnitude",
-  "MinMagnitudeNumber",
-  "MinNumber",
-  "Multiply",
-  "MultiplyAddEstimate",
-  "Negate",
-  "NewGuid",
-  "Normalize",
-  "PadLeft",
-  "PadRight",
-  "Parse",
-  "ParseExact",
-  "PopCount",
-  "Pow",
-  "RadiansToDegrees",
-  "ReciprocalEstimate",
-  "ReciprocalSqrtEstimate",
-  "ReferenceEquals",
-  "Remainder",
-  "Remove",
-  "Replace",
-  "ReplaceLineEndings",
-  "RootN",
-  "RotateLeft",
-  "RotateRight",
-  "Round",
-  "Scale",
-  "ScaleB",
-  "Sign",
-  "Sin",
-  "SinCos",
-  "SinCosPi",
-  "SinPi",
-  "Sinh",
-  "SpecifyKind",
-  "Split",
-  "Sqrt",
-  "StartsWith",
-  "Substring",
-  "Subtract",
-  "Tan",
-  "TanPi",
-  "Tanh",
-  "ToBase64CharArray",
-  "ToBase64String",
-  "ToBinary",
-  "ToBoolean",
-  "ToByte",
-  "ToByteArray",
-  "ToChar",
-  "ToCharArray",
-  "ToDateTime",
-  "ToDecimal",
-  "ToDouble",
-  "ToFileTime",
-  "ToFileTimeUtc",
-  "ToInt16",
-  "ToInt32",
-  "ToInt64",
-  "ToLocalTime",
-  "ToLongDateString",
-  "ToLongTimeString",
-  "ToLower",
-  "ToLowerInvariant",
-  "ToOACurrency",
-  "ToOADate",
-  "ToSByte",
-  "ToShortDateString",
-  "ToShortTimeString",
-  "ToSingle",
-  "ToString",
-  "ToUInt16",
-  "ToUInt32",
-  "ToUInt64",
-  "ToUniversalTime",
-  "ToUpper",
-  "ToUpperInvariant",
-  "TrailingZeroCount",
-  "Trim",
-  "TrimEnd",
-  "TrimStart",
-  "Truncate",
-  "TryFormat",
-  "TryFromBase64Chars",
-  "TryFromBase64String",
-  "TryGetBits",
-  "TryParse",
-  "TryParseExact",
-  "TryToBase64Chars",
-  "TryToHexString",
-  "TryToHexStringLower",
-  "TryWriteBytes"
-];
-
-// ../maestro-sdk/src/bpmn-validation/canvas/rules.ts
-var BUILTIN_NON_VARIABLE_VARS_SEGMENTS = new Set(["error"]);
-var baseAllowedTargets = new Set(["bpmn:TextAnnotation"]);
-var commonAllowedTargets = new Set([
-  ...baseAllowedTargets,
-  "bpmn:IntermediateThrowEvent",
-  "bpmn:IntermediateCatchEvent",
-  "bpmn:EndEvent",
-  "bpmn:ExclusiveGateway",
-  "bpmn:ParallelGateway",
-  "bpmn:InclusiveGateway",
-  "bpmn:ComplexGateway",
-  "bpmn:Task",
-  "bpmn:UserTask",
-  "bpmn:ServiceTask",
-  "bpmn:SendTask",
-  "bpmn:ReceiveTask",
-  "bpmn:ManualTask",
-  "bpmn:BusinessRuleTask",
-  "bpmn:ScriptTask",
-  "bpmn:CallActivity",
-  "bpmn:SubProcess",
-  "bpmn:AdHocSubProcess",
-  "bpmn:Transaction"
-]);
-var activityAllowedTargets = new Set([
-  ...commonAllowedTargets,
-  "bpmn:EventBasedGateway",
-  "bpmn:DataOutput",
-  "bpmn:DataStoreReference",
-  "bpmn:DataObjectReference"
-]);
-var allowedTargetNodeTypesForSourceNodeType = {
-  "bpmn:StartEvent": commonAllowedTargets,
-  "bpmn:IntermediateThrowEvent": commonAllowedTargets,
-  "bpmn:IntermediateCatchEvent": commonAllowedTargets,
-  "bpmn:BoundaryEvent": commonAllowedTargets,
-  "bpmn:EndEvent": new Set(["bpmn:TextAnnotation"]),
-  "bpmn:ExclusiveGateway": commonAllowedTargets,
-  "bpmn:ParallelGateway": commonAllowedTargets,
-  "bpmn:InclusiveGateway": commonAllowedTargets,
-  "bpmn:ComplexGateway": commonAllowedTargets,
-  "bpmn:EventBasedGateway": new Set([
-    "bpmn:IntermediateCatchEvent",
-    "bpmn:TextAnnotation"
-  ]),
-  "bpmn:Task": activityAllowedTargets,
-  "bpmn:UserTask": activityAllowedTargets,
-  "bpmn:ServiceTask": activityAllowedTargets,
-  "bpmn:SendTask": activityAllowedTargets,
-  "bpmn:ReceiveTask": activityAllowedTargets,
-  "bpmn:ManualTask": activityAllowedTargets,
-  "bpmn:BusinessRuleTask": activityAllowedTargets,
-  "bpmn:ScriptTask": activityAllowedTargets,
-  "bpmn:CallActivity": activityAllowedTargets,
-  "bpmn:SubProcess": activityAllowedTargets,
-  "bpmn:AdHocSubProcess": activityAllowedTargets,
-  "bpmn:Transaction": activityAllowedTargets,
-  "bpmn:TextAnnotation": new Set,
-  "bpmn:Participant": baseAllowedTargets,
-  "bpmn:Lane": baseAllowedTargets
-};
-var SERVICE_TYPES_REQUIRING_RESOURCE = new Set([
-  "Orchestrator.StartAgentJob",
-  "Orchestrator.StartJob",
-  "Orchestrator.CreateQueueItem",
-  "Orchestrator.CreateAndWaitForQueueItem",
-  "Orchestrator.BulkAddQueueItems",
-  "Orchestrator.QueueItemAdded",
-  "Orchestrator.ExecuteApiWorkflowAsync",
-  "Orchestrator.StartFlowProcess",
-  "Orchestrator.StartFlowProcessAsync",
-  "Actions.HITL",
-  "Orchestrator.StartAgenticProcess",
-  "Orchestrator.StartAgenticProcessAsync",
-  "Orchestrator.StartCaseMgmtProcess",
-  "Orchestrator.StartCaseMgmtProcessAsync"
-]);
-var HITL_QUICK_SCHEMA_CONTEXT_NAMES = new Set([
-  "_schemaFileId",
-  "hitlSchemaId",
-  "__hitlFormSchema"
-]);
-var MAX_TIMER_MINUTES = 90 * 24 * 60;
-var CONDITION_IGNORING_NODE_TYPES = new Set([
-  "bpmn:ParallelGateway",
-  "bpmn:EventBasedGateway"
-]);
-var SUPERFLUOUS_RULE_GATEWAY_TYPES = new Set([
-  "bpmn:ExclusiveGateway",
-  "bpmn:InclusiveGateway"
-]);
-var METHODS_FOLLOWED_BY_PARENTHESES = new Set(known_methods_default);
-var SERVICE_TYPES_WITH_INPUT_TYPE_VALIDATION = new Set([
-  "Orchestrator.StartAgentJob"
-]);
-var NUMERIC_INPUT_TYPES = new Set(["integer", "number", "double", "float"]);
-var JSON_INPUT_TYPES = new Set(["json", "jsonSchema", "object", "array"]);
-var JSON_CONTAINER_INPUT_TYPES = new Set(["json", "jsonSchema"]);
 // ../maestro-sdk/src/bpmn-validation/project-validator.ts
 var KNOWN_UIPATH_TAGS = new Set(SUPPORTED_UIPATH_EXTENSION_TAGS);
 // ../maestro-sdk/src/client.ts
@@ -359173,7 +357250,7 @@ class TextApiResponse {
 var package_default3 = {
   name: "@uipath/integrationservice-sdk",
   license: "MIT",
-  version: "1.199.0-preview.104",
+  version: "1.199.0-preview.106",
   repository: {
     type: "git",
     url: "https://github.com/UiPath/cli.git",
@@ -366780,23 +364857,23 @@ async function pullNodes(options = {}) {
 async function refreshNodes() {
   const oldMeta = await loadIndexMetadata();
   const pullResult = await pullRemoteNodes();
-  const allNodes2 = pullResult.nodes;
+  const allNodes = pullResult.nodes;
   if (!pullResult.cacheable) {
     return {
       cacheWritten: false,
-      nodeCount: allNodes2.length,
+      nodeCount: allNodes.length,
       source: pullResult.source,
       info: pullResult.info
     };
   }
-  const content = JSON.stringify(allNodes2);
+  const content = JSON.stringify(allNodes);
   const newHash = await hashContent(content);
   if (oldMeta && oldMeta.hash === newHash) {
     if (!await areDerivedArtifactsCurrent()) {
-      await saveNodeIndex(allNodes2);
+      await saveNodeIndex(allNodes);
       return {
         cacheWritten: true,
-        nodeCount: allNodes2.length,
+        nodeCount: allNodes.length,
         source: pullResult.source
       };
     }
@@ -366811,10 +364888,10 @@ async function refreshNodes() {
       source: pullResult.source
     };
   }
-  await saveNodeIndex(allNodes2);
+  await saveNodeIndex(allNodes);
   return {
     cacheWritten: true,
-    nodeCount: allNodes2.length,
+    nodeCount: allNodes.length,
     source: pullResult.source
   };
 }
@@ -377515,8 +375592,8 @@ var addNodeToFlow = async (filePath, nodeType, options = {}) => {
     }
   }
   if (typeof options.parent === "string" && options.parent.length > 0) {
-    const allNodes2 = workflow.nodes;
-    if (!allNodes2.some((n) => n.id === options.parent)) {
+    const allNodes = workflow.nodes;
+    if (!allNodes.some((n) => n.id === options.parent)) {
       throw new Error(`--parent value "${options.parent}" is not an existing node id in this flow. ` + "Run 'uip maestro flow node list <file>' to see valid ids.");
     }
     node2.parentId = options.parent;
@@ -378494,7 +376571,7 @@ function querystringSingleKey4(key, value, keyPrefix = "") {
 var package_default5 = {
   name: "@uipath/solution-sdk",
   license: "MIT",
-  version: "1.199.0-preview.104",
+  version: "1.199.0-preview.106",
   repository: {
     type: "git",
     url: "https://github.com/UiPath/cli.git",
@@ -415733,7 +413810,7 @@ function querystringSingleKey6(key, value, keyPrefix = "") {
 var package_default6 = {
   name: "@uipath/solution-sdk",
   license: "MIT",
-  version: "1.199.0-preview.104",
+  version: "1.199.0-preview.106",
   repository: {
     type: "git",
     url: "https://github.com/UiPath/cli.git",
@@ -433949,11 +432026,11 @@ var migrateFlow = async (filePath, options = {}) => {
   const migrated = wfResult.migrated ? wfResult.workflow : workflow;
   const workflowSteps = wfResult.steps.map((s2) => `${s2.from} -> ${s2.to}`);
   const registry7 = buildNodeMigrationRegistry();
-  const allNodes2 = [
+  const allNodes = [
     ...migrated.nodes ?? [],
     ...Object.values(migrated.subflows ?? {}).flatMap((sf2) => sf2?.nodes ?? [])
   ];
-  const check5 = checkNodeMigrations(allNodes2, allDefinitions2, registry7);
+  const check5 = checkNodeMigrations(allNodes, allDefinitions2, registry7);
   const includeOptional = options.includeOptional ?? true;
   const toApply = includeOptional ? [...check5.forced, ...check5.optional] : check5.forced;
   const nodeResult = applyNodeMigrations(migrated, toApply);
@@ -436930,14 +435007,14 @@ async function tidyNodesAndEdges(engine, nodes, edges, portResolver, shapeOf) {
   if (nodes.length === 0) {
     return { repositioned: 0, resized: 0 };
   }
-  const allNodes2 = nodesToLayoutNodes(nodes, shapeOf);
-  const allEdges2 = edgesToLayoutEdges(edges);
-  const artifactChildIds = identifyArtifactChildIds(allEdges2, portResolver, allNodes2);
-  const collapsedIds = new Set(allNodes2.filter((n) => n.data?.ui?.isCollapsed).map((n) => n.id));
-  const hiddenIds = collectArtifactDescendants2(collapsedIds, allEdges2, artifactChildIds);
-  const layoutNodes = allNodes2.filter((n) => !hiddenIds.has(n.id));
-  const layoutEdges = allEdges2.filter((e3) => !hiddenIds.has(e3.source) && !hiddenIds.has(e3.target));
-  const hiddenNodes = allNodes2.filter((n) => hiddenIds.has(n.id));
+  const allNodes = nodesToLayoutNodes(nodes, shapeOf);
+  const allEdges = edgesToLayoutEdges(edges);
+  const artifactChildIds = identifyArtifactChildIds(allEdges, portResolver, allNodes);
+  const collapsedIds = new Set(allNodes.filter((n) => n.data?.ui?.isCollapsed).map((n) => n.id));
+  const hiddenIds = collectArtifactDescendants2(collapsedIds, allEdges, artifactChildIds);
+  const layoutNodes = allNodes.filter((n) => !hiddenIds.has(n.id));
+  const layoutEdges = allEdges.filter((e3) => !hiddenIds.has(e3.source) && !hiddenIds.has(e3.target));
+  const hiddenNodes = allNodes.filter((n) => hiddenIds.has(n.id));
   if (layoutNodes.length === 0) {
     return { repositioned: 0, resized: 0 };
   }
@@ -436955,7 +435032,7 @@ async function tidyNodesAndEdges(engine, nodes, edges, portResolver, shapeOf) {
       node2.position.y = snapToGrid(node2.position.y + offsetY);
     }
   }
-  const hiddenUpdates = propagateHiddenArtifactPositions(layoutedNodes, preLayoutPositions, hiddenNodes, allEdges2, artifactChildIds);
+  const hiddenUpdates = propagateHiddenArtifactPositions(layoutedNodes, preLayoutPositions, hiddenNodes, allEdges, artifactChildIds);
   const allUpdated = [...layoutedNodes, ...hiddenUpdates];
   return applyLayoutToNodes(nodes, allUpdated, shapeOf);
 }
@@ -438445,7 +436522,7 @@ Validating: ${absolutePath}
     const declaredKeys = new Set(bindings.map((b3) => b3.resourceKey));
     const definitions = workflow.definitions;
     const subflows = workflow.subflows ?? {};
-    const allNodes2 = [
+    const allNodes = [
       ...workflow.nodes.map((n) => ({
         id: n.id,
         type: n.type,
@@ -438459,7 +436536,7 @@ Validating: ${absolutePath}
         scope: `subflows[${subflowId}].`
       })))
     ];
-    for (const node2 of allNodes2) {
+    for (const node2 of allNodes) {
       if (!isProcessNode2({ nodeType: node2.type }))
         continue;
       const needed = collectNodeBindingResourceKeys(node2, bindings, definitions);
@@ -439049,7 +437126,7 @@ function querystringSingleKey7(key, value, keyPrefix = "") {
 var package_default8 = {
   name: "@uipath/agent-sdk",
   license: "MIT",
-  version: "1.199.0-preview.104",
+  version: "1.199.0-preview.106",
   description: "SDK for the UiPath Agent Runtime API — evaluation execution and debug sessions.",
   repository: {
     type: "git",
@@ -439797,4 +437874,4 @@ export {
   metadata
 };
 
-//# debugId=26E444EEBE1833AC64756E2164756E21
+//# debugId=A74EFCE574A9618664756E2164756E21