@uipath/solution-tool 1.197.0 → 1.198.0-preview.101

package/dist/init.js

@@ -5063,31 +5063,17 @@ function search(data, expression, options) {
 }
 
 // ../../node_modules/js-yaml/dist/js-yaml.mjs
-/*! js-yaml 4.2.0 https://github.com/nodeca/js-yaml @license MIT */
-var __create2 = Object.create;
-var __defProp2 = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames2 = Object.getOwnPropertyNames;
-var __getProtoOf2 = Object.getPrototypeOf;
-var __hasOwnProp2 = Object.prototype.hasOwnProperty;
-var __commonJSMin = (cb, mod2) => () => (mod2 || (cb((mod2 = { exports: {} }).exports, mod2), cb = null), mod2.exports);
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function")
-    for (var keys = __getOwnPropNames2(from), i = 0, n = keys.length, key;i < n; i++) {
-      key = keys[i];
-      if (!__hasOwnProp2.call(to, key) && key !== except)
-        __defProp2(to, key, {
-          get: ((k) => from[k]).bind(null, key),
-          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-        });
-    }
-  return to;
-};
-var __toESM2 = (mod2, isNodeMode, target) => (target = mod2 != null ? __create2(__getProtoOf2(mod2)) : {}, __copyProps(isNodeMode || !mod2 || !mod2.__esModule ? __defProp2(target, "default", {
-  value: mod2,
-  enumerable: true
-}) : target, mod2));
-var require_common = /* @__PURE__ */ __commonJSMin((exports, module) => {
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+var jsYaml = {};
+var loader = {};
+var common = {};
+var hasRequiredCommon;
+function requireCommon() {
+  if (hasRequiredCommon)
+    return common;
+  hasRequiredCommon = 1;
   function isNothing(subject) {
     return typeof subject === "undefined" || subject === null;
   }
@@ -5113,55 +5099,71 @@ var require_common = /* @__PURE__ */ __commonJSMin((exports, module) => {
   }
   function repeat(string, count) {
     let result = "";
-    for (let cycle = 0;cycle < count; cycle += 1)
+    for (let cycle = 0;cycle < count; cycle += 1) {
       result += string;
+    }
     return result;
   }
   function isNegativeZero(number) {
     return number === 0 && Number.NEGATIVE_INFINITY === 1 / number;
   }
-  module.exports.isNothing = isNothing;
-  module.exports.isObject = isObject2;
-  module.exports.toArray = toArray;
-  module.exports.repeat = repeat;
-  module.exports.isNegativeZero = isNegativeZero;
-  module.exports.extend = extend;
-});
-var require_exception = /* @__PURE__ */ __commonJSMin((exports, module) => {
-  function formatError(exception, compact) {
+  common.isNothing = isNothing;
+  common.isObject = isObject2;
+  common.toArray = toArray;
+  common.repeat = repeat;
+  common.isNegativeZero = isNegativeZero;
+  common.extend = extend;
+  return common;
+}
+var exception;
+var hasRequiredException;
+function requireException() {
+  if (hasRequiredException)
+    return exception;
+  hasRequiredException = 1;
+  function formatError(exception2, compact) {
     let where = "";
-    const message = exception.reason || "(unknown reason)";
-    if (!exception.mark)
+    const message = exception2.reason || "(unknown reason)";
+    if (!exception2.mark)
       return message;
-    if (exception.mark.name)
-      where += 'in "' + exception.mark.name + '" ';
-    where += "(" + (exception.mark.line + 1) + ":" + (exception.mark.column + 1) + ")";
-    if (!compact && exception.mark.snippet)
+    if (exception2.mark.name) {
+      where += 'in "' + exception2.mark.name + '" ';
+    }
+    where += "(" + (exception2.mark.line + 1) + ":" + (exception2.mark.column + 1) + ")";
+    if (!compact && exception2.mark.snippet) {
       where += `
 
-` + exception.mark.snippet;
+` + exception2.mark.snippet;
+    }
     return message + " " + where;
   }
-  function YAMLException(reason, mark) {
+  function YAMLException2(reason, mark) {
     Error.call(this);
     this.name = "YAMLException";
     this.reason = reason;
     this.mark = mark;
     this.message = formatError(this, false);
-    if (Error.captureStackTrace)
+    if (Error.captureStackTrace) {
       Error.captureStackTrace(this, this.constructor);
-    else
-      this.stack = (/* @__PURE__ */ new Error()).stack || "";
+    } else {
+      this.stack = new Error().stack || "";
+    }
   }
-  YAMLException.prototype = Object.create(Error.prototype);
-  YAMLException.prototype.constructor = YAMLException;
-  YAMLException.prototype.toString = function toString(compact) {
+  YAMLException2.prototype = Object.create(Error.prototype);
+  YAMLException2.prototype.constructor = YAMLException2;
+  YAMLException2.prototype.toString = function toString(compact) {
     return this.name + ": " + formatError(this, compact);
   };
-  module.exports = YAMLException;
-});
-var require_snippet = /* @__PURE__ */ __commonJSMin((exports, module) => {
-  var common = require_common();
+  exception = YAMLException2;
+  return exception;
+}
+var snippet;
+var hasRequiredSnippet;
+function requireSnippet() {
+  if (hasRequiredSnippet)
+    return snippet;
+  hasRequiredSnippet = 1;
+  const common2 = requireCommon();
   function getLine(buffer, lineStart, lineEnd, position, maxLineLength) {
     let head = "";
     let tail = "";
@@ -5180,7 +5182,7 @@ var require_snippet = /* @__PURE__ */ __commonJSMin((exports, module) => {
     };
   }
   function padStart(string, max) {
-    return common.repeat(" ", max - string.length) + string;
+    return common2.repeat(" ", max - string.length) + string;
   }
   function makeSnippet(mark, options) {
     options = Object.create(options || null);
@@ -5202,8 +5204,9 @@ var require_snippet = /* @__PURE__ */ __commonJSMin((exports, module) => {
     while (match = re.exec(mark.buffer)) {
       lineEnds.push(match.index);
       lineStarts.push(match.index + match[0].length);
-      if (mark.position <= match.index && foundLineNo < 0)
+      if (mark.position <= match.index && foundLineNo < 0) {
         foundLineNo = lineStarts.length - 2;
+      }
     }
     if (foundLineNo < 0)
       foundLineNo = lineStarts.length - 1;
@@ -5214,28 +5217,34 @@ var require_snippet = /* @__PURE__ */ __commonJSMin((exports, module) => {
       if (foundLineNo - i < 0)
         break;
       const line2 = getLine(mark.buffer, lineStarts[foundLineNo - i], lineEnds[foundLineNo - i], mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo - i]), maxLineLength);
-      result = common.repeat(" ", options.indent) + padStart((mark.line - i + 1).toString(), lineNoLength) + " | " + line2.str + `
+      result = common2.repeat(" ", options.indent) + padStart((mark.line - i + 1).toString(), lineNoLength) + " | " + line2.str + `
 ` + result;
     }
     const line = getLine(mark.buffer, lineStarts[foundLineNo], lineEnds[foundLineNo], mark.position, maxLineLength);
-    result += common.repeat(" ", options.indent) + padStart((mark.line + 1).toString(), lineNoLength) + " | " + line.str + `
+    result += common2.repeat(" ", options.indent) + padStart((mark.line + 1).toString(), lineNoLength) + " | " + line.str + `
 `;
-    result += common.repeat("-", options.indent + lineNoLength + 3 + line.pos) + `^
+    result += common2.repeat("-", options.indent + lineNoLength + 3 + line.pos) + `^
 `;
     for (let i = 1;i <= options.linesAfter; i++) {
       if (foundLineNo + i >= lineEnds.length)
         break;
       const line2 = getLine(mark.buffer, lineStarts[foundLineNo + i], lineEnds[foundLineNo + i], mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo + i]), maxLineLength);
-      result += common.repeat(" ", options.indent) + padStart((mark.line + i + 1).toString(), lineNoLength) + " | " + line2.str + `
+      result += common2.repeat(" ", options.indent) + padStart((mark.line + i + 1).toString(), lineNoLength) + " | " + line2.str + `
 `;
     }
     return result.replace(/\n$/, "");
   }
-  module.exports = makeSnippet;
-});
-var require_type = /* @__PURE__ */ __commonJSMin((exports, module) => {
-  var YAMLException = require_exception();
-  var TYPE_CONSTRUCTOR_OPTIONS = [
+  snippet = makeSnippet;
+  return snippet;
+}
+var type;
+var hasRequiredType;
+function requireType() {
+  if (hasRequiredType)
+    return type;
+  hasRequiredType = 1;
+  const YAMLException2 = requireException();
+  const TYPE_CONSTRUCTOR_OPTIONS = [
     "kind",
     "multi",
     "resolve",
@@ -5247,26 +5256,28 @@ var require_type = /* @__PURE__ */ __commonJSMin((exports, module) => {
     "defaultStyle",
     "styleAliases"
   ];
-  var YAML_NODE_KINDS = [
+  const YAML_NODE_KINDS = [
     "scalar",
     "sequence",
     "mapping"
   ];
-  function compileStyleAliases(map) {
+  function compileStyleAliases(map2) {
     const result = {};
-    if (map !== null)
-      Object.keys(map).forEach(function(style) {
-        map[style].forEach(function(alias) {
+    if (map2 !== null) {
+      Object.keys(map2).forEach(function(style) {
+        map2[style].forEach(function(alias) {
           result[String(alias)] = style;
         });
       });
+    }
     return result;
   }
-  function Type(tag, options) {
+  function Type2(tag, options) {
     options = options || {};
     Object.keys(options).forEach(function(name) {
-      if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1)
-        throw new YAMLException('Unknown option "' + name + '" is met in definition of "' + tag + '" YAML type.');
+      if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) {
+        throw new YAMLException2('Unknown option "' + name + '" is met in definition of "' + tag + '" YAML type.');
+      }
     });
     this.options = options;
     this.tag = tag;
@@ -5284,21 +5295,29 @@ var require_type = /* @__PURE__ */ __commonJSMin((exports, module) => {
     this.defaultStyle = options["defaultStyle"] || null;
     this.multi = options["multi"] || false;
     this.styleAliases = compileStyleAliases(options["styleAliases"] || null);
-    if (YAML_NODE_KINDS.indexOf(this.kind) === -1)
-      throw new YAMLException('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.');
+    if (YAML_NODE_KINDS.indexOf(this.kind) === -1) {
+      throw new YAMLException2('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.');
+    }
   }
-  module.exports = Type;
-});
-var require_schema = /* @__PURE__ */ __commonJSMin((exports, module) => {
-  var YAMLException = require_exception();
-  var Type = require_type();
-  function compileList(schema, name) {
+  type = Type2;
+  return type;
+}
+var schema;
+var hasRequiredSchema;
+function requireSchema() {
+  if (hasRequiredSchema)
+    return schema;
+  hasRequiredSchema = 1;
+  const YAMLException2 = requireException();
+  const Type2 = requireType();
+  function compileList(schema2, name) {
     const result = [];
-    schema[name].forEach(function(currentType) {
+    schema2[name].forEach(function(currentType) {
       let newIndex = result.length;
       result.forEach(function(previousType, previousIndex) {
-        if (previousType.tag === currentType.tag && previousType.kind === currentType.kind && previousType.multi === currentType.multi)
+        if (previousType.tag === currentType.tag && previousType.kind === currentType.kind && previousType.multi === currentType.multi) {
           newIndex = previousIndex;
+        }
       });
       result[newIndex] = currentType;
     });
@@ -5317,47 +5336,54 @@ var require_schema = /* @__PURE__ */ __commonJSMin((exports, module) => {
         fallback: []
       }
     };
-    function collectType(type) {
-      if (type.multi) {
-        result.multi[type.kind].push(type);
-        result.multi["fallback"].push(type);
-      } else
-        result[type.kind][type.tag] = result["fallback"][type.tag] = type;
-    }
-    for (let index = 0, length = arguments.length;index < length; index += 1)
+    function collectType(type2) {
+      if (type2.multi) {
+        result.multi[type2.kind].push(type2);
+        result.multi["fallback"].push(type2);
+      } else {
+        result[type2.kind][type2.tag] = result["fallback"][type2.tag] = type2;
+      }
+    }
+    for (let index = 0, length = arguments.length;index < length; index += 1) {
       arguments[index].forEach(collectType);
+    }
     return result;
   }
-  function Schema(definition) {
+  function Schema2(definition) {
     return this.extend(definition);
   }
-  Schema.prototype.extend = function extend(definition) {
+  Schema2.prototype.extend = function extend(definition) {
     let implicit = [];
     let explicit = [];
-    if (definition instanceof Type)
+    if (definition instanceof Type2) {
       explicit.push(definition);
-    else if (Array.isArray(definition))
+    } else if (Array.isArray(definition)) {
       explicit = explicit.concat(definition);
-    else if (definition && (Array.isArray(definition.implicit) || Array.isArray(definition.explicit))) {
+    } else if (definition && (Array.isArray(definition.implicit) || Array.isArray(definition.explicit))) {
       if (definition.implicit)
         implicit = implicit.concat(definition.implicit);
       if (definition.explicit)
         explicit = explicit.concat(definition.explicit);
-    } else
-      throw new YAMLException("Schema.extend argument should be a Type, [ Type ], or a schema definition ({ implicit: [...], explicit: [...] })");
-    implicit.forEach(function(type) {
-      if (!(type instanceof Type))
-        throw new YAMLException("Specified list of YAML types (or a single Type object) contains a non-Type object.");
-      if (type.loadKind && type.loadKind !== "scalar")
-        throw new YAMLException("There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.");
-      if (type.multi)
-        throw new YAMLException("There is a multi type in the implicit list of a schema. Multi tags can only be listed as explicit.");
+    } else {
+      throw new YAMLException2("Schema.extend argument should be a Type, [ Type ], or a schema definition ({ implicit: [...], explicit: [...] })");
+    }
+    implicit.forEach(function(type2) {
+      if (!(type2 instanceof Type2)) {
+        throw new YAMLException2("Specified list of YAML types (or a single Type object) contains a non-Type object.");
+      }
+      if (type2.loadKind && type2.loadKind !== "scalar") {
+        throw new YAMLException2("There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.");
+      }
+      if (type2.multi) {
+        throw new YAMLException2("There is a multi type in the implicit list of a schema. Multi tags can only be listed as explicit.");
+      }
     });
-    explicit.forEach(function(type) {
-      if (!(type instanceof Type))
-        throw new YAMLException("Specified list of YAML types (or a single Type object) contains a non-Type object.");
+    explicit.forEach(function(type2) {
+      if (!(type2 instanceof Type2)) {
+        throw new YAMLException2("Specified list of YAML types (or a single Type object) contains a non-Type object.");
+      }
     });
-    const result = Object.create(Schema.prototype);
+    const result = Object.create(Schema2.prototype);
     result.implicit = (this.implicit || []).concat(implicit);
     result.explicit = (this.explicit || []).concat(explicit);
     result.compiledImplicit = compileList(result, "implicit");
@@ -5365,41 +5391,77 @@ var require_schema = /* @__PURE__ */ __commonJSMin((exports, module) => {
     result.compiledTypeMap = compileMap(result.compiledImplicit, result.compiledExplicit);
     return result;
   };
-  module.exports = Schema;
-});
-var require_str = /* @__PURE__ */ __commonJSMin((exports, module) => {
-  module.exports = new (require_type())("tag:yaml.org,2002:str", {
+  schema = Schema2;
+  return schema;
+}
+var str;
+var hasRequiredStr;
+function requireStr() {
+  if (hasRequiredStr)
+    return str;
+  hasRequiredStr = 1;
+  const Type2 = requireType();
+  str = new Type2("tag:yaml.org,2002:str", {
     kind: "scalar",
     construct: function(data) {
       return data !== null ? data : "";
     }
   });
-});
-var require_seq = /* @__PURE__ */ __commonJSMin((exports, module) => {
-  module.exports = new (require_type())("tag:yaml.org,2002:seq", {
+  return str;
+}
+var seq;
+var hasRequiredSeq;
+function requireSeq() {
+  if (hasRequiredSeq)
+    return seq;
+  hasRequiredSeq = 1;
+  const Type2 = requireType();
+  seq = new Type2("tag:yaml.org,2002:seq", {
     kind: "sequence",
     construct: function(data) {
       return data !== null ? data : [];
     }
   });
-});
-var require_map = /* @__PURE__ */ __commonJSMin((exports, module) => {
-  module.exports = new (require_type())("tag:yaml.org,2002:map", {
+  return seq;
+}
+var map;
+var hasRequiredMap;
+function requireMap() {
+  if (hasRequiredMap)
+    return map;
+  hasRequiredMap = 1;
+  const Type2 = requireType();
+  map = new Type2("tag:yaml.org,2002:map", {
     kind: "mapping",
     construct: function(data) {
       return data !== null ? data : {};
     }
   });
-});
-var require_failsafe = /* @__PURE__ */ __commonJSMin((exports, module) => {
-  module.exports = new (require_schema())({ explicit: [
-    require_str(),
-    require_seq(),
-    require_map()
-  ] });
-});
-var require_null = /* @__PURE__ */ __commonJSMin((exports, module) => {
-  var Type = require_type();
+  return map;
+}
+var failsafe;
+var hasRequiredFailsafe;
+function requireFailsafe() {
+  if (hasRequiredFailsafe)
+    return failsafe;
+  hasRequiredFailsafe = 1;
+  const Schema2 = requireSchema();
+  failsafe = new Schema2({
+    explicit: [
+      requireStr(),
+      requireSeq(),
+      requireMap()
+    ]
+  });
+  return failsafe;
+}
+var _null;
+var hasRequired_null;
+function require_null() {
+  if (hasRequired_null)
+    return _null;
+  hasRequired_null = 1;
+  const Type2 = requireType();
   function resolveYamlNull(data) {
     if (data === null)
       return true;
@@ -5412,7 +5474,7 @@ var require_null = /* @__PURE__ */ __commonJSMin((exports, module) => {
   function isNull(object) {
     return object === null;
   }
-  module.exports = new Type("tag:yaml.org,2002:null", {
+  _null = new Type2("tag:yaml.org,2002:null", {
     kind: "scalar",
     resolve: resolveYamlNull,
     construct: constructYamlNull,
@@ -5436,9 +5498,15 @@ var require_null = /* @__PURE__ */ __commonJSMin((exports, module) => {
     },
     defaultStyle: "lowercase"
   });
-});
-var require_bool = /* @__PURE__ */ __commonJSMin((exports, module) => {
-  var Type = require_type();
+  return _null;
+}
+var bool;
+var hasRequiredBool;
+function requireBool() {
+  if (hasRequiredBool)
+    return bool;
+  hasRequiredBool = 1;
+  const Type2 = requireType();
   function resolveYamlBoolean(data) {
     if (data === null)
       return false;
@@ -5451,7 +5519,7 @@ var require_bool = /* @__PURE__ */ __commonJSMin((exports, module) => {
   function isBoolean(object) {
     return Object.prototype.toString.call(object) === "[object Boolean]";
   }
-  module.exports = new Type("tag:yaml.org,2002:bool", {
+  bool = new Type2("tag:yaml.org,2002:bool", {
     kind: "scalar",
     resolve: resolveYamlBoolean,
     construct: constructYamlBoolean,
@@ -5469,10 +5537,16 @@ var require_bool = /* @__PURE__ */ __commonJSMin((exports, module) => {
     },
     defaultStyle: "lowercase"
   });
-});
-var require_int = /* @__PURE__ */ __commonJSMin((exports, module) => {
-  var common = require_common();
-  var Type = require_type();
+  return bool;
+}
+var int;
+var hasRequiredInt;
+function requireInt() {
+  if (hasRequiredInt)
+    return int;
+  hasRequiredInt = 1;
+  const common2 = requireCommon();
+  const Type2 = requireType();
   function isHexCode(c) {
     return c >= 48 && c <= 57 || c >= 65 && c <= 70 || c >= 97 && c <= 102;
   }
@@ -5491,8 +5565,9 @@ var require_int = /* @__PURE__ */ __commonJSMin((exports, module) => {
     if (!max)
       return false;
     let ch = data[index];
-    if (ch === "-" || ch === "+")
+    if (ch === "-" || ch === "+") {
       ch = data[++index];
+    }
     if (ch === "0") {
       if (index + 1 === max)
         return true;
@@ -5505,7 +5580,7 @@ var require_int = /* @__PURE__ */ __commonJSMin((exports, module) => {
             return false;
           hasDigits = true;
         }
-        return hasDigits && Number.isFinite(parseYamlInteger(data));
+        return hasDigits && isFinite(parseYamlInteger(data));
       }
       if (ch === "x") {
         index++;
@@ -5514,7 +5589,7 @@ var require_int = /* @__PURE__ */ __commonJSMin((exports, module) => {
             return false;
           hasDigits = true;
         }
-        return hasDigits && Number.isFinite(parseYamlInteger(data));
+        return hasDigits && isFinite(parseYamlInteger(data));
       }
       if (ch === "o") {
         index++;
@@ -5523,17 +5598,18 @@ var require_int = /* @__PURE__ */ __commonJSMin((exports, module) => {
             return false;
           hasDigits = true;
         }
-        return hasDigits && Number.isFinite(parseYamlInteger(data));
+        return hasDigits && isFinite(parseYamlInteger(data));
       }
     }
     for (;index < max; index++) {
-      if (!isDecCode(data.charCodeAt(index)))
+      if (!isDecCode(data.charCodeAt(index))) {
         return false;
+      }
       hasDigits = true;
     }
     if (!hasDigits)
       return false;
-    return Number.isFinite(parseYamlInteger(data));
+    return isFinite(parseYamlInteger(data));
   }
   function parseYamlInteger(data) {
     let value = data;
@@ -5561,9 +5637,9 @@ var require_int = /* @__PURE__ */ __commonJSMin((exports, module) => {
     return parseYamlInteger(data);
   }
   function isInteger(object) {
-    return Object.prototype.toString.call(object) === "[object Number]" && object % 1 === 0 && !common.isNegativeZero(object);
+    return Object.prototype.toString.call(object) === "[object Number]" && (object % 1 === 0 && !common2.isNegativeZero(object));
   }
-  module.exports = new Type("tag:yaml.org,2002:int", {
+  int = new Type2("tag:yaml.org,2002:int", {
     kind: "scalar",
     resolve: resolveYamlInteger,
     construct: constructYamlInteger,
@@ -5590,35 +5666,45 @@ var require_int = /* @__PURE__ */ __commonJSMin((exports, module) => {
       hexadecimal: [16, "hex"]
     }
   });
-});
-var require_float = /* @__PURE__ */ __commonJSMin((exports, module) => {
-  var common = require_common();
-  var Type = require_type();
-  var YAML_FLOAT_PATTERN = /* @__PURE__ */ new RegExp("^(?:[-+]?(?:[0-9]+)(?:\\.[0-9]*)?(?:[eE][-+]?[0-9]+)?|\\.[0-9]+(?:[eE][-+]?[0-9]+)?|[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$");
-  var YAML_FLOAT_SPECIAL_PATTERN = /* @__PURE__ */ new RegExp("^(?:[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$");
+  return int;
+}
+var float;
+var hasRequiredFloat;
+function requireFloat() {
+  if (hasRequiredFloat)
+    return float;
+  hasRequiredFloat = 1;
+  const common2 = requireCommon();
+  const Type2 = requireType();
+  const YAML_FLOAT_PATTERN = new RegExp("^(?:[-+]?(?:[0-9]+)(?:\\.[0-9]*)?(?:[eE][-+]?[0-9]+)?|\\.[0-9]+(?:[eE][-+]?[0-9]+)?|[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$");
+  const YAML_FLOAT_SPECIAL_PATTERN = new RegExp("^(?:[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$");
   function resolveYamlFloat(data) {
     if (data === null)
       return false;
-    if (!YAML_FLOAT_PATTERN.test(data))
+    if (!YAML_FLOAT_PATTERN.test(data)) {
       return false;
-    if (Number.isFinite(parseFloat(data, 10)))
+    }
+    if (isFinite(parseFloat(data, 10))) {
       return true;
+    }
     return YAML_FLOAT_SPECIAL_PATTERN.test(data);
   }
   function constructYamlFloat(data) {
     let value = data.toLowerCase();
     const sign = value[0] === "-" ? -1 : 1;
-    if ("+-".indexOf(value[0]) >= 0)
+    if ("+-".indexOf(value[0]) >= 0) {
       value = value.slice(1);
-    if (value === ".inf")
+    }
+    if (value === ".inf") {
       return sign === 1 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
-    else if (value === ".nan")
+    } else if (value === ".nan") {
       return NaN;
+    }
     return sign * parseFloat(value, 10);
   }
-  var SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/;
+  const SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/;
   function representYamlFloat(object, style) {
-    if (isNaN(object))
+    if (isNaN(object)) {
       switch (style) {
         case "lowercase":
           return ".nan";
@@ -5627,7 +5713,7 @@ var require_float = /* @__PURE__ */ __commonJSMin((exports, module) => {
         case "camelcase":
           return ".NaN";
       }
-    else if (Number.POSITIVE_INFINITY === object)
+    } else if (Number.POSITIVE_INFINITY === object) {
       switch (style) {
         case "lowercase":
           return ".inf";
@@ -5636,7 +5722,7 @@ var require_float = /* @__PURE__ */ __commonJSMin((exports, module) => {
         case "camelcase":
           return ".Inf";
       }
-    else if (Number.NEGATIVE_INFINITY === object)
+    } else if (Number.NEGATIVE_INFINITY === object) {
       switch (style) {
         case "lowercase":
           return "-.inf";
@@ -5645,15 +5731,16 @@ var require_float = /* @__PURE__ */ __commonJSMin((exports, module) => {
         case "camelcase":
           return "-.Inf";
       }
-    else if (common.isNegativeZero(object))
+    } else if (common2.isNegativeZero(object)) {
       return "-0.0";
+    }
     const res = object.toString(10);
     return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace("e", ".e") : res;
   }
   function isFloat(object) {
-    return Object.prototype.toString.call(object) === "[object Number]" && (object % 1 !== 0 || common.isNegativeZero(object));
+    return Object.prototype.toString.call(object) === "[object Number]" && (object % 1 !== 0 || common2.isNegativeZero(object));
   }
-  module.exports = new Type("tag:yaml.org,2002:float", {
+  float = new Type2("tag:yaml.org,2002:float", {
     kind: "scalar",
     resolve: resolveYamlFloat,
     construct: constructYamlFloat,
@@ -5661,22 +5748,42 @@ var require_float = /* @__PURE__ */ __commonJSMin((exports, module) => {
     represent: representYamlFloat,
     defaultStyle: "lowercase"
   });
-});
-var require_json = /* @__PURE__ */ __commonJSMin((exports, module) => {
-  module.exports = require_failsafe().extend({ implicit: [
-    require_null(),
-    require_bool(),
-    require_int(),
-    require_float()
-  ] });
-});
-var require_core = /* @__PURE__ */ __commonJSMin((exports, module) => {
-  module.exports = require_json();
-});
-var require_timestamp = /* @__PURE__ */ __commonJSMin((exports, module) => {
-  var Type = require_type();
-  var YAML_DATE_REGEXP = /* @__PURE__ */ new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9])-([0-9][0-9])$");
-  var YAML_TIMESTAMP_REGEXP = /* @__PURE__ */ new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9]?)-([0-9][0-9]?)(?:[Tt]|[ \\t]+)([0-9][0-9]?):([0-9][0-9]):([0-9][0-9])(?:\\.([0-9]*))?(?:[ \\t]*(Z|([-+])([0-9][0-9]?)(?::([0-9][0-9]))?))?$");
+  return float;
+}
+var json;
+var hasRequiredJson;
+function requireJson() {
+  if (hasRequiredJson)
+    return json;
+  hasRequiredJson = 1;
+  json = requireFailsafe().extend({
+    implicit: [
+      require_null(),
+      requireBool(),
+      requireInt(),
+      requireFloat()
+    ]
+  });
+  return json;
+}
+var core;
+var hasRequiredCore;
+function requireCore() {
+  if (hasRequiredCore)
+    return core;
+  hasRequiredCore = 1;
+  core = requireJson();
+  return core;
+}
+var timestamp;
+var hasRequiredTimestamp;
+function requireTimestamp() {
+  if (hasRequiredTimestamp)
+    return timestamp;
+  hasRequiredTimestamp = 1;
+  const Type2 = requireType();
+  const YAML_DATE_REGEXP = new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9])-([0-9][0-9])$");
+  const YAML_TIMESTAMP_REGEXP = new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9]?)-([0-9][0-9]?)(?:[Tt]|[ \\t]+)([0-9][0-9]?):([0-9][0-9]):([0-9][0-9])(?:\\.([0-9]*))?(?:[ \\t]*(Z|([-+])([0-9][0-9]?)(?::([0-9][0-9]))?))?$");
   function resolveYamlTimestamp(data) {
     if (data === null)
       return false;
@@ -5697,15 +5804,17 @@ var require_timestamp = /* @__PURE__ */ __commonJSMin((exports, module) => {
     const year = +match[1];
     const month = +match[2] - 1;
     const day = +match[3];
-    if (!match[4])
+    if (!match[4]) {
       return new Date(Date.UTC(year, month, day));
+    }
     const hour = +match[4];
     const minute = +match[5];
     const second = +match[6];
     if (match[7]) {
       fraction = match[7].slice(0, 3);
-      while (fraction.length < 3)
+      while (fraction.length < 3) {
         fraction += "0";
+      }
       fraction = +fraction;
     }
     if (match[9]) {
@@ -5723,36 +5832,48 @@ var require_timestamp = /* @__PURE__ */ __commonJSMin((exports, module) => {
   function representYamlTimestamp(object) {
     return object.toISOString();
   }
-  module.exports = new Type("tag:yaml.org,2002:timestamp", {
+  timestamp = new Type2("tag:yaml.org,2002:timestamp", {
     kind: "scalar",
     resolve: resolveYamlTimestamp,
     construct: constructYamlTimestamp,
     instanceOf: Date,
     represent: representYamlTimestamp
   });
-});
-var require_merge = /* @__PURE__ */ __commonJSMin((exports, module) => {
-  var Type = require_type();
+  return timestamp;
+}
+var merge;
+var hasRequiredMerge;
+function requireMerge() {
+  if (hasRequiredMerge)
+    return merge;
+  hasRequiredMerge = 1;
+  const Type2 = requireType();
   function resolveYamlMerge(data) {
     return data === "<<" || data === null;
   }
-  module.exports = new Type("tag:yaml.org,2002:merge", {
+  merge = new Type2("tag:yaml.org,2002:merge", {
     kind: "scalar",
     resolve: resolveYamlMerge
   });
-});
-var require_binary = /* @__PURE__ */ __commonJSMin((exports, module) => {
-  var Type = require_type();
-  var BASE64_MAP = `ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=
+  return merge;
+}
+var binary;
+var hasRequiredBinary;
+function requireBinary() {
+  if (hasRequiredBinary)
+    return binary;
+  hasRequiredBinary = 1;
+  const Type2 = requireType();
+  const BASE64_MAP = `ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=
 \r`;
   function resolveYamlBinary(data) {
     if (data === null)
       return false;
     let bitlen = 0;
     const max = data.length;
-    const map = BASE64_MAP;
+    const map2 = BASE64_MAP;
     for (let idx = 0;idx < max; idx++) {
-      const code = map.indexOf(data.charAt(idx));
+      const code = map2.indexOf(data.charAt(idx));
       if (code > 64)
         continue;
       if (code < 0)
@@ -5764,7 +5885,7 @@ var require_binary = /* @__PURE__ */ __commonJSMin((exports, module) => {
   function constructYamlBinary(data) {
     const input = data.replace(/[\r\n=]/g, "");
     const max = input.length;
-    const map = BASE64_MAP;
+    const map2 = BASE64_MAP;
     let bits = 0;
     const result = [];
     for (let idx = 0;idx < max; idx++) {
@@ -5773,7 +5894,7 @@ var require_binary = /* @__PURE__ */ __commonJSMin((exports, module) => {
         result.push(bits >> 8 & 255);
         result.push(bits & 255);
       }
-      bits = bits << 6 | map.indexOf(input.charAt(idx));
+      bits = bits << 6 | map2.indexOf(input.charAt(idx));
     }
     const tailbits = max % 4 * 6;
     if (tailbits === 0) {
@@ -5783,58 +5904,65 @@ var require_binary = /* @__PURE__ */ __commonJSMin((exports, module) => {
     } else if (tailbits === 18) {
       result.push(bits >> 10 & 255);
       result.push(bits >> 2 & 255);
-    } else if (tailbits === 12)
+    } else if (tailbits === 12) {
       result.push(bits >> 4 & 255);
+    }
     return new Uint8Array(result);
   }
   function representYamlBinary(object) {
     let result = "";
     let bits = 0;
     const max = object.length;
-    const map = BASE64_MAP;
+    const map2 = BASE64_MAP;
     for (let idx = 0;idx < max; idx++) {
       if (idx % 3 === 0 && idx) {
-        result += map[bits >> 18 & 63];
-        result += map[bits >> 12 & 63];
-        result += map[bits >> 6 & 63];
-        result += map[bits & 63];
+        result += map2[bits >> 18 & 63];
+        result += map2[bits >> 12 & 63];
+        result += map2[bits >> 6 & 63];
+        result += map2[bits & 63];
       }
       bits = (bits << 8) + object[idx];
     }
     const tail = max % 3;
     if (tail === 0) {
-      result += map[bits >> 18 & 63];
-      result += map[bits >> 12 & 63];
-      result += map[bits >> 6 & 63];
-      result += map[bits & 63];
+      result += map2[bits >> 18 & 63];
+      result += map2[bits >> 12 & 63];
+      result += map2[bits >> 6 & 63];
+      result += map2[bits & 63];
     } else if (tail === 2) {
-      result += map[bits >> 10 & 63];
-      result += map[bits >> 4 & 63];
-      result += map[bits << 2 & 63];
-      result += map[64];
+      result += map2[bits >> 10 & 63];
+      result += map2[bits >> 4 & 63];
+      result += map2[bits << 2 & 63];
+      result += map2[64];
     } else if (tail === 1) {
-      result += map[bits >> 2 & 63];
-      result += map[bits << 4 & 63];
-      result += map[64];
-      result += map[64];
+      result += map2[bits >> 2 & 63];
+      result += map2[bits << 4 & 63];
+      result += map2[64];
+      result += map2[64];
     }
     return result;
   }
   function isBinary(obj) {
     return Object.prototype.toString.call(obj) === "[object Uint8Array]";
   }
-  module.exports = new Type("tag:yaml.org,2002:binary", {
+  binary = new Type2("tag:yaml.org,2002:binary", {
     kind: "scalar",
     resolve: resolveYamlBinary,
     construct: constructYamlBinary,
     predicate: isBinary,
     represent: representYamlBinary
   });
-});
-var require_omap = /* @__PURE__ */ __commonJSMin((exports, module) => {
-  var Type = require_type();
-  var _hasOwnProperty = Object.prototype.hasOwnProperty;
-  var _toString = Object.prototype.toString;
+  return binary;
+}
+var omap;
+var hasRequiredOmap;
+function requireOmap() {
+  if (hasRequiredOmap)
+    return omap;
+  hasRequiredOmap = 1;
+  const Type2 = requireType();
+  const _hasOwnProperty = Object.prototype.hasOwnProperty;
+  const _toString = Object.prototype.toString;
   function resolveYamlOmap(data) {
     if (data === null)
       return true;
@@ -5846,12 +5974,14 @@ var require_omap = /* @__PURE__ */ __commonJSMin((exports, module) => {
       if (_toString.call(pair) !== "[object Object]")
         return false;
       let pairKey;
-      for (pairKey in pair)
-        if (_hasOwnProperty.call(pair, pairKey))
+      for (pairKey in pair) {
+        if (_hasOwnProperty.call(pair, pairKey)) {
           if (!pairHasKey)
             pairHasKey = true;
           else
             return false;
+        }
+      }
       if (!pairHasKey)
         return false;
       if (objectKeys.indexOf(pairKey) === -1)
@@ -5864,15 +5994,21 @@ var require_omap = /* @__PURE__ */ __commonJSMin((exports, module) => {
   function constructYamlOmap(data) {
     return data !== null ? data : [];
   }
-  module.exports = new Type("tag:yaml.org,2002:omap", {
+  omap = new Type2("tag:yaml.org,2002:omap", {
     kind: "sequence",
     resolve: resolveYamlOmap,
     construct: constructYamlOmap
   });
-});
-var require_pairs = /* @__PURE__ */ __commonJSMin((exports, module) => {
-  var Type = require_type();
-  var _toString = Object.prototype.toString;
+  return omap;
+}
+var pairs;
+var hasRequiredPairs;
+function requirePairs() {
+  if (hasRequiredPairs)
+    return pairs;
+  hasRequiredPairs = 1;
+  const Type2 = requireType();
+  const _toString = Object.prototype.toString;
   function resolveYamlPairs(data) {
     if (data === null)
       return true;
@@ -5901,64 +6037,85 @@ var require_pairs = /* @__PURE__ */ __commonJSMin((exports, module) => {
     }
     return result;
   }
-  module.exports = new Type("tag:yaml.org,2002:pairs", {
+  pairs = new Type2("tag:yaml.org,2002:pairs", {
     kind: "sequence",
     resolve: resolveYamlPairs,
     construct: constructYamlPairs
   });
-});
-var require_set = /* @__PURE__ */ __commonJSMin((exports, module) => {
-  var Type = require_type();
-  var _hasOwnProperty = Object.prototype.hasOwnProperty;
+  return pairs;
+}
+var set;
+var hasRequiredSet;
+function requireSet() {
+  if (hasRequiredSet)
+    return set;
+  hasRequiredSet = 1;
+  const Type2 = requireType();
+  const _hasOwnProperty = Object.prototype.hasOwnProperty;
   function resolveYamlSet(data) {
     if (data === null)
       return true;
     const object = data;
-    for (const key in object)
+    for (const key in object) {
       if (_hasOwnProperty.call(object, key)) {
         if (object[key] !== null)
           return false;
       }
+    }
     return true;
   }
   function constructYamlSet(data) {
     return data !== null ? data : {};
   }
-  module.exports = new Type("tag:yaml.org,2002:set", {
+  set = new Type2("tag:yaml.org,2002:set", {
     kind: "mapping",
     resolve: resolveYamlSet,
     construct: constructYamlSet
   });
-});
-var require_default = /* @__PURE__ */ __commonJSMin((exports, module) => {
-  module.exports = require_core().extend({
-    implicit: [require_timestamp(), require_merge()],
+  return set;
+}
+var _default;
+var hasRequired_default;
+function require_default() {
+  if (hasRequired_default)
+    return _default;
+  hasRequired_default = 1;
+  _default = requireCore().extend({
+    implicit: [
+      requireTimestamp(),
+      requireMerge()
+    ],
     explicit: [
-      require_binary(),
-      require_omap(),
-      require_pairs(),
-      require_set()
+      requireBinary(),
+      requireOmap(),
+      requirePairs(),
+      requireSet()
     ]
   });
-});
-var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
-  var common = require_common();
-  var YAMLException = require_exception();
-  var makeSnippet = require_snippet();
-  var DEFAULT_SCHEMA = require_default();
-  var _hasOwnProperty = Object.prototype.hasOwnProperty;
-  var CONTEXT_FLOW_IN = 1;
-  var CONTEXT_FLOW_OUT = 2;
-  var CONTEXT_BLOCK_IN = 3;
-  var CONTEXT_BLOCK_OUT = 4;
-  var CHOMPING_CLIP = 1;
-  var CHOMPING_STRIP = 2;
-  var CHOMPING_KEEP = 3;
-  var PATTERN_NON_PRINTABLE = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
-  var PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/;
-  var PATTERN_FLOW_INDICATORS = /[,\[\]{}]/;
-  var PATTERN_TAG_HANDLE = /^(?:!|!!|![0-9A-Za-z-]+!)$/;
-  var PATTERN_TAG_URI = /^(?:!|[^,\[\]{}])(?:%[0-9a-f]{2}|[0-9a-z\-#;/?:@&=+$,_.!~*'()\[\]])*$/i;
+  return _default;
+}
+var hasRequiredLoader;
+function requireLoader() {
+  if (hasRequiredLoader)
+    return loader;
+  hasRequiredLoader = 1;
+  const common2 = requireCommon();
+  const YAMLException2 = requireException();
+  const makeSnippet = requireSnippet();
+  const DEFAULT_SCHEMA2 = require_default();
+  const _hasOwnProperty = Object.prototype.hasOwnProperty;
+  const CONTEXT_FLOW_IN = 1;
+  const CONTEXT_FLOW_OUT = 2;
+  const CONTEXT_BLOCK_IN = 3;
+  const CONTEXT_BLOCK_OUT = 4;
+  const CHOMPING_CLIP = 1;
+  const CHOMPING_STRIP = 2;
+  const CHOMPING_KEEP = 3;
+  const PATTERN_NON_PRINTABLE = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
+  const PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/;
+  const PATTERN_FLOW_INDICATORS = /[,\[\]{}]/;
+  const PATTERN_TAG_HANDLE = /^(?:!|!!|![0-9A-Za-z-]+!)$/;
+  const PATTERN_TAG_URI = /^(?:!|[^,\[\]{}])(?:%[0-9a-f]{2}|[0-9a-z\-#;/?:@&=+$,_.!~*'()\[\]])*$/i;
   function _class(obj) {
     return Object.prototype.toString.call(obj);
   }
@@ -5975,25 +6132,31 @@ var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
     return c === 44 || c === 91 || c === 93 || c === 123 || c === 125;
   }
   function fromHexCode(c) {
-    if (c >= 48 && c <= 57)
+    if (c >= 48 && c <= 57) {
       return c - 48;
+    }
     const lc = c | 32;
-    if (lc >= 97 && lc <= 102)
+    if (lc >= 97 && lc <= 102) {
       return lc - 97 + 10;
+    }
     return -1;
   }
   function escapedHexLen(c) {
-    if (c === 120)
+    if (c === 120) {
       return 2;
-    if (c === 117)
+    }
+    if (c === 117) {
       return 4;
-    if (c === 85)
+    }
+    if (c === 85) {
       return 8;
+    }
     return 0;
   }
   function fromDecimalCode(c) {
-    if (c >= 48 && c <= 57)
+    if (c >= 48 && c <= 57) {
       return c - 48;
+    }
     return -1;
   }
   function simpleEscapeSequence(c) {
@@ -6040,23 +6203,25 @@ var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
     }
   }
   function charFromCodepoint(c) {
-    if (c <= 65535)
+    if (c <= 65535) {
       return String.fromCharCode(c);
+    }
     return String.fromCharCode((c - 65536 >> 10) + 55296, (c - 65536 & 1023) + 56320);
   }
   function setProperty(object, key, value) {
-    if (key === "__proto__")
+    if (key === "__proto__") {
       Object.defineProperty(object, key, {
         configurable: true,
         enumerable: true,
         writable: true,
         value
       });
-    else
+    } else {
       object[key] = value;
+    }
   }
-  var simpleEscapeCheck = new Array(256);
-  var simpleEscapeMap = new Array(256);
+  const simpleEscapeCheck = new Array(256);
+  const simpleEscapeMap = new Array(256);
   for (let i = 0;i < 256; i++) {
     simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0;
     simpleEscapeMap[i] = simpleEscapeSequence(i);
@@ -6064,13 +6229,13 @@ var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
   function State(input, options) {
     this.input = input;
     this.filename = options["filename"] || null;
-    this.schema = options["schema"] || DEFAULT_SCHEMA;
+    this.schema = options["schema"] || DEFAULT_SCHEMA2;
     this.onWarning = options["onWarning"] || null;
     this.legacy = options["legacy"] || false;
     this.json = options["json"] || false;
     this.listener = options["listener"] || null;
     this.maxDepth = typeof options["maxDepth"] === "number" ? options["maxDepth"] : 100;
-    this.maxMergeSeqLength = typeof options["maxMergeSeqLength"] === "number" ? options["maxMergeSeqLength"] : 20;
+    this.maxTotalMergeKeys = typeof options["maxTotalMergeKeys"] === "number" ? options["maxTotalMergeKeys"] : 1e4;
     this.implicitTypes = this.schema.compiledImplicit;
     this.typeMap = this.schema.compiledTypeMap;
     this.length = input.length;
@@ -6079,6 +6244,7 @@ var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
     this.lineStart = 0;
     this.lineIndent = 0;
     this.depth = 0;
+    this.totalMergeKeys = 0;
     this.firstTabInLine = -1;
     this.documents = [];
     this.anchorMapTransactions = [];
@@ -6092,29 +6258,31 @@ var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
       column: state.position - state.lineStart
     };
     mark.snippet = makeSnippet(mark);
-    return new YAMLException(message, mark);
+    return new YAMLException2(message, mark);
   }
   function throwError(state, message) {
     throw generateError(state, message);
   }
   function throwWarning(state, message) {
-    if (state.onWarning)
+    if (state.onWarning) {
       state.onWarning.call(null, generateError(state, message));
+    }
   }
   function storeAnchor(state, name, value) {
     const transactions = state.anchorMapTransactions;
     if (transactions.length !== 0) {
       const transaction = transactions[transactions.length - 1];
-      if (!_hasOwnProperty.call(transaction, name))
+      if (!_hasOwnProperty.call(transaction, name)) {
         transaction[name] = {
           existed: _hasOwnProperty.call(state.anchorMap, name),
           value: state.anchorMap[name]
         };
+      }
     }
     state.anchorMap[name] = value;
   }
   function beginAnchorTransaction(state) {
-    state.anchorMapTransactions.push(Object.create(null));
+    state.anchorMapTransactions.push(/* @__PURE__ */ Object.create(null));
   }
   function commitAnchorTransaction(state) {
     const transaction = state.anchorMapTransactions.pop();
@@ -6125,8 +6293,9 @@ var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
     const names = Object.keys(transaction);
     for (let index = 0, length = names.length;index < length; index += 1) {
       const name = names[index];
-      if (!_hasOwnProperty.call(parent, name))
+      if (!_hasOwnProperty.call(parent, name)) {
         parent[name] = transaction[name];
+      }
     }
   }
   function rollbackAnchorTransaction(state) {
@@ -6134,10 +6303,11 @@ var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
     const names = Object.keys(transaction);
     for (let index = names.length - 1;index >= 0; index -= 1) {
       const entry = transaction[names[index]];
-      if (entry.existed)
+      if (entry.existed) {
         state.anchorMap[names[index]] = entry.value;
-      else
+      } else {
         delete state.anchorMap[names[index]];
+      }
     }
   }
   function snapshotState(state) {
@@ -6164,36 +6334,45 @@ var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
     state.kind = snapshot.kind;
     state.result = snapshot.result;
   }
-  var directiveHandlers = {
+  const directiveHandlers = {
     YAML: function handleYamlDirective(state, name, args) {
-      if (state.version !== null)
+      if (state.version !== null) {
         throwError(state, "duplication of %YAML directive");
-      if (args.length !== 1)
+      }
+      if (args.length !== 1) {
         throwError(state, "YAML directive accepts exactly one argument");
+      }
       const match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]);
-      if (match === null)
+      if (match === null) {
         throwError(state, "ill-formed argument of the YAML directive");
+      }
       const major = parseInt(match[1], 10);
       const minor = parseInt(match[2], 10);
-      if (major !== 1)
+      if (major !== 1) {
         throwError(state, "unacceptable YAML version of the document");
+      }
       state.version = args[0];
       state.checkLineBreaks = minor < 2;
-      if (minor !== 1 && minor !== 2)
+      if (minor !== 1 && minor !== 2) {
         throwWarning(state, "unsupported YAML version of the document");
+      }
     },
     TAG: function handleTagDirective(state, name, args) {
       let prefix;
-      if (args.length !== 2)
+      if (args.length !== 2) {
         throwError(state, "TAG directive accepts exactly two arguments");
+      }
       const handle = args[0];
       prefix = args[1];
-      if (!PATTERN_TAG_HANDLE.test(handle))
+      if (!PATTERN_TAG_HANDLE.test(handle)) {
         throwError(state, "ill-formed tag handle (first argument) of the TAG directive");
-      if (_hasOwnProperty.call(state.tagMap, handle))
+      }
+      if (_hasOwnProperty.call(state.tagMap, handle)) {
         throwError(state, 'there is a previously declared suffix for "' + handle + '" tag handle');
-      if (!PATTERN_TAG_URI.test(prefix))
+      }
+      if (!PATTERN_TAG_URI.test(prefix)) {
         throwError(state, "ill-formed tag prefix (second argument) of the TAG directive");
+      }
       try {
         prefix = decodeURIComponent(prefix);
       } catch (err) {
@@ -6205,23 +6384,29 @@ var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
   function captureSegment(state, start, end, checkJson) {
     if (start < end) {
       const _result = state.input.slice(start, end);
-      if (checkJson)
+      if (checkJson) {
         for (let _position = 0, _length = _result.length;_position < _length; _position += 1) {
           const _character = _result.charCodeAt(_position);
-          if (!(_character === 9 || _character >= 32 && _character <= 1114111))
+          if (!(_character === 9 || _character >= 32 && _character <= 1114111)) {
             throwError(state, "expected valid JSON character");
+          }
         }
-      else if (PATTERN_NON_PRINTABLE.test(_result))
+      } else if (PATTERN_NON_PRINTABLE.test(_result)) {
         throwError(state, "the stream contains non-printable characters");
+      }
       state.result += _result;
     }
   }
   function mergeMappings(state, destination, source, overridableKeys) {
-    if (!common.isObject(source))
+    if (!common2.isObject(source)) {
       throwError(state, "cannot merge mappings; the provided source object is unacceptable");
+    }
     const sourceKeys = Object.keys(source);
     for (let index = 0, quantity = sourceKeys.length;index < quantity; index += 1) {
       const key = sourceKeys[index];
+      if (state.maxTotalMergeKeys !== -1 && ++state.totalMergeKeys > state.maxTotalMergeKeys) {
+        throwError(state, "merge keys exceeded maxTotalMergeKeys (" + state.maxTotalMergeKeys + ")");
+      }
       if (!_hasOwnProperty.call(destination, key)) {
         setProperty(destination, key, source[key]);
         overridableKeys[key] = true;
@@ -6232,32 +6417,30 @@ var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
     if (Array.isArray(keyNode)) {
       keyNode = Array.prototype.slice.call(keyNode);
       for (let index = 0, quantity = keyNode.length;index < quantity; index += 1) {
-        if (Array.isArray(keyNode[index]))
+        if (Array.isArray(keyNode[index])) {
           throwError(state, "nested arrays are not supported inside keys");
-        if (typeof keyNode === "object" && _class(keyNode[index]) === "[object Object]")
+        }
+        if (typeof keyNode === "object" && _class(keyNode[index]) === "[object Object]") {
           keyNode[index] = "[object Object]";
+        }
       }
     }
-    if (typeof keyNode === "object" && _class(keyNode) === "[object Object]")
+    if (typeof keyNode === "object" && _class(keyNode) === "[object Object]") {
       keyNode = "[object Object]";
+    }
     keyNode = String(keyNode);
-    if (_result === null)
+    if (_result === null) {
       _result = {};
-    if (keyTag === "tag:yaml.org,2002:merge")
+    }
+    if (keyTag === "tag:yaml.org,2002:merge") {
       if (Array.isArray(valueNode)) {
-        if (valueNode.length > state.maxMergeSeqLength)
-          throwError(state, "merge sequence length exceeded maxMergeSeqLength (" + state.maxMergeSeqLength + ")");
-        const seen = /* @__PURE__ */ new Set;
         for (let index = 0, quantity = valueNode.length;index < quantity; index += 1) {
-          const src = valueNode[index];
-          if (seen.has(src))
-            continue;
-          seen.add(src);
-          mergeMappings(state, _result, src, overridableKeys);
+          mergeMappings(state, _result, valueNode[index], overridableKeys);
         }
-      } else
+      } else {
         mergeMappings(state, _result, valueNode, overridableKeys);
-    else {
+      }
+    } else {
       if (!state.json && !_hasOwnProperty.call(overridableKeys, keyNode) && _hasOwnProperty.call(_result, keyNode)) {
         state.line = startLine || state.line;
         state.lineStart = startLineStart || state.lineStart;
@@ -6271,14 +6454,16 @@ var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
   }
   function readLineBreak(state) {
     const ch = state.input.charCodeAt(state.position);
-    if (ch === 10)
+    if (ch === 10) {
       state.position++;
-    else if (ch === 13) {
+    } else if (ch === 13) {
       state.position++;
-      if (state.input.charCodeAt(state.position) === 10)
+      if (state.input.charCodeAt(state.position) === 10) {
         state.position++;
-    } else
+      }
+    } else {
       throwError(state, "a line break is expected");
+    }
     state.line += 1;
     state.lineStart = state.position;
     state.firstTabInLine = -1;
@@ -6288,14 +6473,16 @@ var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
     let ch = state.input.charCodeAt(state.position);
     while (ch !== 0) {
       while (isWhiteSpace(ch)) {
-        if (ch === 9 && state.firstTabInLine === -1)
+        if (ch === 9 && state.firstTabInLine === -1) {
           state.firstTabInLine = state.position;
+        }
         ch = state.input.charCodeAt(++state.position);
       }
-      if (allowComments && ch === 35)
-        do
+      if (allowComments && ch === 35) {
+        do {
           ch = state.input.charCodeAt(++state.position);
-        while (ch !== 10 && ch !== 13 && ch !== 0);
+        } while (ch !== 10 && ch !== 13 && ch !== 0);
+      }
       if (isEol(ch)) {
         readLineBreak(state);
         ch = state.input.charCodeAt(state.position);
@@ -6305,11 +6492,13 @@ var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
           state.lineIndent++;
           ch = state.input.charCodeAt(++state.position);
         }
-      } else
+      } else {
         break;
+      }
     }
-    if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent)
+    if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) {
       throwWarning(state, "deficient indentation");
+    }
     return lineBreaks;
   }
   function testDocumentSeparator(state) {
@@ -6318,17 +6507,19 @@ var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
     if ((ch === 45 || ch === 46) && ch === state.input.charCodeAt(_position + 1) && ch === state.input.charCodeAt(_position + 2)) {
       _position += 3;
       ch = state.input.charCodeAt(_position);
-      if (ch === 0 || isWsOrEol(ch))
+      if (ch === 0 || isWsOrEol(ch)) {
         return true;
+      }
     }
     return false;
   }
   function writeFoldedLines(state, count) {
-    if (count === 1)
+    if (count === 1) {
       state.result += " ";
-    else if (count > 1)
-      state.result += common.repeat(`
+    } else if (count > 1) {
+      state.result += common2.repeat(`
 `, count - 1);
+    }
   }
   function readPlainScalar(state, nodeIndent, withinFlowCollection) {
     let captureStart;
@@ -6340,12 +6531,14 @@ var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
     const _kind = state.kind;
     const _result = state.result;
     let ch = state.input.charCodeAt(state.position);
-    if (isWsOrEol(ch) || isFlowIndicator(ch) || ch === 35 || ch === 38 || ch === 42 || ch === 33 || ch === 124 || ch === 62 || ch === 39 || ch === 34 || ch === 37 || ch === 64 || ch === 96)
+    if (isWsOrEol(ch) || isFlowIndicator(ch) || ch === 35 || ch === 38 || ch === 42 || ch === 33 || ch === 124 || ch === 62 || ch === 39 || ch === 34 || ch === 37 || ch === 64 || ch === 96) {
       return false;
+    }
     if (ch === 63 || ch === 45) {
       const following = state.input.charCodeAt(state.position + 1);
-      if (isWsOrEol(following) || withinFlowCollection && isFlowIndicator(following))
+      if (isWsOrEol(following) || withinFlowCollection && isFlowIndicator(following)) {
         return false;
+      }
     }
     state.kind = "scalar";
     state.result = "";
@@ -6354,14 +6547,17 @@ var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
     while (ch !== 0) {
       if (ch === 58) {
         const following = state.input.charCodeAt(state.position + 1);
-        if (isWsOrEol(following) || withinFlowCollection && isFlowIndicator(following))
+        if (isWsOrEol(following) || withinFlowCollection && isFlowIndicator(following)) {
           break;
+        }
       } else if (ch === 35) {
-        if (isWsOrEol(state.input.charCodeAt(state.position - 1)))
+        const preceding = state.input.charCodeAt(state.position - 1);
+        if (isWsOrEol(preceding)) {
           break;
-      } else if (state.position === state.lineStart && testDocumentSeparator(state) || withinFlowCollection && isFlowIndicator(ch))
+        }
+      } else if (state.position === state.lineStart && testDocumentSeparator(state) || withinFlowCollection && isFlowIndicator(ch)) {
         break;
-      else if (isEol(ch)) {
+      } else if (isEol(ch)) {
         _line = state.line;
         _lineStart = state.lineStart;
         _lineIndent = state.lineIndent;
@@ -6384,13 +6580,15 @@ var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
         captureStart = captureEnd = state.position;
         hasPendingContent = false;
       }
-      if (!isWhiteSpace(ch))
+      if (!isWhiteSpace(ch)) {
         captureEnd = state.position + 1;
+      }
       ch = state.input.charCodeAt(++state.position);
     }
     captureSegment(state, captureStart, captureEnd, false);
-    if (state.result)
+    if (state.result) {
       return true;
+    }
     state.kind = _kind;
     state.result = _result;
     return false;
@@ -6399,13 +6597,14 @@ var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
     let captureStart;
     let captureEnd;
     let ch = state.input.charCodeAt(state.position);
-    if (ch !== 39)
+    if (ch !== 39) {
       return false;
+    }
     state.kind = "scalar";
     state.result = "";
     state.position++;
     captureStart = captureEnd = state.position;
-    while ((ch = state.input.charCodeAt(state.position)) !== 0)
+    while ((ch = state.input.charCodeAt(state.position)) !== 0) {
       if (ch === 39) {
         captureSegment(state, captureStart, state.position, true);
         ch = state.input.charCodeAt(++state.position);
@@ -6413,19 +6612,22 @@ var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
           captureStart = state.position;
           state.position++;
           captureEnd = state.position;
-        } else
+        } else {
           return true;
+        }
       } else if (isEol(ch)) {
         captureSegment(state, captureStart, captureEnd, true);
         writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
         captureStart = captureEnd = state.position;
-      } else if (state.position === state.lineStart && testDocumentSeparator(state))
+      } else if (state.position === state.lineStart && testDocumentSeparator(state)) {
         throwError(state, "unexpected end of the document within a single quoted scalar");
-      else {
+      } else {
         state.position++;
-        if (!isWhiteSpace(ch))
+        if (!isWhiteSpace(ch)) {
           captureEnd = state.position;
+        }
       }
+    }
     throwError(state, "unexpected end of the stream within a single quoted scalar");
   }
   function readDoubleQuotedScalar(state, nodeIndent) {
@@ -6433,13 +6635,14 @@ var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
     let captureEnd;
     let tmp;
     let ch = state.input.charCodeAt(state.position);
-    if (ch !== 34)
+    if (ch !== 34) {
       return false;
+    }
     state.kind = "scalar";
     state.result = "";
     state.position++;
     captureStart = captureEnd = state.position;
-    while ((ch = state.input.charCodeAt(state.position)) !== 0)
+    while ((ch = state.input.charCodeAt(state.position)) !== 0) {
       if (ch === 34) {
         captureSegment(state, captureStart, state.position, true);
         state.position++;
@@ -6447,9 +6650,9 @@ var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
       } else if (ch === 92) {
         captureSegment(state, captureStart, state.position, true);
         ch = state.input.charCodeAt(++state.position);
-        if (isEol(ch))
+        if (isEol(ch)) {
           skipSeparationSpace(state, false, nodeIndent);
-        else if (ch < 256 && simpleEscapeCheck[ch]) {
+        } else if (ch < 256 && simpleEscapeCheck[ch]) {
           state.result += simpleEscapeMap[ch];
           state.position++;
         } else if ((tmp = escapedHexLen(ch)) > 0) {
@@ -6457,27 +6660,31 @@ var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
           let hexResult = 0;
           for (;hexLength > 0; hexLength--) {
             ch = state.input.charCodeAt(++state.position);
-            if ((tmp = fromHexCode(ch)) >= 0)
+            if ((tmp = fromHexCode(ch)) >= 0) {
               hexResult = (hexResult << 4) + tmp;
-            else
+            } else {
               throwError(state, "expected hexadecimal character");
+            }
           }
           state.result += charFromCodepoint(hexResult);
           state.position++;
-        } else
+        } else {
           throwError(state, "unknown escape sequence");
+        }
         captureStart = captureEnd = state.position;
       } else if (isEol(ch)) {
         captureSegment(state, captureStart, captureEnd, true);
         writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
         captureStart = captureEnd = state.position;
-      } else if (state.position === state.lineStart && testDocumentSeparator(state))
+      } else if (state.position === state.lineStart && testDocumentSeparator(state)) {
         throwError(state, "unexpected end of the document within a double quoted scalar");
-      else {
+      } else {
         state.position++;
-        if (!isWhiteSpace(ch))
+        if (!isWhiteSpace(ch)) {
           captureEnd = state.position;
+        }
       }
+    }
     throwError(state, "unexpected end of the stream within a double quoted scalar");
   }
   function readFlowCollection(state, nodeIndent) {
@@ -6492,7 +6699,7 @@ var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
     let isPair;
     let isExplicitPair;
     let isMapping;
-    const overridableKeys = Object.create(null);
+    const overridableKeys = /* @__PURE__ */ Object.create(null);
     let keyNode;
     let keyTag;
     let valueNode;
@@ -6505,10 +6712,12 @@ var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
       terminator = 125;
       isMapping = true;
       _result = {};
-    } else
+    } else {
       return false;
-    if (state.anchor !== null)
+    }
+    if (state.anchor !== null) {
       storeAnchor(state, state.anchor, _result);
+    }
     ch = state.input.charCodeAt(++state.position);
     while (ch !== 0) {
       skipSeparationSpace(state, true, nodeIndent);
@@ -6520,14 +6729,16 @@ var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
         state.kind = isMapping ? "mapping" : "sequence";
         state.result = _result;
         return true;
-      } else if (!readNext)
+      } else if (!readNext) {
         throwError(state, "missed comma between flow collection entries");
-      else if (ch === 44)
+      } else if (ch === 44) {
         throwError(state, "expected the node content, but found ','");
+      }
       keyTag = keyNode = valueNode = null;
       isPair = isExplicitPair = false;
       if (ch === 63) {
-        if (isWsOrEol(state.input.charCodeAt(state.position + 1))) {
+        const following = state.input.charCodeAt(state.position + 1);
+        if (isWsOrEol(following)) {
           isPair = isExplicitPair = true;
           state.position++;
           skipSeparationSpace(state, true, nodeIndent);
@@ -6548,19 +6759,21 @@ var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
         composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
         valueNode = state.result;
       }
-      if (isMapping)
+      if (isMapping) {
         storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos);
-      else if (isPair)
+      } else if (isPair) {
         _result.push(storeMappingPair(state, null, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos));
-      else
+      } else {
         _result.push(keyNode);
+      }
       skipSeparationSpace(state, true, nodeIndent);
       ch = state.input.charCodeAt(state.position);
       if (ch === 44) {
         readNext = true;
         ch = state.input.charCodeAt(++state.position);
-      } else
+      } else {
         readNext = false;
+      }
     }
     throwError(state, "unexpected end of the stream within a flow collection");
   }
@@ -6574,40 +6787,45 @@ var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
     let atMoreIndented = false;
     let tmp;
     let ch = state.input.charCodeAt(state.position);
-    if (ch === 124)
+    if (ch === 124) {
       folding = false;
-    else if (ch === 62)
+    } else if (ch === 62) {
       folding = true;
-    else
+    } else {
       return false;
+    }
     state.kind = "scalar";
     state.result = "";
     while (ch !== 0) {
       ch = state.input.charCodeAt(++state.position);
-      if (ch === 43 || ch === 45)
-        if (CHOMPING_CLIP === chomping)
+      if (ch === 43 || ch === 45) {
+        if (CHOMPING_CLIP === chomping) {
           chomping = ch === 43 ? CHOMPING_KEEP : CHOMPING_STRIP;
-        else
+        } else {
           throwError(state, "repeat of a chomping mode identifier");
-      else if ((tmp = fromDecimalCode(ch)) >= 0)
-        if (tmp === 0)
+        }
+      } else if ((tmp = fromDecimalCode(ch)) >= 0) {
+        if (tmp === 0) {
           throwError(state, "bad explicit indentation width of a block scalar; it cannot be less than one");
-        else if (!detectedIndent) {
+        } else if (!detectedIndent) {
           textIndent = nodeIndent + tmp - 1;
           detectedIndent = true;
-        } else
+        } else {
           throwError(state, "repeat of an indentation width identifier");
-      else
+        }
+      } else {
         break;
+      }
     }
     if (isWhiteSpace(ch)) {
-      do
+      do {
         ch = state.input.charCodeAt(++state.position);
-      while (isWhiteSpace(ch));
-      if (ch === 35)
-        do
+      } while (isWhiteSpace(ch));
+      if (ch === 35) {
+        do {
           ch = state.input.charCodeAt(++state.position);
-        while (!isEol(ch) && ch !== 0);
+        } while (!isEol(ch) && ch !== 0);
+      }
     }
     while (ch !== 0) {
       readLineBreak(state);
@@ -6617,49 +6835,56 @@ var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
         state.lineIndent++;
         ch = state.input.charCodeAt(++state.position);
       }
-      if (!detectedIndent && state.lineIndent > textIndent)
+      if (!detectedIndent && state.lineIndent > textIndent) {
         textIndent = state.lineIndent;
+      }
       if (isEol(ch)) {
         emptyLines++;
         continue;
       }
-      if (!detectedIndent && textIndent === 0)
+      if (!detectedIndent && textIndent === 0) {
         throwError(state, "missing indentation for block scalar");
+      }
       if (state.lineIndent < textIndent) {
-        if (chomping === CHOMPING_KEEP)
-          state.result += common.repeat(`
+        if (chomping === CHOMPING_KEEP) {
+          state.result += common2.repeat(`
 `, didReadContent ? 1 + emptyLines : emptyLines);
-        else if (chomping === CHOMPING_CLIP) {
-          if (didReadContent)
+        } else if (chomping === CHOMPING_CLIP) {
+          if (didReadContent) {
             state.result += `
 `;
+          }
         }
         break;
       }
-      if (folding)
+      if (folding) {
         if (isWhiteSpace(ch)) {
           atMoreIndented = true;
-          state.result += common.repeat(`
+          state.result += common2.repeat(`
 `, didReadContent ? 1 + emptyLines : emptyLines);
         } else if (atMoreIndented) {
           atMoreIndented = false;
-          state.result += common.repeat(`
+          state.result += common2.repeat(`
 `, emptyLines + 1);
         } else if (emptyLines === 0) {
-          if (didReadContent)
+          if (didReadContent) {
             state.result += " ";
-        } else
-          state.result += common.repeat(`
+          }
+        } else {
+          state.result += common2.repeat(`
 `, emptyLines);
-      else
-        state.result += common.repeat(`
+        }
+      } else {
+        state.result += common2.repeat(`
 `, didReadContent ? 1 + emptyLines : emptyLines);
+      }
       didReadContent = true;
       detectedIndent = true;
       emptyLines = 0;
       const captureStart = state.position;
-      while (!isEol(ch) && ch !== 0)
+      while (!isEol(ch) && ch !== 0) {
         ch = state.input.charCodeAt(++state.position);
+      }
       captureSegment(state, captureStart, state.position, false);
     }
     return true;
@@ -6671,18 +6896,22 @@ var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
     let detected = false;
     if (state.firstTabInLine !== -1)
       return false;
-    if (state.anchor !== null)
+    if (state.anchor !== null) {
       storeAnchor(state, state.anchor, _result);
+    }
     let ch = state.input.charCodeAt(state.position);
     while (ch !== 0) {
       if (state.firstTabInLine !== -1) {
         state.position = state.firstTabInLine;
         throwError(state, "tab characters must not be used in indentation");
       }
-      if (ch !== 45)
+      if (ch !== 45) {
         break;
-      if (!isWsOrEol(state.input.charCodeAt(state.position + 1)))
+      }
+      const following = state.input.charCodeAt(state.position + 1);
+      if (!isWsOrEol(following)) {
         break;
+      }
       detected = true;
       state.position++;
       if (skipSeparationSpace(state, true, -1)) {
@@ -6697,10 +6926,11 @@ var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
       _result.push(state.result);
       skipSeparationSpace(state, true, -1);
       ch = state.input.charCodeAt(state.position);
-      if ((state.line === _line || state.lineIndent > nodeIndent) && ch !== 0)
+      if ((state.line === _line || state.lineIndent > nodeIndent) && ch !== 0) {
         throwError(state, "bad indentation of a sequence entry");
-      else if (state.lineIndent < nodeIndent)
+      } else if (state.lineIndent < nodeIndent) {
         break;
+      }
     }
     if (detected) {
       state.tag = _tag;
@@ -6719,7 +6949,7 @@ var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
     const _tag = state.tag;
     const _anchor = state.anchor;
     const _result = {};
-    const overridableKeys = Object.create(null);
+    const overridableKeys = /* @__PURE__ */ Object.create(null);
     let keyTag = null;
     let keyNode = null;
     let valueNode = null;
@@ -6727,8 +6957,9 @@ var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
     let detected = false;
     if (state.firstTabInLine !== -1)
       return false;
-    if (state.anchor !== null)
+    if (state.anchor !== null) {
       storeAnchor(state, state.anchor, _result);
+    }
     let ch = state.input.charCodeAt(state.position);
     while (ch !== 0) {
       if (!atExplicitKey && state.firstTabInLine !== -1) {
@@ -6749,24 +6980,28 @@ var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
         } else if (atExplicitKey) {
           atExplicitKey = false;
           allowCompact = true;
-        } else
+        } else {
           throwError(state, "incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line");
+        }
         state.position += 1;
         ch = following;
       } else {
         _keyLine = state.line;
         _keyLineStart = state.lineStart;
         _keyPos = state.position;
-        if (!composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true))
+        if (!composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) {
           break;
+        }
         if (state.line === _line) {
           ch = state.input.charCodeAt(state.position);
-          while (isWhiteSpace(ch))
+          while (isWhiteSpace(ch)) {
             ch = state.input.charCodeAt(++state.position);
+          }
           if (ch === 58) {
             ch = state.input.charCodeAt(++state.position);
-            if (!isWsOrEol(ch))
+            if (!isWsOrEol(ch)) {
               throwError(state, "a whitespace character is expected after the key-value separator within a block mapping");
+            }
             if (atExplicitKey) {
               storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
               keyTag = keyNode = valueNode = null;
@@ -6776,16 +7011,16 @@ var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
             allowCompact = false;
             keyTag = state.tag;
             keyNode = state.result;
-          } else if (detected)
+          } else if (detected) {
             throwError(state, "can not read an implicit mapping pair; a colon is missed");
-          else {
+          } else {
             state.tag = _tag;
             state.anchor = _anchor;
             return true;
           }
-        } else if (detected)
+        } else if (detected) {
           throwError(state, "can not read a block mapping entry; a multiline key may not be an implicit key");
-        else {
+        } else {
           state.tag = _tag;
           state.anchor = _anchor;
           return true;
@@ -6797,11 +7032,13 @@ var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
           _keyLineStart = state.lineStart;
           _keyPos = state.position;
         }
-        if (composeNode(state, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact))
-          if (atExplicitKey)
+        if (composeNode(state, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) {
+          if (atExplicitKey) {
             keyNode = state.result;
-          else
+          } else {
             valueNode = state.result;
+          }
+        }
         if (!atExplicitKey) {
           storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _keyLine, _keyLineStart, _keyPos);
           keyTag = keyNode = valueNode = null;
@@ -6809,13 +7046,15 @@ var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
         skipSeparationSpace(state, true, -1);
         ch = state.input.charCodeAt(state.position);
       }
-      if ((state.line === _line || state.lineIndent > nodeIndent) && ch !== 0)
+      if ((state.line === _line || state.lineIndent > nodeIndent) && ch !== 0) {
         throwError(state, "bad indentation of a mapping entry");
-      else if (state.lineIndent < nodeIndent)
+      } else if (state.lineIndent < nodeIndent) {
         break;
+      }
     }
-    if (atExplicitKey)
+    if (atExplicitKey) {
       storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
+    }
     if (detected) {
       state.tag = _tag;
       state.anchor = _anchor;
@@ -6832,8 +7071,9 @@ var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
     let ch = state.input.charCodeAt(state.position);
     if (ch !== 33)
       return false;
-    if (state.tag !== null)
+    if (state.tag !== null) {
       throwError(state, "duplication of a tag property");
+    }
     ch = state.input.charCodeAt(++state.position);
     if (ch === 60) {
       isVerbatim = true;
@@ -6842,66 +7082,77 @@ var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
       isNamed = true;
       tagHandle = "!!";
       ch = state.input.charCodeAt(++state.position);
-    } else
+    } else {
       tagHandle = "!";
+    }
     let _position = state.position;
     if (isVerbatim) {
-      do
+      do {
         ch = state.input.charCodeAt(++state.position);
-      while (ch !== 0 && ch !== 62);
+      } while (ch !== 0 && ch !== 62);
       if (state.position < state.length) {
         tagName = state.input.slice(_position, state.position);
         ch = state.input.charCodeAt(++state.position);
-      } else
+      } else {
         throwError(state, "unexpected end of the stream within a verbatim tag");
+      }
     } else {
       while (ch !== 0 && !isWsOrEol(ch)) {
-        if (ch === 33)
+        if (ch === 33) {
           if (!isNamed) {
             tagHandle = state.input.slice(_position - 1, state.position + 1);
-            if (!PATTERN_TAG_HANDLE.test(tagHandle))
+            if (!PATTERN_TAG_HANDLE.test(tagHandle)) {
               throwError(state, "named tag handle cannot contain such characters");
+            }
             isNamed = true;
             _position = state.position + 1;
-          } else
+          } else {
             throwError(state, "tag suffix cannot contain exclamation marks");
+          }
+        }
         ch = state.input.charCodeAt(++state.position);
       }
       tagName = state.input.slice(_position, state.position);
-      if (PATTERN_FLOW_INDICATORS.test(tagName))
+      if (PATTERN_FLOW_INDICATORS.test(tagName)) {
         throwError(state, "tag suffix cannot contain flow indicator characters");
+      }
     }
-    if (tagName && !PATTERN_TAG_URI.test(tagName))
+    if (tagName && !PATTERN_TAG_URI.test(tagName)) {
       throwError(state, "tag name cannot contain such characters: " + tagName);
+    }
     try {
       tagName = decodeURIComponent(tagName);
     } catch (err) {
       throwError(state, "tag name is malformed: " + tagName);
     }
-    if (isVerbatim)
+    if (isVerbatim) {
       state.tag = tagName;
-    else if (_hasOwnProperty.call(state.tagMap, tagHandle))
+    } else if (_hasOwnProperty.call(state.tagMap, tagHandle)) {
       state.tag = state.tagMap[tagHandle] + tagName;
-    else if (tagHandle === "!")
+    } else if (tagHandle === "!") {
       state.tag = "!" + tagName;
-    else if (tagHandle === "!!")
+    } else if (tagHandle === "!!") {
       state.tag = "tag:yaml.org,2002:" + tagName;
-    else
+    } else {
       throwError(state, 'undeclared tag handle "' + tagHandle + '"');
+    }
     return true;
   }
   function readAnchorProperty(state) {
     let ch = state.input.charCodeAt(state.position);
     if (ch !== 38)
       return false;
-    if (state.anchor !== null)
+    if (state.anchor !== null) {
       throwError(state, "duplication of an anchor property");
+    }
     ch = state.input.charCodeAt(++state.position);
     const _position = state.position;
-    while (ch !== 0 && !isWsOrEol(ch) && !isFlowIndicator(ch))
+    while (ch !== 0 && !isWsOrEol(ch) && !isFlowIndicator(ch)) {
       ch = state.input.charCodeAt(++state.position);
-    if (state.position === _position)
+    }
+    if (state.position === _position) {
       throwError(state, "name of an anchor node must contain at least one character");
+    }
     state.anchor = state.input.slice(_position, state.position);
     return true;
   }
@@ -6911,13 +7162,16 @@ var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
       return false;
     ch = state.input.charCodeAt(++state.position);
     const _position = state.position;
-    while (ch !== 0 && !isWsOrEol(ch) && !isFlowIndicator(ch))
+    while (ch !== 0 && !isWsOrEol(ch) && !isFlowIndicator(ch)) {
       ch = state.input.charCodeAt(++state.position);
-    if (state.position === _position)
+    }
+    if (state.position === _position) {
       throwError(state, "name of an alias node must contain at least one character");
+    }
     const alias = state.input.slice(_position, state.position);
-    if (!_hasOwnProperty.call(state.anchorMap, alias))
+    if (!_hasOwnProperty.call(state.anchorMap, alias)) {
       throwError(state, 'unidentified alias "' + alias + '"');
+    }
     state.result = state.anchorMap[alias];
     skipSeparationSpace(state, true, -1);
     return true;
@@ -6945,14 +7199,16 @@ var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
     let atNewLine = false;
     let hasContent = false;
     let propertyStart = null;
-    let type;
+    let type2;
     let flowIndent;
     let blockIndent;
-    if (state.depth >= state.maxDepth)
+    if (state.depth >= state.maxDepth) {
       throwError(state, "nesting exceeded maxDepth (" + state.maxDepth + ")");
+    }
     state.depth += 1;
-    if (state.listener !== null)
+    if (state.listener !== null) {
       state.listener("open", state);
+    }
     state.tag = null;
     state.anchor = null;
     state.kind = null;
@@ -6961,110 +7217,131 @@ var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
     if (allowToSeek) {
       if (skipSeparationSpace(state, true, -1)) {
         atNewLine = true;
-        if (state.lineIndent > parentIndent)
+        if (state.lineIndent > parentIndent) {
           indentStatus = 1;
-        else if (state.lineIndent === parentIndent)
+        } else if (state.lineIndent === parentIndent) {
           indentStatus = 0;
-        else if (state.lineIndent < parentIndent)
+        } else if (state.lineIndent < parentIndent) {
           indentStatus = -1;
+        }
       }
     }
-    if (indentStatus === 1)
+    if (indentStatus === 1) {
       while (true) {
         const ch = state.input.charCodeAt(state.position);
         const propertyState = snapshotState(state);
-        if (atNewLine && (ch === 33 && state.tag !== null || ch === 38 && state.anchor !== null))
+        if (atNewLine && (ch === 33 && state.tag !== null || ch === 38 && state.anchor !== null)) {
           break;
-        if (!readTagProperty(state) && !readAnchorProperty(state))
+        }
+        if (!readTagProperty(state) && !readAnchorProperty(state)) {
           break;
-        if (propertyStart === null)
+        }
+        if (propertyStart === null) {
           propertyStart = propertyState;
+        }
         if (skipSeparationSpace(state, true, -1)) {
           atNewLine = true;
           allowBlockCollections = allowBlockStyles;
-          if (state.lineIndent > parentIndent)
+          if (state.lineIndent > parentIndent) {
             indentStatus = 1;
-          else if (state.lineIndent === parentIndent)
+          } else if (state.lineIndent === parentIndent) {
             indentStatus = 0;
-          else if (state.lineIndent < parentIndent)
+          } else if (state.lineIndent < parentIndent) {
             indentStatus = -1;
-        } else
+          }
+        } else {
           allowBlockCollections = false;
+        }
       }
-    if (allowBlockCollections)
+    }
+    if (allowBlockCollections) {
       allowBlockCollections = atNewLine || allowCompact;
+    }
     if (indentStatus === 1 || CONTEXT_BLOCK_OUT === nodeContext) {
-      if (CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext)
+      if (CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext) {
         flowIndent = parentIndent;
-      else
+      } else {
         flowIndent = parentIndent + 1;
+      }
       blockIndent = state.position - state.lineStart;
-      if (indentStatus === 1)
-        if (allowBlockCollections && (readBlockSequence(state, blockIndent) || readBlockMapping(state, blockIndent, flowIndent)) || readFlowCollection(state, flowIndent))
+      if (indentStatus === 1) {
+        if (allowBlockCollections && (readBlockSequence(state, blockIndent) || readBlockMapping(state, blockIndent, flowIndent)) || readFlowCollection(state, flowIndent)) {
           hasContent = true;
-        else {
+        } else {
           const ch = state.input.charCodeAt(state.position);
-          if (propertyStart !== null && allowBlockStyles && !allowBlockCollections && ch !== 124 && ch !== 62 && tryReadBlockMappingFromProperty(state, propertyStart, propertyStart.position - propertyStart.lineStart, flowIndent))
+          if (propertyStart !== null && allowBlockStyles && !allowBlockCollections && ch !== 124 && ch !== 62 && tryReadBlockMappingFromProperty(state, propertyStart, propertyStart.position - propertyStart.lineStart, flowIndent)) {
             hasContent = true;
-          else if (allowBlockScalars && readBlockScalar(state, flowIndent) || readSingleQuotedScalar(state, flowIndent) || readDoubleQuotedScalar(state, flowIndent))
+          } else if (allowBlockScalars && readBlockScalar(state, flowIndent) || readSingleQuotedScalar(state, flowIndent) || readDoubleQuotedScalar(state, flowIndent)) {
             hasContent = true;
-          else if (readAlias(state)) {
+          } else if (readAlias(state)) {
             hasContent = true;
-            if (state.tag !== null || state.anchor !== null)
+            if (state.tag !== null || state.anchor !== null) {
               throwError(state, "alias node should not have any properties");
+            }
           } else if (readPlainScalar(state, flowIndent, CONTEXT_FLOW_IN === nodeContext)) {
             hasContent = true;
-            if (state.tag === null)
+            if (state.tag === null) {
               state.tag = "?";
+            }
           }
-          if (state.anchor !== null)
+          if (state.anchor !== null) {
             storeAnchor(state, state.anchor, state.result);
+          }
         }
-      else if (indentStatus === 0)
+      } else if (indentStatus === 0) {
         hasContent = allowBlockCollections && readBlockSequence(state, blockIndent);
+      }
     }
     if (state.tag === null) {
-      if (state.anchor !== null)
+      if (state.anchor !== null) {
         storeAnchor(state, state.anchor, state.result);
+      }
     } else if (state.tag === "?") {
-      if (state.result !== null && state.kind !== "scalar")
+      if (state.result !== null && state.kind !== "scalar") {
         throwError(state, 'unacceptable node kind for !<?> tag; it should be "scalar", not "' + state.kind + '"');
+      }
       for (let typeIndex = 0, typeQuantity = state.implicitTypes.length;typeIndex < typeQuantity; typeIndex += 1) {
-        type = state.implicitTypes[typeIndex];
-        if (type.resolve(state.result)) {
-          state.result = type.construct(state.result);
-          state.tag = type.tag;
-          if (state.anchor !== null)
+        type2 = state.implicitTypes[typeIndex];
+        if (type2.resolve(state.result)) {
+          state.result = type2.construct(state.result);
+          state.tag = type2.tag;
+          if (state.anchor !== null) {
             storeAnchor(state, state.anchor, state.result);
+          }
           break;
         }
       }
     } else if (state.tag !== "!") {
-      if (_hasOwnProperty.call(state.typeMap[state.kind || "fallback"], state.tag))
-        type = state.typeMap[state.kind || "fallback"][state.tag];
-      else {
-        type = null;
+      if (_hasOwnProperty.call(state.typeMap[state.kind || "fallback"], state.tag)) {
+        type2 = state.typeMap[state.kind || "fallback"][state.tag];
+      } else {
+        type2 = null;
         const typeList = state.typeMap.multi[state.kind || "fallback"];
-        for (let typeIndex = 0, typeQuantity = typeList.length;typeIndex < typeQuantity; typeIndex += 1)
+        for (let typeIndex = 0, typeQuantity = typeList.length;typeIndex < typeQuantity; typeIndex += 1) {
           if (state.tag.slice(0, typeList[typeIndex].tag.length) === typeList[typeIndex].tag) {
-            type = typeList[typeIndex];
+            type2 = typeList[typeIndex];
             break;
           }
+        }
       }
-      if (!type)
+      if (!type2) {
         throwError(state, "unknown tag !<" + state.tag + ">");
-      if (state.result !== null && type.kind !== state.kind)
-        throwError(state, "unacceptable node kind for !<" + state.tag + '> tag; it should be "' + type.kind + '", not "' + state.kind + '"');
-      if (!type.resolve(state.result, state.tag))
-        throwError(state, "cannot resolve a node with !<" + state.tag + "> explicit tag");
-      else {
-        state.result = type.construct(state.result, state.tag);
-        if (state.anchor !== null)
+      }
+      if (state.result !== null && type2.kind !== state.kind) {
+        throwError(state, "unacceptable node kind for !<" + state.tag + '> tag; it should be "' + type2.kind + '", not "' + state.kind + '"');
+      }
+      if (!type2.resolve(state.result, state.tag)) {
+        throwError(state, "cannot resolve a node with !<" + state.tag + "> explicit tag");
+      } else {
+        state.result = type2.construct(state.result, state.tag);
+        if (state.anchor !== null) {
           storeAnchor(state, state.anchor, state.result);
+        }
       }
     }
-    if (state.listener !== null)
+    if (state.listener !== null) {
       state.listener("close", state);
+    }
     state.depth -= 1;
     return state.tag !== null || state.anchor !== null || hasContent;
   }
@@ -7074,55 +7351,63 @@ var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
     let ch;
     state.version = null;
     state.checkLineBreaks = state.legacy;
-    state.tagMap = Object.create(null);
-    state.anchorMap = Object.create(null);
+    state.tagMap = /* @__PURE__ */ Object.create(null);
+    state.anchorMap = /* @__PURE__ */ Object.create(null);
     while ((ch = state.input.charCodeAt(state.position)) !== 0) {
       skipSeparationSpace(state, true, -1);
       ch = state.input.charCodeAt(state.position);
-      if (state.lineIndent > 0 || ch !== 37)
+      if (state.lineIndent > 0 || ch !== 37) {
         break;
+      }
       hasDirectives = true;
       ch = state.input.charCodeAt(++state.position);
       let _position = state.position;
-      while (ch !== 0 && !isWsOrEol(ch))
+      while (ch !== 0 && !isWsOrEol(ch)) {
         ch = state.input.charCodeAt(++state.position);
+      }
       const directiveName = state.input.slice(_position, state.position);
       const directiveArgs = [];
-      if (directiveName.length < 1)
+      if (directiveName.length < 1) {
         throwError(state, "directive name must not be less than one character in length");
+      }
       while (ch !== 0) {
-        while (isWhiteSpace(ch))
+        while (isWhiteSpace(ch)) {
           ch = state.input.charCodeAt(++state.position);
+        }
         if (ch === 35) {
-          do
+          do {
             ch = state.input.charCodeAt(++state.position);
-          while (ch !== 0 && !isEol(ch));
+          } while (ch !== 0 && !isEol(ch));
           break;
         }
         if (isEol(ch))
           break;
         _position = state.position;
-        while (ch !== 0 && !isWsOrEol(ch))
+        while (ch !== 0 && !isWsOrEol(ch)) {
           ch = state.input.charCodeAt(++state.position);
+        }
         directiveArgs.push(state.input.slice(_position, state.position));
       }
       if (ch !== 0)
         readLineBreak(state);
-      if (_hasOwnProperty.call(directiveHandlers, directiveName))
+      if (_hasOwnProperty.call(directiveHandlers, directiveName)) {
         directiveHandlers[directiveName](state, directiveName, directiveArgs);
-      else
+      } else {
         throwWarning(state, 'unknown document directive "' + directiveName + '"');
+      }
     }
     skipSeparationSpace(state, true, -1);
     if (state.lineIndent === 0 && state.input.charCodeAt(state.position) === 45 && state.input.charCodeAt(state.position + 1) === 45 && state.input.charCodeAt(state.position + 2) === 45) {
       state.position += 3;
       skipSeparationSpace(state, true, -1);
-    } else if (hasDirectives)
+    } else if (hasDirectives) {
       throwError(state, "directives end mark is expected");
+    }
     composeNode(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true);
     skipSeparationSpace(state, true, -1);
-    if (state.checkLineBreaks && PATTERN_NON_ASCII_LINE_BREAKS.test(state.input.slice(documentStart, state.position)))
+    if (state.checkLineBreaks && PATTERN_NON_ASCII_LINE_BREAKS.test(state.input.slice(documentStart, state.position))) {
       throwWarning(state, "non-ASCII line breaks are interpreted as content");
+    }
     state.documents.push(state.result);
     if (state.position === state.lineStart && testDocumentSeparator(state)) {
       if (state.input.charCodeAt(state.position) === 46) {
@@ -7131,18 +7416,21 @@ var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
       }
       return;
     }
-    if (state.position < state.length - 1)
+    if (state.position < state.length - 1) {
       throwError(state, "end of the stream or a document separator is expected");
+    }
   }
   function loadDocuments(input, options) {
     input = String(input);
     options = options || {};
     if (input.length !== 0) {
-      if (input.charCodeAt(input.length - 1) !== 10 && input.charCodeAt(input.length - 1) !== 13)
+      if (input.charCodeAt(input.length - 1) !== 10 && input.charCodeAt(input.length - 1) !== 13) {
         input += `
 `;
-      if (input.charCodeAt(0) === 65279)
+      }
+      if (input.charCodeAt(0) === 65279) {
         input = input.slice(1);
+      }
     }
     const state = new State(input, options);
     const nullpos = input.indexOf("\x00");
@@ -7155,64 +7443,74 @@ var require_loader = /* @__PURE__ */ __commonJSMin((exports, module) => {
       state.lineIndent += 1;
       state.position += 1;
     }
-    while (state.position < state.length - 1)
+    while (state.position < state.length - 1) {
       readDocument(state);
+    }
     return state.documents;
   }
-  function loadAll(input, iterator, options) {
+  function loadAll2(input, iterator, options) {
     if (iterator !== null && typeof iterator === "object" && typeof options === "undefined") {
       options = iterator;
       iterator = null;
     }
     const documents = loadDocuments(input, options);
-    if (typeof iterator !== "function")
+    if (typeof iterator !== "function") {
       return documents;
-    for (let index = 0, length = documents.length;index < length; index += 1)
+    }
+    for (let index = 0, length = documents.length;index < length; index += 1) {
       iterator(documents[index]);
+    }
   }
-  function load(input, options) {
+  function load2(input, options) {
     const documents = loadDocuments(input, options);
-    if (documents.length === 0)
+    if (documents.length === 0) {
       return;
-    else if (documents.length === 1)
+    } else if (documents.length === 1) {
       return documents[0];
-    throw new YAMLException("expected a single document in the stream, but found more");
+    }
+    throw new YAMLException2("expected a single document in the stream, but found more");
   }
-  module.exports.loadAll = loadAll;
-  module.exports.load = load;
-});
-var require_dumper = /* @__PURE__ */ __commonJSMin((exports, module) => {
-  var common = require_common();
-  var YAMLException = require_exception();
-  var DEFAULT_SCHEMA = require_default();
-  var _toString = Object.prototype.toString;
-  var _hasOwnProperty = Object.prototype.hasOwnProperty;
-  var CHAR_BOM = 65279;
-  var CHAR_TAB = 9;
-  var CHAR_LINE_FEED = 10;
-  var CHAR_CARRIAGE_RETURN = 13;
-  var CHAR_SPACE = 32;
-  var CHAR_EXCLAMATION = 33;
-  var CHAR_DOUBLE_QUOTE = 34;
-  var CHAR_SHARP = 35;
-  var CHAR_PERCENT = 37;
-  var CHAR_AMPERSAND = 38;
-  var CHAR_SINGLE_QUOTE = 39;
-  var CHAR_ASTERISK = 42;
-  var CHAR_COMMA = 44;
-  var CHAR_MINUS = 45;
-  var CHAR_COLON = 58;
-  var CHAR_EQUALS = 61;
-  var CHAR_GREATER_THAN = 62;
-  var CHAR_QUESTION = 63;
-  var CHAR_COMMERCIAL_AT = 64;
-  var CHAR_LEFT_SQUARE_BRACKET = 91;
-  var CHAR_RIGHT_SQUARE_BRACKET = 93;
-  var CHAR_GRAVE_ACCENT = 96;
-  var CHAR_LEFT_CURLY_BRACKET = 123;
-  var CHAR_VERTICAL_LINE = 124;
-  var CHAR_RIGHT_CURLY_BRACKET = 125;
-  var ESCAPE_SEQUENCES = {};
+  loader.loadAll = loadAll2;
+  loader.load = load2;
+  return loader;
+}
+var dumper = {};
+var hasRequiredDumper;
+function requireDumper() {
+  if (hasRequiredDumper)
+    return dumper;
+  hasRequiredDumper = 1;
+  const common2 = requireCommon();
+  const YAMLException2 = requireException();
+  const DEFAULT_SCHEMA2 = require_default();
+  const _toString = Object.prototype.toString;
+  const _hasOwnProperty = Object.prototype.hasOwnProperty;
+  const CHAR_BOM = 65279;
+  const CHAR_TAB = 9;
+  const CHAR_LINE_FEED = 10;
+  const CHAR_CARRIAGE_RETURN = 13;
+  const CHAR_SPACE = 32;
+  const CHAR_EXCLAMATION = 33;
+  const CHAR_DOUBLE_QUOTE = 34;
+  const CHAR_SHARP = 35;
+  const CHAR_PERCENT = 37;
+  const CHAR_AMPERSAND = 38;
+  const CHAR_SINGLE_QUOTE = 39;
+  const CHAR_ASTERISK = 42;
+  const CHAR_COMMA = 44;
+  const CHAR_MINUS = 45;
+  const CHAR_COLON = 58;
+  const CHAR_EQUALS = 61;
+  const CHAR_GREATER_THAN = 62;
+  const CHAR_QUESTION = 63;
+  const CHAR_COMMERCIAL_AT = 64;
+  const CHAR_LEFT_SQUARE_BRACKET = 91;
+  const CHAR_RIGHT_SQUARE_BRACKET = 93;
+  const CHAR_GRAVE_ACCENT = 96;
+  const CHAR_LEFT_CURLY_BRACKET = 123;
+  const CHAR_VERTICAL_LINE = 124;
+  const CHAR_RIGHT_CURLY_BRACKET = 125;
+  const ESCAPE_SEQUENCES = {};
   ESCAPE_SEQUENCES[0] = "\\0";
   ESCAPE_SEQUENCES[7] = "\\a";
   ESCAPE_SEQUENCES[8] = "\\b";
@@ -7228,7 +7526,7 @@ var require_dumper = /* @__PURE__ */ __commonJSMin((exports, module) => {
   ESCAPE_SEQUENCES[160] = "\\_";
   ESCAPE_SEQUENCES[8232] = "\\L";
   ESCAPE_SEQUENCES[8233] = "\\P";
-  var DEPRECATED_BOOLEANS_SYNTAX = [
+  const DEPRECATED_BOOLEANS_SYNTAX = [
     "y",
     "Y",
     "yes",
@@ -7246,20 +7544,22 @@ var require_dumper = /* @__PURE__ */ __commonJSMin((exports, module) => {
     "Off",
     "OFF"
   ];
-  var DEPRECATED_BASE60_SYNTAX = /^[-+]?[0-9_]+(?::[0-9_]+)+(?:\.[0-9_]*)?$/;
-  function compileStyleMap(schema, map) {
-    if (map === null)
+  const DEPRECATED_BASE60_SYNTAX = /^[-+]?[0-9_]+(?::[0-9_]+)+(?:\.[0-9_]*)?$/;
+  function compileStyleMap(schema2, map2) {
+    if (map2 === null)
       return {};
     const result = {};
-    const keys = Object.keys(map);
+    const keys = Object.keys(map2);
     for (let index = 0, length = keys.length;index < length; index += 1) {
       let tag = keys[index];
-      let style = String(map[tag]);
-      if (tag.slice(0, 2) === "!!")
+      let style = String(map2[tag]);
+      if (tag.slice(0, 2) === "!!") {
         tag = "tag:yaml.org,2002:" + tag.slice(2);
-      const type = schema.compiledTypeMap["fallback"][tag];
-      if (type && _hasOwnProperty.call(type.styleAliases, style))
-        style = type.styleAliases[style];
+      }
+      const type2 = schema2.compiledTypeMap["fallback"][tag];
+      if (type2 && _hasOwnProperty.call(type2.styleAliases, style)) {
+        style = type2.styleAliases[style];
+      }
       result[tag] = style;
     }
     return result;
@@ -7277,18 +7577,19 @@ var require_dumper = /* @__PURE__ */ __commonJSMin((exports, module) => {
     } else if (character <= 4294967295) {
       handle = "U";
       length = 8;
-    } else
-      throw new YAMLException("code point within a string may not be greater than 0xFFFFFFFF");
-    return "\\" + handle + common.repeat("0", length - string.length) + string;
+    } else {
+      throw new YAMLException2("code point within a string may not be greater than 0xFFFFFFFF");
+    }
+    return "\\" + handle + common2.repeat("0", length - string.length) + string;
   }
-  var QUOTING_TYPE_SINGLE = 1;
-  var QUOTING_TYPE_DOUBLE = 2;
+  const QUOTING_TYPE_SINGLE = 1;
+  const QUOTING_TYPE_DOUBLE = 2;
   function State(options) {
-    this.schema = options["schema"] || DEFAULT_SCHEMA;
+    this.schema = options["schema"] || DEFAULT_SCHEMA2;
     this.indent = Math.max(1, options["indent"] || 2);
     this.noArrayIndent = options["noArrayIndent"] || false;
     this.skipInvalid = options["skipInvalid"] || false;
-    this.flowLevel = common.isNothing(options["flowLevel"]) ? -1 : options["flowLevel"];
+    this.flowLevel = common2.isNothing(options["flowLevel"]) ? -1 : options["flowLevel"];
     this.styleMap = compileStyleMap(this.schema, options["styles"] || null);
     this.sortKeys = options["sortKeys"] || false;
     this.lineWidth = options["lineWidth"] || 80;
@@ -7306,7 +7607,7 @@ var require_dumper = /* @__PURE__ */ __commonJSMin((exports, module) => {
     this.usedDuplicates = null;
   }
   function indentString(string, spaces) {
-    const ind = common.repeat(" ", spaces);
+    const ind = common2.repeat(" ", spaces);
     let position = 0;
     let result = "";
     const length = string.length;
@@ -7330,12 +7631,15 @@ var require_dumper = /* @__PURE__ */ __commonJSMin((exports, module) => {
   }
   function generateNextLine(state, level) {
     return `
-` + common.repeat(" ", state.indent * level);
+` + common2.repeat(" ", state.indent * level);
   }
-  function testImplicitResolving(state, str) {
-    for (let index = 0, length = state.implicitTypes.length;index < length; index += 1)
-      if (state.implicitTypes[index].resolve(str))
+  function testImplicitResolving(state, str2) {
+    for (let index = 0, length = state.implicitTypes.length;index < length; index += 1) {
+      const type2 = state.implicitTypes[index];
+      if (type2.resolve(str2)) {
         return true;
+      }
+    }
     return false;
   }
   function isWhitespace(c) {
@@ -7363,19 +7667,21 @@ var require_dumper = /* @__PURE__ */ __commonJSMin((exports, module) => {
     let second;
     if (first >= 55296 && first <= 56319 && pos + 1 < string.length) {
       second = string.charCodeAt(pos + 1);
-      if (second >= 56320 && second <= 57343)
+      if (second >= 56320 && second <= 57343) {
         return (first - 55296) * 1024 + second - 56320 + 65536;
+      }
     }
     return first;
   }
   function needIndentIndicator(string) {
-    return /^\n* /.test(string);
-  }
-  var STYLE_PLAIN = 1;
-  var STYLE_SINGLE = 2;
-  var STYLE_LITERAL = 3;
-  var STYLE_FOLDED = 4;
-  var STYLE_DOUBLE = 5;
+    const leadingSpaceRe = /^\n* /;
+    return leadingSpaceRe.test(string);
+  }
+  const STYLE_PLAIN = 1;
+  const STYLE_SINGLE = 2;
+  const STYLE_LITERAL = 3;
+  const STYLE_FOLDED = 4;
+  const STYLE_DOUBLE = 5;
   function chooseScalarStyle(string, singleLineOnly, indentPerLevel, lineWidth, testAmbiguousType, quotingType, forceQuotes, inblock) {
     let i;
     let char = 0;
@@ -7385,15 +7691,16 @@ var require_dumper = /* @__PURE__ */ __commonJSMin((exports, module) => {
     const shouldTrackWidth = lineWidth !== -1;
     let previousLineBreak = -1;
     let plain = isPlainSafeFirst(codePointAt(string, 0)) && isPlainSafeLast(codePointAt(string, string.length - 1));
-    if (singleLineOnly || forceQuotes)
+    if (singleLineOnly || forceQuotes) {
       for (i = 0;i < string.length; char >= 65536 ? i += 2 : i++) {
         char = codePointAt(string, i);
-        if (!isPrintable(char))
+        if (!isPrintable(char)) {
           return STYLE_DOUBLE;
+        }
         plain = plain && isPlainSafe(char, prevChar, inblock);
         prevChar = char;
       }
-    else {
+    } else {
       for (i = 0;i < string.length; char >= 65536 ? i += 2 : i++) {
         char = codePointAt(string, i);
         if (char === CHAR_LINE_FEED) {
@@ -7402,31 +7709,37 @@ var require_dumper = /* @__PURE__ */ __commonJSMin((exports, module) => {
             hasFoldableLine = hasFoldableLine || i - previousLineBreak - 1 > lineWidth && string[previousLineBreak + 1] !== " ";
             previousLineBreak = i;
           }
-        } else if (!isPrintable(char))
+        } else if (!isPrintable(char)) {
           return STYLE_DOUBLE;
+        }
         plain = plain && isPlainSafe(char, prevChar, inblock);
         prevChar = char;
       }
-      hasFoldableLine = hasFoldableLine || shouldTrackWidth && i - previousLineBreak - 1 > lineWidth && string[previousLineBreak + 1] !== " ";
+      hasFoldableLine = hasFoldableLine || shouldTrackWidth && (i - previousLineBreak - 1 > lineWidth && string[previousLineBreak + 1] !== " ");
     }
     if (!hasLineBreak && !hasFoldableLine) {
-      if (plain && !forceQuotes && !testAmbiguousType(string))
+      if (plain && !forceQuotes && !testAmbiguousType(string)) {
         return STYLE_PLAIN;
+      }
       return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE;
     }
-    if (indentPerLevel > 9 && needIndentIndicator(string))
+    if (indentPerLevel > 9 && needIndentIndicator(string)) {
       return STYLE_DOUBLE;
-    if (!forceQuotes)
+    }
+    if (!forceQuotes) {
       return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL;
+    }
     return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE;
   }
   function writeScalar(state, string, level, iskey, inblock) {
     state.dump = function() {
-      if (string.length === 0)
+      if (string.length === 0) {
         return state.quotingType === QUOTING_TYPE_DOUBLE ? '""' : "''";
+      }
       if (!state.noCompatMode) {
-        if (DEPRECATED_BOOLEANS_SYNTAX.indexOf(string) !== -1 || DEPRECATED_BASE60_SYNTAX.test(string))
+        if (DEPRECATED_BOOLEANS_SYNTAX.indexOf(string) !== -1 || DEPRECATED_BASE60_SYNTAX.test(string)) {
           return state.quotingType === QUOTING_TYPE_DOUBLE ? '"' + string + '"' : "'" + string + "'";
+        }
       }
       const indent = state.indent * Math.max(1, level);
       const lineWidth = state.lineWidth === -1 ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent);
@@ -7444,9 +7757,9 @@ var require_dumper = /* @__PURE__ */ __commonJSMin((exports, module) => {
         case STYLE_FOLDED:
           return ">" + blockHeader(string, state.indent) + dropEndingNewline(indentString(foldString(string, lineWidth), indent));
         case STYLE_DOUBLE:
-          return '"' + escapeString(string, lineWidth) + '"';
+          return '"' + escapeString(string) + '"';
         default:
-          throw new YAMLException("impossible error: invalid scalar style");
+          throw new YAMLException2("impossible error: invalid scalar style");
       }
     }();
   }
@@ -7454,9 +7767,11 @@ var require_dumper = /* @__PURE__ */ __commonJSMin((exports, module) => {
     const indentIndicator = needIndentIndicator(string) ? String(indentPerLevel) : "";
     const clip = string[string.length - 1] === `
 `;
-    return indentIndicator + (clip && (string[string.length - 2] === `
+    const keep = clip && (string[string.length - 2] === `
 ` || string === `
-`) ? "+" : clip ? "" : "-") + `
+`);
+    const chomp = keep ? "+" : clip ? "" : "-";
+    return indentIndicator + chomp + `
 `;
   }
   function dropEndingNewline(string) {
@@ -7508,11 +7823,12 @@ var require_dumper = /* @__PURE__ */ __commonJSMin((exports, module) => {
     }
     result += `
 `;
-    if (line.length - start > width && curr > start)
+    if (line.length - start > width && curr > start) {
       result += line.slice(start, curr) + `
 ` + line.slice(curr + 1);
-    else
+    } else {
       result += line.slice(start);
+    }
     return result.slice(1);
   }
   function escapeString(string) {
@@ -7525,8 +7841,9 @@ var require_dumper = /* @__PURE__ */ __commonJSMin((exports, module) => {
         result += string[i];
         if (char >= 65536)
           result += string[i + 1];
-      } else
+      } else {
         result += escapeSeq || encodeHex(char);
+      }
     }
     return result;
   }
@@ -7535,8 +7852,9 @@ var require_dumper = /* @__PURE__ */ __commonJSMin((exports, module) => {
     const _tag = state.tag;
     for (let index = 0, length = object.length;index < length; index += 1) {
       let value = object[index];
-      if (state.replacer)
+      if (state.replacer) {
         value = state.replacer.call(object, String(index), value);
+      }
       if (writeNode(state, level, value, false, false) || typeof value === "undefined" && writeNode(state, level, null, false, false)) {
         if (_result !== "")
           _result += "," + (!state.condenseFlow ? " " : "");
@@ -7551,15 +7869,18 @@ var require_dumper = /* @__PURE__ */ __commonJSMin((exports, module) => {
     const _tag = state.tag;
     for (let index = 0, length = object.length;index < length; index += 1) {
       let value = object[index];
-      if (state.replacer)
+      if (state.replacer) {
         value = state.replacer.call(object, String(index), value);
+      }
       if (writeNode(state, level + 1, value, true, true, false, true) || typeof value === "undefined" && writeNode(state, level + 1, null, true, true, false, true)) {
-        if (!compact || _result !== "")
+        if (!compact || _result !== "") {
           _result += generateNextLine(state, level);
-        if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0))
+        }
+        if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
           _result += "-";
-        else
+        } else {
           _result += "- ";
+        }
         _result += state.dump;
       }
     }
@@ -7578,15 +7899,18 @@ var require_dumper = /* @__PURE__ */ __commonJSMin((exports, module) => {
         pairBuffer += '"';
       const objectKey = objectKeyList[index];
       let objectValue = object[objectKey];
-      if (state.replacer)
+      if (state.replacer) {
         objectValue = state.replacer.call(object, objectKey, objectValue);
-      if (!writeNode(state, level, objectKey, false, false))
+      }
+      if (!writeNode(state, level, objectKey, false, false)) {
         continue;
+      }
       if (state.dump.length > 1024)
         pairBuffer += "? ";
       pairBuffer += state.dump + (state.condenseFlow ? '"' : "") + ":" + (state.condenseFlow ? "" : " ");
-      if (!writeNode(state, level, objectValue, false, false))
+      if (!writeNode(state, level, objectValue, false, false)) {
         continue;
+      }
       pairBuffer += state.dump;
       _result += pairBuffer;
     }
@@ -7597,37 +7921,46 @@ var require_dumper = /* @__PURE__ */ __commonJSMin((exports, module) => {
     let _result = "";
     const _tag = state.tag;
     const objectKeyList = Object.keys(object);
-    if (state.sortKeys === true)
+    if (state.sortKeys === true) {
       objectKeyList.sort();
-    else if (typeof state.sortKeys === "function")
+    } else if (typeof state.sortKeys === "function") {
       objectKeyList.sort(state.sortKeys);
-    else if (state.sortKeys)
-      throw new YAMLException("sortKeys must be a boolean or a function");
+    } else if (state.sortKeys) {
+      throw new YAMLException2("sortKeys must be a boolean or a function");
+    }
     for (let index = 0, length = objectKeyList.length;index < length; index += 1) {
       let pairBuffer = "";
-      if (!compact || _result !== "")
+      if (!compact || _result !== "") {
         pairBuffer += generateNextLine(state, level);
+      }
       const objectKey = objectKeyList[index];
       let objectValue = object[objectKey];
-      if (state.replacer)
+      if (state.replacer) {
         objectValue = state.replacer.call(object, objectKey, objectValue);
-      if (!writeNode(state, level + 1, objectKey, true, true, true))
+      }
+      if (!writeNode(state, level + 1, objectKey, true, true, true)) {
         continue;
+      }
       const explicitPair = state.tag !== null && state.tag !== "?" || state.dump && state.dump.length > 1024;
-      if (explicitPair)
-        if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0))
+      if (explicitPair) {
+        if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
           pairBuffer += "?";
-        else
+        } else {
           pairBuffer += "? ";
+        }
+      }
       pairBuffer += state.dump;
-      if (explicitPair)
+      if (explicitPair) {
         pairBuffer += generateNextLine(state, level);
-      if (!writeNode(state, level + 1, objectValue, true, explicitPair))
+      }
+      if (!writeNode(state, level + 1, objectValue, true, explicitPair)) {
         continue;
-      if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0))
+      }
+      if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
         pairBuffer += ":";
-      else
+      } else {
         pairBuffer += ": ";
+      }
       pairBuffer += state.dump;
       _result += pairBuffer;
     }
@@ -7637,24 +7970,27 @@ var require_dumper = /* @__PURE__ */ __commonJSMin((exports, module) => {
   function detectType(state, object, explicit) {
     const typeList = explicit ? state.explicitTypes : state.implicitTypes;
     for (let index = 0, length = typeList.length;index < length; index += 1) {
-      const type = typeList[index];
-      if ((type.instanceOf || type.predicate) && (!type.instanceOf || typeof object === "object" && object instanceof type.instanceOf) && (!type.predicate || type.predicate(object))) {
-        if (explicit)
-          if (type.multi && type.representName)
-            state.tag = type.representName(object);
-          else
-            state.tag = type.tag;
-        else
+      const type2 = typeList[index];
+      if ((type2.instanceOf || type2.predicate) && (!type2.instanceOf || typeof object === "object" && object instanceof type2.instanceOf) && (!type2.predicate || type2.predicate(object))) {
+        if (explicit) {
+          if (type2.multi && type2.representName) {
+            state.tag = type2.representName(object);
+          } else {
+            state.tag = type2.tag;
+          }
+        } else {
           state.tag = "?";
-        if (type.represent) {
-          const style = state.styleMap[type.tag] || type.defaultStyle;
+        }
+        if (type2.represent) {
+          const style = state.styleMap[type2.tag] || type2.defaultStyle;
           let _result;
-          if (_toString.call(type.represent) === "[object Function]")
-            _result = type.represent(object, style);
-          else if (_hasOwnProperty.call(type.represent, style))
-            _result = type.represent[style](object, style);
-          else
-            throw new YAMLException("!<" + type.tag + '> tag resolver accepts not "' + style + '" style');
+          if (_toString.call(type2.represent) === "[object Function]") {
+            _result = type2.represent(object, style);
+          } else if (_hasOwnProperty.call(type2.represent, style)) {
+            _result = type2.represent[style](object, style);
+          } else {
+            throw new YAMLException2("!<" + type2.tag + '> tag resolver accepts not "' + style + '" style');
+          }
           state.dump = _result;
         }
         return true;
@@ -7665,67 +8001,78 @@ var require_dumper = /* @__PURE__ */ __commonJSMin((exports, module) => {
   function writeNode(state, level, object, block, compact, iskey, isblockseq) {
     state.tag = null;
     state.dump = object;
-    if (!detectType(state, object, false))
+    if (!detectType(state, object, false)) {
       detectType(state, object, true);
-    const type = _toString.call(state.dump);
+    }
+    const type2 = _toString.call(state.dump);
     const inblock = block;
-    if (block)
+    if (block) {
       block = state.flowLevel < 0 || state.flowLevel > level;
-    const objectOrArray = type === "[object Object]" || type === "[object Array]";
+    }
+    const objectOrArray = type2 === "[object Object]" || type2 === "[object Array]";
     let duplicateIndex;
     let duplicate;
     if (objectOrArray) {
       duplicateIndex = state.duplicates.indexOf(object);
       duplicate = duplicateIndex !== -1;
     }
-    if (state.tag !== null && state.tag !== "?" || duplicate || state.indent !== 2 && level > 0)
+    if (state.tag !== null && state.tag !== "?" || duplicate || state.indent !== 2 && level > 0) {
       compact = false;
-    if (duplicate && state.usedDuplicates[duplicateIndex])
+    }
+    if (duplicate && state.usedDuplicates[duplicateIndex]) {
       state.dump = "*ref_" + duplicateIndex;
-    else {
-      if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex])
+    } else {
+      if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) {
         state.usedDuplicates[duplicateIndex] = true;
-      if (type === "[object Object]")
+      }
+      if (type2 === "[object Object]") {
         if (block && Object.keys(state.dump).length !== 0) {
           writeBlockMapping(state, level, state.dump, compact);
-          if (duplicate)
+          if (duplicate) {
             state.dump = "&ref_" + duplicateIndex + state.dump;
+          }
         } else {
           writeFlowMapping(state, level, state.dump);
-          if (duplicate)
+          if (duplicate) {
             state.dump = "&ref_" + duplicateIndex + " " + state.dump;
+          }
         }
-      else if (type === "[object Array]")
+      } else if (type2 === "[object Array]") {
         if (block && state.dump.length !== 0) {
-          if (state.noArrayIndent && !isblockseq && level > 0)
+          if (state.noArrayIndent && !isblockseq && level > 0) {
             writeBlockSequence(state, level - 1, state.dump, compact);
-          else
+          } else {
             writeBlockSequence(state, level, state.dump, compact);
-          if (duplicate)
+          }
+          if (duplicate) {
             state.dump = "&ref_" + duplicateIndex + state.dump;
+          }
         } else {
           writeFlowSequence(state, level, state.dump);
-          if (duplicate)
+          if (duplicate) {
             state.dump = "&ref_" + duplicateIndex + " " + state.dump;
+          }
         }
-      else if (type === "[object String]") {
-        if (state.tag !== "?")
+      } else if (type2 === "[object String]") {
+        if (state.tag !== "?") {
           writeScalar(state, state.dump, level, iskey, inblock);
-      } else if (type === "[object Undefined]")
+        }
+      } else if (type2 === "[object Undefined]") {
         return false;
-      else {
+      } else {
         if (state.skipInvalid)
           return false;
-        throw new YAMLException("unacceptable kind of an object to dump " + type);
+        throw new YAMLException2("unacceptable kind of an object to dump " + type2);
       }
       if (state.tag !== null && state.tag !== "?") {
         let tagStr = encodeURI(state.tag[0] === "!" ? state.tag.slice(1) : state.tag).replace(/!/g, "%21");
-        if (state.tag[0] === "!")
+        if (state.tag[0] === "!") {
           tagStr = "!" + tagStr;
-        else if (tagStr.slice(0, 18) === "tag:yaml.org,2002:")
+        } else if (tagStr.slice(0, 18) === "tag:yaml.org,2002:") {
           tagStr = "!!" + tagStr.slice(18);
-        else
+        } else {
           tagStr = "!<" + tagStr + ">";
+        }
         state.dump = tagStr + " " + state.dump;
       }
     }
@@ -7736,83 +8083,110 @@ var require_dumper = /* @__PURE__ */ __commonJSMin((exports, module) => {
     const duplicatesIndexes = [];
     inspectNode(object, objects, duplicatesIndexes);
     const length = duplicatesIndexes.length;
-    for (let index = 0;index < length; index += 1)
+    for (let index = 0;index < length; index += 1) {
       state.duplicates.push(objects[duplicatesIndexes[index]]);
+    }
     state.usedDuplicates = new Array(length);
   }
   function inspectNode(object, objects, duplicatesIndexes) {
     if (object !== null && typeof object === "object") {
       const index = objects.indexOf(object);
       if (index !== -1) {
-        if (duplicatesIndexes.indexOf(index) === -1)
+        if (duplicatesIndexes.indexOf(index) === -1) {
           duplicatesIndexes.push(index);
+        }
       } else {
         objects.push(object);
-        if (Array.isArray(object))
-          for (let i = 0, length = object.length;i < length; i += 1)
+        if (Array.isArray(object)) {
+          for (let i = 0, length = object.length;i < length; i += 1) {
             inspectNode(object[i], objects, duplicatesIndexes);
-        else {
+          }
+        } else {
           const objectKeyList = Object.keys(object);
-          for (let i = 0, length = objectKeyList.length;i < length; i += 1)
+          for (let i = 0, length = objectKeyList.length;i < length; i += 1) {
             inspectNode(object[objectKeyList[i]], objects, duplicatesIndexes);
+          }
         }
       }
     }
   }
-  function dump(input, options) {
+  function dump2(input, options) {
     options = options || {};
     const state = new State(options);
     if (!state.noRefs)
       getDuplicateReferences(input, state);
     let value = input;
-    if (state.replacer)
+    if (state.replacer) {
       value = state.replacer.call({ "": value }, "", value);
+    }
     if (writeNode(state, 0, value, true, true))
       return state.dump + `
 `;
     return "";
   }
-  module.exports.dump = dump;
-});
-var import_js_yaml = /* @__PURE__ */ __toESM2((/* @__PURE__ */ __commonJSMin((exports, module) => {
-  var loader = require_loader();
-  var dumper = require_dumper();
+  dumper.dump = dump2;
+  return dumper;
+}
+var hasRequiredJsYaml;
+function requireJsYaml() {
+  if (hasRequiredJsYaml)
+    return jsYaml;
+  hasRequiredJsYaml = 1;
+  const loader2 = requireLoader();
+  const dumper2 = requireDumper();
   function renamed(from, to) {
     return function() {
       throw new Error("Function yaml." + from + " is removed in js-yaml 4. Use yaml." + to + " instead, which is now safe by default.");
     };
   }
-  module.exports.Type = require_type();
-  module.exports.Schema = require_schema();
-  module.exports.FAILSAFE_SCHEMA = require_failsafe();
-  module.exports.JSON_SCHEMA = require_json();
-  module.exports.CORE_SCHEMA = require_core();
-  module.exports.DEFAULT_SCHEMA = require_default();
-  module.exports.load = loader.load;
-  module.exports.loadAll = loader.loadAll;
-  module.exports.dump = dumper.dump;
-  module.exports.YAMLException = require_exception();
-  module.exports.types = {
-    binary: require_binary(),
-    float: require_float(),
-    map: require_map(),
+  jsYaml.Type = requireType();
+  jsYaml.Schema = requireSchema();
+  jsYaml.FAILSAFE_SCHEMA = requireFailsafe();
+  jsYaml.JSON_SCHEMA = requireJson();
+  jsYaml.CORE_SCHEMA = requireCore();
+  jsYaml.DEFAULT_SCHEMA = require_default();
+  jsYaml.load = loader2.load;
+  jsYaml.loadAll = loader2.loadAll;
+  jsYaml.dump = dumper2.dump;
+  jsYaml.YAMLException = requireException();
+  jsYaml.types = {
+    binary: requireBinary(),
+    float: requireFloat(),
+    map: requireMap(),
     null: require_null(),
-    pairs: require_pairs(),
-    set: require_set(),
-    timestamp: require_timestamp(),
-    bool: require_bool(),
-    int: require_int(),
-    merge: require_merge(),
-    omap: require_omap(),
-    seq: require_seq(),
-    str: require_str()
+    pairs: requirePairs(),
+    set: requireSet(),
+    timestamp: requireTimestamp(),
+    bool: requireBool(),
+    int: requireInt(),
+    merge: requireMerge(),
+    omap: requireOmap(),
+    seq: requireSeq(),
+    str: requireStr()
   };
-  module.exports.safeLoad = renamed("safeLoad", "load");
-  module.exports.safeLoadAll = renamed("safeLoadAll", "loadAll");
-  module.exports.safeDump = renamed("safeDump", "dump");
-}))(), 1);
-var { Type, Schema, FAILSAFE_SCHEMA, JSON_SCHEMA, CORE_SCHEMA, DEFAULT_SCHEMA, load, loadAll, dump, YAMLException, types, safeLoad, safeLoadAll, safeDump } = import_js_yaml.default;
-var index_vite_proxy_tmp_default = import_js_yaml.default;
+  jsYaml.safeLoad = renamed("safeLoad", "load");
+  jsYaml.safeLoadAll = renamed("safeLoadAll", "loadAll");
+  jsYaml.safeDump = renamed("safeDump", "dump");
+  return jsYaml;
+}
+var jsYamlExports = requireJsYaml();
+var yaml = /* @__PURE__ */ getDefaultExportFromCjs(jsYamlExports);
+var {
+  Type,
+  Schema,
+  FAILSAFE_SCHEMA,
+  JSON_SCHEMA,
+  CORE_SCHEMA,
+  DEFAULT_SCHEMA,
+  load,
+  loadAll,
+  dump,
+  YAMLException,
+  types,
+  safeLoad,
+  safeLoadAll,
+  safeDump
+} = yaml;
 
 // ../common/src/logger.ts
 var logFilePathSlot = singleton("logFilePath");
@@ -7888,11 +8262,11 @@ class SimpleLogger {
     const path3 = this.logFilePath || getGlobalLogFilePath();
     if (!path3)
       return;
-    const timestamp = new Date().toISOString();
+    const timestamp2 = new Date().toISOString();
     this.pendingWrites = Promise.all([
       this.pendingWrites,
       this.pendingInit
-    ]).then(() => getFileSystem().appendFile(path3, `${timestamp} ${formatted}`).catch(() => {}));
+    ]).then(() => getFileSystem().appendFile(path3, `${timestamp2} ${formatted}`).catch(() => {}));
   }
   debug(message, ...args) {
     if (this.level > 0 /* DEBUG */)
@@ -8008,6 +8382,7 @@ function getLogFilePath() {
 // ../common/src/output-format-context.ts
 var formatSlot = singleton("OutputFormat");
 var formatExplicitSlot = singleton("OutputFormatExplicit");
+var helpRequestedSlot = singleton("HelpRequested");
 var filterSlot = singleton("OutputFilter");
 function getOutputFormat() {
   return formatSlot.get("json");
@@ -8285,10 +8660,10 @@ class LoggerTelemetryProvider {
       success
     })));
   }
-  async trackDependency(name, type, duration, success, properties) {
+  async trackDependency(name, type2, duration, success, properties) {
     logger.debug(formatMessage("Dependency", name, this.enrich({
       ...properties,
-      type,
+      type: type2,
       duration: `${duration}ms`,
       success
     })));
@@ -8446,11 +8821,36 @@ class NodeContextStorage {
     return this.storage.getStore();
   }
 }
+// ../common/src/telemetry/trace-context.ts
+var TELEMETRY_TRACEPARENT_ENV = "TRACEPARENT";
+var TRACEPARENT_PATTERN = /^00-([0-9a-f]{32})-([0-9a-f]{16})-[0-9a-f]{2}$/;
+function getProcessEnv() {
+  return globalThis.process?.env;
+}
+function parseInboundTraceparent(value) {
+  if (!value) {
+    return;
+  }
+  const match = TRACEPARENT_PATTERN.exec(value.trim().toLowerCase());
+  if (!match) {
+    return;
+  }
+  const [, traceId, parentSpanId] = match;
+  if (/^0+$/.test(traceId) || /^0+$/.test(parentSpanId)) {
+    return;
+  }
+  return { traceId, parentSpanId };
+}
+function getInboundTraceContext() {
+  return parseInboundTraceparent(getProcessEnv()?.[TELEMETRY_TRACEPARENT_ENV]);
+}
+
 // ../common/src/telemetry/session-id.ts
 var TELEMETRY_SESSION_ID_ENV = "UIPATH_SESSION_ID";
 var TELEMETRY_SESSION_ID_PROPERTY = "session_id";
 var telemetrySessionIdSlot = singleton("TelemetrySessionId");
-function getProcessEnv() {
+var telemetryOperationIdSlot = singleton("TelemetryOperationId");
+function getProcessEnv2() {
   return globalThis.process?.env;
 }
 function normalizeSessionId(value) {
@@ -8461,18 +8861,165 @@ function normalizeSessionId(value) {
   return trimmed || undefined;
 }
 function getConfiguredTelemetrySessionId() {
-  return normalizeSessionId(getProcessEnv()?.[TELEMETRY_SESSION_ID_ENV]);
+  return normalizeSessionId(getProcessEnv2()?.[TELEMETRY_SESSION_ID_ENV]);
 }
 function resolveTelemetrySessionId(existingSessionId) {
   return getConfiguredTelemetrySessionId() ?? normalizeSessionId(existingSessionId);
 }
+function getTelemetryOperationId() {
+  const existing = telemetryOperationIdSlot.get();
+  if (existing) {
+    return existing;
+  }
+  const inboundTraceId = getInboundTraceContext()?.traceId;
+  const generated = inboundTraceId ?? crypto.randomUUID().replaceAll("-", "");
+  telemetryOperationIdSlot.set(generated);
+  return generated;
+}
 // ../common/src/telemetry/global-telemetry-properties.ts
 var telemetryPropsSlot = singleton("TelemetryDefaultProps");
 function getGlobalTelemetryProperties() {
   return telemetryPropsSlot.get();
 }
 
+// ../common/src/telemetry/pii-redactor.ts
+var REDACTED = "[REDACTED]";
+var MAX_VALUE_LENGTH = 200;
+var SENSITIVE_NAME_TOKENS = new Set([
+  "token",
+  "tokens",
+  "secret",
+  "secrets",
+  "password",
+  "passwords",
+  "pwd",
+  "credential",
+  "credentials",
+  "auth",
+  "authentication",
+  "authorization",
+  "authority",
+  "cert",
+  "certificate",
+  "certificates"
+]);
+var SENSITIVE_KEY_PREFIXES = new Set([
+  "api",
+  "access",
+  "client",
+  "private",
+  "public",
+  "signing",
+  "encryption",
+  "session",
+  "master",
+  "shared",
+  "root",
+  "ssh",
+  "rsa",
+  "aes",
+  "hmac",
+  "oauth"
+]);
+var UUID_PATTERN = /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi;
+var EMAIL_PATTERN = /\b[^\s@]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g;
+var JWT_PATTERN = /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g;
+var LONG_TOKEN_PATTERN = /\b[A-Za-z0-9_-]{40,}\b/g;
+var USER_HOME_PATTERN = /([/\\])(Users|home)([/\\])([^/\\]+)/gi;
+var URL_PATTERN = /\bhttps?:\/\/[^\s,;]+/gi;
+var URL_TRAILING_PUNCT = /[.,;:!?)\]}>'"]+$/;
+function shortHash(input) {
+  let hash = 2166136261;
+  for (let i = 0;i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function redactUrl(raw) {
+  try {
+    const url = new URL(raw);
+    return `${url.protocol}//${url.host}`;
+  } catch {
+    return `url#${shortHash(raw)}`;
+  }
+}
+function redactValueDetectors(value) {
+  let out = value;
+  out = out.replace(JWT_PATTERN, () => REDACTED);
+  out = out.replace(URL_PATTERN, (match) => {
+    const trailing = match.match(URL_TRAILING_PUNCT)?.[0] ?? "";
+    const core2 = trailing ? match.slice(0, -trailing.length) : match;
+    return `${redactUrl(core2)}${trailing}`;
+  });
+  out = out.replace(USER_HOME_PATTERN, (_match, sep1, folder, sep2) => `${sep1}${folder}${sep2}<user>`);
+  out = out.replace(EMAIL_PATTERN, (match) => `email#${shortHash(match)}`);
+  out = out.replace(UUID_PATTERN, (match) => `uuid#${shortHash(match)}`);
+  out = out.replace(LONG_TOKEN_PATTERN, () => REDACTED);
+  if (out.length > MAX_VALUE_LENGTH) {
+    out = `${out.slice(0, MAX_VALUE_LENGTH)}…`;
+  }
+  return out;
+}
+function redactValue(value) {
+  return redactValueDetectors(value);
+}
+function redactError(error) {
+  const safe = new Error(redactValueDetectors(error.message ?? ""));
+  safe.name = error.name;
+  safe.stack = typeof error.stack === "string" ? redactValueDetectors(error.stack) : undefined;
+  return safe;
+}
+function nameTokens(name) {
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").split(/[\s._-]+/).map((t) => t.toLowerCase()).filter(Boolean);
+}
+function isSensitiveName(name) {
+  const tokens = nameTokens(name);
+  for (let i = 0;i < tokens.length; i++) {
+    const token = tokens[i];
+    if (SENSITIVE_NAME_TOKENS.has(token)) {
+      return true;
+    }
+    if (token === "key" || token === "keys") {
+      const prev = tokens[i - 1];
+      if (prev && SENSITIVE_KEY_PREFIXES.has(prev)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function redactProperty(name, value) {
+  if (value === undefined || value === null) {
+    return;
+  }
+  if (isSensitiveName(name)) {
+    return REDACTED;
+  }
+  if (typeof value === "boolean" || typeof value === "number") {
+    return value;
+  }
+  if (typeof value !== "string") {
+    return "[OBJECT]";
+  }
+  return redactValueDetectors(value);
+}
+function redactProperties(properties) {
+  const out = {};
+  for (const [name, value] of Object.entries(properties)) {
+    const redacted = redactProperty(name, value);
+    if (redacted !== undefined) {
+      out[name] = redacted;
+    }
+  }
+  return out;
+}
+
 // ../common/src/telemetry/telemetry-service.ts
+var TELEMETRY_OPERATION_ID_PROPERTY = "uip.trace.operation_id";
+var TELEMETRY_PARENT_ID_PROPERTY = "uip.trace.parent_id";
+var TELEMETRY_SPAN_ID_PROPERTY = "uip.trace.span_id";
+
 class TelemetryService {
   telemetryProvider;
   contextStorage;
@@ -8499,11 +9046,15 @@ class TelemetryService {
   trackException(error, properties) {
     const context = this.getCurrentContext();
     const enrichedProperties = this.enrichPropertiesWithContext(properties, context);
-    this.telemetryProvider.trackException(error, enrichedProperties);
+    this.telemetryProvider.trackException(redactError(error), enrichedProperties);
   }
   async trackRequest(name, fn, properties) {
+    const parentContext = this.getCurrentContext();
+    const operationId = parentContext?.operationId ?? this.operationId ?? getTelemetryOperationId();
+    const parentId = parentContext ? parentContext.id : this.inboundParentIdFor(operationId);
     const context = {
-      operationId: this.operationId ?? this.generateId(),
+      operationId,
+      ...parentId !== undefined ? { parentId } : {},
       id: this.generateId()
     };
     const startTime = performance.now();
@@ -8521,7 +9072,46 @@ class TelemetryService {
       throw error;
     }
   }
-  async trackDependencyOperation(name, type, fn, properties) {
+  trackRequestResult(name, durationMs, success, properties, context) {
+    const requestContext = context ?? {
+      operationId: this.operationId ?? getTelemetryOperationId(),
+      id: this.generateId()
+    };
+    const enrichedProperties = this.enrichPropertiesWithContext(properties, requestContext);
+    this.telemetryProvider.trackRequest(name, durationMs, success, enrichedProperties);
+  }
+  createRequestContext() {
+    const operationId = this.operationId ?? getTelemetryOperationId();
+    const parentId = this.inboundParentIdFor(operationId);
+    return {
+      operationId,
+      ...parentId !== undefined ? { parentId } : {},
+      id: this.generateId()
+    };
+  }
+  inboundParentIdFor(operationId) {
+    const inbound = getInboundTraceContext();
+    return inbound && inbound.traceId === operationId ? inbound.parentSpanId : undefined;
+  }
+  runWithContext(context, fn) {
+    return this.contextStorage.run(context, fn);
+  }
+  createDependencyContext() {
+    const parentContext = this.getCurrentContext();
+    if (!parentContext) {
+      return;
+    }
+    return {
+      operationId: parentContext.operationId,
+      parentId: parentContext.id,
+      id: this.generateId()
+    };
+  }
+  trackDependencyResult(name, type2, durationMs, success, properties, context, resultCode) {
+    const enrichedProperties = this.enrichPropertiesWithContext(properties, context);
+    this.telemetryProvider.trackDependency(redactValue(name), type2, durationMs, success, enrichedProperties, resultCode);
+  }
+  async trackDependencyOperation(name, type2, fn, properties) {
     const parentContext = this.getCurrentContext();
     if (!parentContext) {
       throw new Error("trackDependencyOperation must be called within a trackRequest block.");
@@ -8536,13 +9126,13 @@ class TelemetryService {
       const result = await this.contextStorage.run(childContext, fn);
       const durationMs = performance.now() - startTime;
       const enrichedProperties = this.enrichPropertiesWithContext(properties, childContext);
-      await this.telemetryProvider.trackDependency(name, type, durationMs, true, enrichedProperties);
+      await this.telemetryProvider.trackDependency(name, type2, durationMs, true, enrichedProperties);
       return result;
     } catch (error) {
       const durationMs = performance.now() - startTime;
       const err = error instanceof Error ? error : new Error(String(error));
       const enrichedProperties = this.enrichPropertiesWithContext({ ...properties, errorMessage: err.message }, childContext);
-      await this.telemetryProvider.trackDependency(name, type, durationMs, false, enrichedProperties);
+      await this.telemetryProvider.trackDependency(name, type2, durationMs, false, enrichedProperties);
       throw error;
     }
   }
@@ -8557,8 +9147,12 @@ class TelemetryService {
       ...getExecutionContextTelemetryProperties(),
       ...globalProperties,
       ...this.defaultProperties,
-      ...properties,
-      ...context
+      ...redactProperties(properties ?? {}),
+      ...context ? {
+        [TELEMETRY_OPERATION_ID_PROPERTY]: context.operationId,
+        ...context.parentId !== undefined ? { [TELEMETRY_PARENT_ID_PROPERTY]: context.parentId } : {},
+        [TELEMETRY_SPAN_ID_PROPERTY]: context.id
+      } : {}
     };
     if (sessionId === undefined) {
       delete enriched[TELEMETRY_SESSION_ID_PROPERTY];
@@ -8568,7 +9162,16 @@ class TelemetryService {
     return enriched;
   }
   generateId() {
-    return crypto.randomUUID().replaceAll("-", "");
+    const bytes = new Uint8Array(8);
+    let hex = "";
+    do {
+      crypto.getRandomValues(bytes);
+      hex = "";
+      for (const byte of bytes) {
+        hex += byte.toString(16).padStart(2, "0");
+      }
+    } while (/^0+$/.test(hex));
+    return hex;
   }
 }
 // ../common/src/telemetry/node-appinsights-telemetry-provider.ts
@@ -8749,8 +9352,8 @@ function printOutput(data, format = "json", logFn, asciiSafe = false) {
   }
   switch (format) {
     case "json": {
-      const json = JSON.stringify(data, null, 2);
-      logFn(asciiSafe ? escapeNonAscii(json) : json);
+      const json2 = JSON.stringify(data, null, 2);
+      logFn(asciiSafe ? escapeNonAscii(json2) : json2);
       break;
     }
     case "yaml":
@@ -9075,6 +9678,9 @@ var OutputFormatter;
     if (opts?.warning) {
       data.Warning = opts.warning;
     }
+    if (opts?.pagination) {
+      data.Pagination = opts.pagination;
+    }
     success(data);
   }
   OutputFormatter.emitList = emitList;
@@ -9083,8 +9689,8 @@ var OutputFormatter;
     const sink = getOutputSink();
     const normalized = toPascalCaseData(data);
     if (format === "json") {
-      const json = JSON.stringify(normalized);
-      const safe = needsAsciiSafeJson(sink) ? escapeNonAscii(json) : json;
+      const json2 = JSON.stringify(normalized);
+      const safe = needsAsciiSafeJson(sink) ? escapeNonAscii(json2) : json2;
       sink.writeErr(`${safe}
 `);
     } else {
@@ -9267,152 +9873,25 @@ function buildCommandTelemetryAttribution(commandPath, skillSource) {
   };
 }
 
-// ../common/src/telemetry/pii-redactor.ts
-var REDACTED = "[REDACTED]";
-var MAX_VALUE_LENGTH = 200;
-var SENSITIVE_NAME_TOKENS = new Set([
-  "token",
-  "tokens",
-  "secret",
-  "secrets",
-  "password",
-  "passwords",
-  "pwd",
-  "credential",
-  "credentials",
-  "auth",
-  "authentication",
-  "authorization",
-  "authority",
-  "cert",
-  "certificate",
-  "certificates"
-]);
-var SENSITIVE_KEY_PREFIXES = new Set([
-  "api",
-  "access",
-  "client",
-  "private",
-  "public",
-  "signing",
-  "encryption",
-  "session",
-  "master",
-  "shared",
-  "root",
-  "ssh",
-  "rsa",
-  "aes",
-  "hmac",
-  "oauth"
-]);
-var UUID_PATTERN = /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi;
-var EMAIL_PATTERN = /\b[^\s@]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g;
-var JWT_PATTERN = /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g;
-var LONG_TOKEN_PATTERN = /\b[A-Za-z0-9_-]{40,}\b/g;
-var USER_HOME_PATTERN = /([/\\])(Users|home)([/\\])([^/\\]+)/gi;
-var URL_PATTERN = /\bhttps?:\/\/[^\s,;]+/gi;
-var URL_TRAILING_PUNCT = /[.,;:!?)\]}>'"]+$/;
-function shortHash(input) {
-  let hash = 2166136261;
-  for (let i = 0;i < input.length; i++) {
-    hash ^= input.charCodeAt(i);
-    hash = Math.imul(hash, 16777619);
-  }
-  return (hash >>> 0).toString(16).padStart(8, "0");
-}
-function redactUrl(raw) {
-  try {
-    const url = new URL(raw);
-    return `${url.protocol}//${url.host}`;
-  } catch {
-    return `url#${shortHash(raw)}`;
-  }
-}
-function redactValueDetectors(value) {
-  let out = value;
-  out = out.replace(JWT_PATTERN, () => REDACTED);
-  out = out.replace(URL_PATTERN, (match) => {
-    const trailing = match.match(URL_TRAILING_PUNCT)?.[0] ?? "";
-    const core = trailing ? match.slice(0, -trailing.length) : match;
-    return `${redactUrl(core)}${trailing}`;
-  });
-  out = out.replace(USER_HOME_PATTERN, (_match, sep1, folder, sep2) => `${sep1}${folder}${sep2}<user>`);
-  out = out.replace(EMAIL_PATTERN, (match) => `email#${shortHash(match)}`);
-  out = out.replace(UUID_PATTERN, (match) => `uuid#${shortHash(match)}`);
-  out = out.replace(LONG_TOKEN_PATTERN, () => REDACTED);
-  if (out.length > MAX_VALUE_LENGTH) {
-    out = `${out.slice(0, MAX_VALUE_LENGTH)}…`;
-  }
-  return out;
-}
-function nameTokens(name) {
-  return name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").split(/[\s_-]+/).map((t) => t.toLowerCase()).filter(Boolean);
-}
-function isSensitiveName(name) {
-  const tokens = nameTokens(name);
-  for (let i = 0;i < tokens.length; i++) {
-    const token = tokens[i];
-    if (SENSITIVE_NAME_TOKENS.has(token)) {
-      return true;
-    }
-    if (token === "key" || token === "keys") {
-      const prev = tokens[i - 1];
-      if (prev && SENSITIVE_KEY_PREFIXES.has(prev)) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-function redactProperty(name, value) {
-  if (value === undefined || value === null) {
-    return;
-  }
-  if (isSensitiveName(name)) {
-    return REDACTED;
-  }
-  if (typeof value === "boolean" || typeof value === "number") {
-    return value;
-  }
-  if (typeof value !== "string") {
-    return "[OBJECT]";
-  }
-  return redactValueDetectors(value);
-}
-function redactProperties(properties) {
-  const out = {};
-  for (const [name, value] of Object.entries(properties)) {
-    const redacted = redactProperty(name, value);
-    if (redacted !== undefined) {
-      out[name] = redacted;
-    }
-  }
-  return out;
-}
-
 // ../common/src/trackedAction.ts
 var pollSignalSlot = singleton("PollSignal");
 var cliErrorCodeValues = new Set(CLI_ERROR_CODES);
 var retryHintValues = new Set(RETRY_HINTS);
+var TELEMETRY_COMMAND_ARG_PREFIX = "uip.cmd.arg.";
 function extractCommandParams(cmd) {
   const params = {};
+  const add2 = (name, value) => {
+    if (name && value !== undefined) {
+      params[`${TELEMETRY_COMMAND_ARG_PREFIX}${name}`] = value;
+    }
+  };
   const registered = cmd.registeredArguments ?? [];
   const processed = cmd.processedArgs ?? [];
   for (let i = 0;i < registered.length; i++) {
-    const value = processed[i];
-    if (value === undefined) {
-      continue;
-    }
-    const name = registered[i].name();
-    if (name) {
-      params[name] = value;
-    }
+    add2(registered[i].name(), processed[i]);
   }
   for (const [key, value] of Object.entries(cmd.opts())) {
-    if (value !== undefined) {
-      params[key] = value;
-    }
+    add2(key, value);
   }
   return params;
 }
@@ -9455,11 +9934,12 @@ Command.prototype.trackedAction = function(context, fn, properties) {
   return this.action(async (...args) => {
     const telemetryName = deriveCommandPath(command);
     const props = typeof properties === "function" ? properties(...args) : properties;
+    const requestContext = telemetry.createRequestContext();
     const startTime = performance.now();
     let errorMessage;
     let fallbackExitCode = EXIT_CODES.Success;
     clearRecordedCommandFailureTelemetry();
-    const [error] = await catchError(fn(...args));
+    const [error] = await catchError(telemetry.runWithContext(requestContext, () => fn(...args)));
     if (error) {
       errorMessage = error instanceof Error ? error.message : String(error);
       logger.debug(`[trackedAction] ${telemetryName} failed: ${errorMessage}`);
@@ -9495,16 +9975,21 @@ Command.prototype.trackedAction = function(context, fn, properties) {
       recordedFailure,
       pollSignal: context.pollSignal
     });
-    telemetry.trackEvent(telemetryName, redactProperties({
-      ...extractCommandParams(command),
+    const commandParams = extractCommandParams(command);
+    if (props) {
+      for (const key of Object.keys(props)) {
+        delete commandParams[`${TELEMETRY_COMMAND_ARG_PREFIX}${key}`];
+      }
+    }
+    const baseProperties = redactProperties({
+      ...commandParams,
       ...props,
       ...buildCommandTelemetryAttribution(telemetryName, process.env.UIPATH_SKILL),
       command: "true",
-      duration: String(durationMs),
-      success: String(success),
       ...terminalTelemetry,
       ...errorMessage ? { errorMessage } : {}
-    }));
+    });
+    telemetry.trackRequestResult(telemetryName, durationMs, success, baseProperties, requestContext);
   });
 };
 // ../common/src/console-guard.ts
@@ -9514,6 +9999,7 @@ var savedOriginalsSlot = singleton("ConsoleGuardOriginals");
 var DEFAULT_AUTH_TIMEOUT_MS = 5 * 60 * 1000;
 // ../common/src/interactivity-context.ts
 var modeSlot = singleton("InteractivityMode");
+var interactiveFlagSlot = singleton("InteractiveFlag");
 // ../common/src/polling/types.ts
 var PollOutcome = {
   Completed: "completed",
@@ -9638,4 +10124,4 @@ export {
   SolutionInitError
 };
 
-//# debugId=5002F814CEA5C34E64756E2164756E21
+//# debugId=B4DE82653D2B978664756E2164756E21