@storm-software/tsdown 0.45.15 → 0.45.18

package/bin/tsdown.cjs

@@ -102653,9 +102653,9 @@ var require_prettier = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/@nx+devkit@21.5.2_nx@21.5.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_c4b3329f377a274c25d9c6b2b666ae22/node_modules/@nx/devkit/src/generators/format-files.js
+// ../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/src/generators/format-files.js
 var require_format_files = __commonJS({
-  "../../node_modules/.pnpm/@nx+devkit@21.5.2_nx@21.5.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_c4b3329f377a274c25d9c6b2b666ae22/node_modules/@nx/devkit/src/generators/format-files.js"(exports2) {
+  "../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/src/generators/format-files.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.formatFiles = formatFiles;
@@ -102671,7 +102671,7 @@ var require_format_files = __commonJS({
         }
       } catch {
       }
-      options8.sortRootTsconfigPaths ??= process.env.NX_FORMAT_SORT_TSCONFIG_PATHS !== "false";
+      options8.sortRootTsconfigPaths ??= process.env.NX_FORMAT_SORT_TSCONFIG_PATHS === "true";
       if (options8.sortRootTsconfigPaths) {
         sortTsConfig(tree);
       }
@@ -102749,9 +102749,9 @@ var require_format_files = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/@nx+devkit@21.5.2_nx@21.5.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_c4b3329f377a274c25d9c6b2b666ae22/node_modules/@nx/devkit/src/utils/binary-extensions.js
+// ../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/src/utils/binary-extensions.js
 var require_binary_extensions = __commonJS({
-  "../../node_modules/.pnpm/@nx+devkit@21.5.2_nx@21.5.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_c4b3329f377a274c25d9c6b2b666ae22/node_modules/@nx/devkit/src/utils/binary-extensions.js"(exports2) {
+  "../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/src/utils/binary-extensions.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.isBinaryPath = isBinaryPath;
@@ -103766,9 +103766,9 @@ var require_ejs = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/@nx+devkit@21.5.2_nx@21.5.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_c4b3329f377a274c25d9c6b2b666ae22/node_modules/@nx/devkit/src/generators/generate-files.js
+// ../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/src/generators/generate-files.js
 var require_generate_files = __commonJS({
-  "../../node_modules/.pnpm/@nx+devkit@21.5.2_nx@21.5.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_c4b3329f377a274c25d9c6b2b666ae22/node_modules/@nx/devkit/src/generators/generate-files.js"(exports2) {
+  "../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/src/generators/generate-files.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.OverwriteStrategy = void 0;
@@ -103853,9 +103853,9 @@ var require_generate_files = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/@nx+devkit@21.5.2_nx@21.5.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_c4b3329f377a274c25d9c6b2b666ae22/node_modules/@nx/devkit/src/utils/versions.js
+// ../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/src/utils/versions.js
 var require_versions = __commonJS({
-  "../../node_modules/.pnpm/@nx+devkit@21.5.2_nx@21.5.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_c4b3329f377a274c25d9c6b2b666ae22/node_modules/@nx/devkit/src/utils/versions.js"(exports2) {
+  "../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/src/utils/versions.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.typescriptVersion = void 0;
@@ -105793,9 +105793,9 @@ var require_semver3 = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/@nx+devkit@21.5.2_nx@21.5.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_c4b3329f377a274c25d9c6b2b666ae22/node_modules/@nx/devkit/src/tasks/install-packages-task.js
+// ../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/src/tasks/install-packages-task.js
 var require_install_packages_task = __commonJS({
-  "../../node_modules/.pnpm/@nx+devkit@21.5.2_nx@21.5.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_c4b3329f377a274c25d9c6b2b666ae22/node_modules/@nx/devkit/src/tasks/install-packages-task.js"(exports2) {
+  "../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/src/tasks/install-packages-task.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.installPackagesTask = installPackagesTask;
@@ -105825,382 +105825,3101 @@ var require_install_packages_task = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/tmp@0.2.5/node_modules/tmp/lib/tmp.js
-var require_tmp = __commonJS({
-  "../../node_modules/.pnpm/tmp@0.2.5/node_modules/tmp/lib/tmp.js"(exports2, module2) {
-    var fs8 = require("fs");
-    var os8 = require("os");
-    var path14 = require("path");
-    var crypto = require("crypto");
-    var _c3 = { fs: fs8.constants, os: os8.constants };
-    var RANDOM_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-    var TEMPLATE_PATTERN = /XXXXXX/;
-    var DEFAULT_TRIES = 3;
-    var CREATE_FLAGS = (_c3.O_CREAT || _c3.fs.O_CREAT) | (_c3.O_EXCL || _c3.fs.O_EXCL) | (_c3.O_RDWR || _c3.fs.O_RDWR);
-    var IS_WIN32 = os8.platform() === "win32";
-    var EBADF = _c3.EBADF || _c3.os.errno.EBADF;
-    var ENOENT = _c3.ENOENT || _c3.os.errno.ENOENT;
-    var DIR_MODE = 448;
-    var FILE_MODE = 384;
-    var EXIT = "exit";
-    var _removeObjects = [];
-    var FN_RMDIR_SYNC = fs8.rmdirSync.bind(fs8);
-    var _gracefulCleanup = false;
-    function rimraf(dirPath, callback) {
-      return fs8.rm(dirPath, { recursive: true }, callback);
-    }
-    function FN_RIMRAF_SYNC(dirPath) {
-      return fs8.rmSync(dirPath, { recursive: true });
-    }
-    function tmpName(options8, callback) {
-      const args = _parseArguments(options8, callback), opts = args[0], cb2 = args[1];
-      _assertAndSanitizeOptions(opts, function(err, sanitizedOptions) {
-        if (err) return cb2(err);
-        let tries = sanitizedOptions.tries;
-        (function _getUniqueName() {
-          try {
-            const name = _generateTmpName(sanitizedOptions);
-            fs8.stat(name, function(err2) {
-              if (!err2) {
-                if (tries-- > 0) return _getUniqueName();
-                return cb2(new Error("Could not get a unique tmp filename, max tries reached " + name));
+// ../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/common.js
+var require_common3 = __commonJS({
+  "../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/common.js"(exports2, module2) {
+    "use strict";
+    function isNothing(subject) {
+      return typeof subject === "undefined" || subject === null;
+    }
+    function isObject2(subject) {
+      return typeof subject === "object" && subject !== null;
+    }
+    function toArray(sequence) {
+      if (Array.isArray(sequence)) return sequence;
+      else if (isNothing(sequence)) return [];
+      return [sequence];
+    }
+    function extend(target, source2) {
+      var index, length, key2, sourceKeys;
+      if (source2) {
+        sourceKeys = Object.keys(source2);
+        for (index = 0, length = sourceKeys.length; index < length; index += 1) {
+          key2 = sourceKeys[index];
+          target[key2] = source2[key2];
+        }
+      }
+      return target;
+    }
+    function repeat2(string, count) {
+      var result = "", cycle;
+      for (cycle = 0; cycle < count; cycle += 1) {
+        result += string;
+      }
+      return result;
+    }
+    function isNegativeZero(number) {
+      return number === 0 && Number.NEGATIVE_INFINITY === 1 / number;
+    }
+    module2.exports.isNothing = isNothing;
+    module2.exports.isObject = isObject2;
+    module2.exports.toArray = toArray;
+    module2.exports.repeat = repeat2;
+    module2.exports.isNegativeZero = isNegativeZero;
+    module2.exports.extend = extend;
+  }
+});
+
+// ../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/exception.js
+var require_exception = __commonJS({
+  "../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/exception.js"(exports2, module2) {
+    "use strict";
+    function formatError(exception, compact) {
+      var where = "", message = exception.reason || "(unknown reason)";
+      if (!exception.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) {
+        where += "\n\n" + exception.mark.snippet;
+      }
+      return message + " " + where;
+    }
+    function YAMLException(reason, mark) {
+      Error.call(this);
+      this.name = "YAMLException";
+      this.reason = reason;
+      this.mark = mark;
+      this.message = formatError(this, false);
+      if (Error.captureStackTrace) {
+        Error.captureStackTrace(this, this.constructor);
+      } else {
+        this.stack = new Error().stack || "";
+      }
+    }
+    YAMLException.prototype = Object.create(Error.prototype);
+    YAMLException.prototype.constructor = YAMLException;
+    YAMLException.prototype.toString = function toString(compact) {
+      return this.name + ": " + formatError(this, compact);
+    };
+    module2.exports = YAMLException;
+  }
+});
+
+// ../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/snippet.js
+var require_snippet = __commonJS({
+  "../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/snippet.js"(exports2, module2) {
+    "use strict";
+    var common = require_common3();
+    function getLine(buffer2, lineStart, lineEnd, position, maxLineLength) {
+      var head = "";
+      var tail = "";
+      var maxHalfLength = Math.floor(maxLineLength / 2) - 1;
+      if (position - lineStart > maxHalfLength) {
+        head = " ... ";
+        lineStart = position - maxHalfLength + head.length;
+      }
+      if (lineEnd - position > maxHalfLength) {
+        tail = " ...";
+        lineEnd = position + maxHalfLength - tail.length;
+      }
+      return {
+        str: head + buffer2.slice(lineStart, lineEnd).replace(/\t/g, "\u2192") + tail,
+        pos: position - lineStart + head.length
+        // relative position
+      };
+    }
+    function padStart(string, max) {
+      return common.repeat(" ", max - string.length) + string;
+    }
+    function makeSnippet(mark, options8) {
+      options8 = Object.create(options8 || null);
+      if (!mark.buffer) return null;
+      if (!options8.maxLength) options8.maxLength = 79;
+      if (typeof options8.indent !== "number") options8.indent = 1;
+      if (typeof options8.linesBefore !== "number") options8.linesBefore = 3;
+      if (typeof options8.linesAfter !== "number") options8.linesAfter = 2;
+      var re10 = /\r?\n|\r|\0/g;
+      var lineStarts = [0];
+      var lineEnds = [];
+      var match;
+      var foundLineNo = -1;
+      while (match = re10.exec(mark.buffer)) {
+        lineEnds.push(match.index);
+        lineStarts.push(match.index + match[0].length);
+        if (mark.position <= match.index && foundLineNo < 0) {
+          foundLineNo = lineStarts.length - 2;
+        }
+      }
+      if (foundLineNo < 0) foundLineNo = lineStarts.length - 1;
+      var result = "", i, line3;
+      var lineNoLength = Math.min(mark.line + options8.linesAfter, lineEnds.length).toString().length;
+      var maxLineLength = options8.maxLength - (options8.indent + lineNoLength + 3);
+      for (i = 1; i <= options8.linesBefore; i++) {
+        if (foundLineNo - i < 0) break;
+        line3 = getLine(
+          mark.buffer,
+          lineStarts[foundLineNo - i],
+          lineEnds[foundLineNo - i],
+          mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo - i]),
+          maxLineLength
+        );
+        result = common.repeat(" ", options8.indent) + padStart((mark.line - i + 1).toString(), lineNoLength) + " | " + line3.str + "\n" + result;
+      }
+      line3 = getLine(mark.buffer, lineStarts[foundLineNo], lineEnds[foundLineNo], mark.position, maxLineLength);
+      result += common.repeat(" ", options8.indent) + padStart((mark.line + 1).toString(), lineNoLength) + " | " + line3.str + "\n";
+      result += common.repeat("-", options8.indent + lineNoLength + 3 + line3.pos) + "^\n";
+      for (i = 1; i <= options8.linesAfter; i++) {
+        if (foundLineNo + i >= lineEnds.length) break;
+        line3 = getLine(
+          mark.buffer,
+          lineStarts[foundLineNo + i],
+          lineEnds[foundLineNo + i],
+          mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo + i]),
+          maxLineLength
+        );
+        result += common.repeat(" ", options8.indent) + padStart((mark.line + i + 1).toString(), lineNoLength) + " | " + line3.str + "\n";
+      }
+      return result.replace(/\n$/, "");
+    }
+    module2.exports = makeSnippet;
+  }
+});
+
+// ../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/type.js
+var require_type = __commonJS({
+  "../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/type.js"(exports2, module2) {
+    "use strict";
+    var YAMLException = require_exception();
+    var TYPE_CONSTRUCTOR_OPTIONS = [
+      "kind",
+      "multi",
+      "resolve",
+      "construct",
+      "instanceOf",
+      "predicate",
+      "represent",
+      "representName",
+      "defaultStyle",
+      "styleAliases"
+    ];
+    var YAML_NODE_KINDS = [
+      "scalar",
+      "sequence",
+      "mapping"
+    ];
+    function compileStyleAliases(map) {
+      var result = {};
+      if (map !== null) {
+        Object.keys(map).forEach(function(style) {
+          map[style].forEach(function(alias) {
+            result[String(alias)] = style;
+          });
+        });
+      }
+      return result;
+    }
+    function Type(tag, options8) {
+      options8 = options8 || {};
+      Object.keys(options8).forEach(function(name) {
+        if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) {
+          throw new YAMLException('Unknown option "' + name + '" is met in definition of "' + tag + '" YAML type.');
+        }
+      });
+      this.tag = tag;
+      this.kind = options8["kind"] || null;
+      this.resolve = options8["resolve"] || function() {
+        return true;
+      };
+      this.construct = options8["construct"] || function(data) {
+        return data;
+      };
+      this.instanceOf = options8["instanceOf"] || null;
+      this.predicate = options8["predicate"] || null;
+      this.represent = options8["represent"] || null;
+      this.representName = options8["representName"] || null;
+      this.defaultStyle = options8["defaultStyle"] || null;
+      this.multi = options8["multi"] || false;
+      this.styleAliases = compileStyleAliases(options8["styleAliases"] || null);
+      if (YAML_NODE_KINDS.indexOf(this.kind) === -1) {
+        throw new YAMLException('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.');
+      }
+    }
+    module2.exports = Type;
+  }
+});
+
+// ../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/schema.js
+var require_schema = __commonJS({
+  "../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/schema.js"(exports2, module2) {
+    "use strict";
+    var YAMLException = require_exception();
+    var Type = require_type();
+    function compileList(schema, name, result) {
+      var exclude = [];
+      schema[name].forEach(function(currentType) {
+        result.forEach(function(previousType, previousIndex) {
+          if (previousType.tag === currentType.tag && previousType.kind === currentType.kind && previousType.multi === currentType.multi) {
+            exclude.push(previousIndex);
+          }
+        });
+        result.push(currentType);
+      });
+      return result.filter(function(type, index) {
+        return exclude.indexOf(index) === -1;
+      });
+    }
+    function compileMap() {
+      var result = {
+        scalar: {},
+        sequence: {},
+        mapping: {},
+        fallback: {},
+        multi: {
+          scalar: [],
+          sequence: [],
+          mapping: [],
+          fallback: []
+        }
+      }, index, length;
+      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 (index = 0, length = arguments.length; index < length; index += 1) {
+        arguments[index].forEach(collectType);
+      }
+      return result;
+    }
+    function Schema2(definition) {
+      return this.extend(definition);
+    }
+    Schema2.prototype.extend = function extend(definition) {
+      var implicit = [];
+      var explicit = [];
+      if (definition instanceof Type) {
+        explicit.push(definition);
+      } else if (Array.isArray(definition)) {
+        explicit = explicit.concat(definition);
+      } 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.");
+        }
+      });
+      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.");
+        }
+      });
+      var result = Object.create(Schema2.prototype);
+      result.implicit = (this.implicit || []).concat(implicit);
+      result.explicit = (this.explicit || []).concat(explicit);
+      result.compiledImplicit = compileList(result, "implicit", []);
+      result.compiledExplicit = compileList(result, "explicit", []);
+      result.compiledTypeMap = compileMap(result.compiledImplicit, result.compiledExplicit);
+      return result;
+    };
+    module2.exports = Schema2;
+  }
+});
+
+// ../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/type/str.js
+var require_str = __commonJS({
+  "../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/type/str.js"(exports2, module2) {
+    "use strict";
+    var Type = require_type();
+    module2.exports = new Type("tag:yaml.org,2002:str", {
+      kind: "scalar",
+      construct: function(data) {
+        return data !== null ? data : "";
+      }
+    });
+  }
+});
+
+// ../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/type/seq.js
+var require_seq = __commonJS({
+  "../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/type/seq.js"(exports2, module2) {
+    "use strict";
+    var Type = require_type();
+    module2.exports = new Type("tag:yaml.org,2002:seq", {
+      kind: "sequence",
+      construct: function(data) {
+        return data !== null ? data : [];
+      }
+    });
+  }
+});
+
+// ../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/type/map.js
+var require_map2 = __commonJS({
+  "../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/type/map.js"(exports2, module2) {
+    "use strict";
+    var Type = require_type();
+    module2.exports = new Type("tag:yaml.org,2002:map", {
+      kind: "mapping",
+      construct: function(data) {
+        return data !== null ? data : {};
+      }
+    });
+  }
+});
+
+// ../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/schema/failsafe.js
+var require_failsafe = __commonJS({
+  "../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/schema/failsafe.js"(exports2, module2) {
+    "use strict";
+    var Schema2 = require_schema();
+    module2.exports = new Schema2({
+      explicit: [
+        require_str(),
+        require_seq(),
+        require_map2()
+      ]
+    });
+  }
+});
+
+// ../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/type/null.js
+var require_null = __commonJS({
+  "../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/type/null.js"(exports2, module2) {
+    "use strict";
+    var Type = require_type();
+    function resolveYamlNull(data) {
+      if (data === null) return true;
+      var max = data.length;
+      return max === 1 && data === "~" || max === 4 && (data === "null" || data === "Null" || data === "NULL");
+    }
+    function constructYamlNull() {
+      return null;
+    }
+    function isNull(object) {
+      return object === null;
+    }
+    module2.exports = new Type("tag:yaml.org,2002:null", {
+      kind: "scalar",
+      resolve: resolveYamlNull,
+      construct: constructYamlNull,
+      predicate: isNull,
+      represent: {
+        canonical: function() {
+          return "~";
+        },
+        lowercase: function() {
+          return "null";
+        },
+        uppercase: function() {
+          return "NULL";
+        },
+        camelcase: function() {
+          return "Null";
+        },
+        empty: function() {
+          return "";
+        }
+      },
+      defaultStyle: "lowercase"
+    });
+  }
+});
+
+// ../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/type/bool.js
+var require_bool = __commonJS({
+  "../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/type/bool.js"(exports2, module2) {
+    "use strict";
+    var Type = require_type();
+    function resolveYamlBoolean(data) {
+      if (data === null) return false;
+      var max = data.length;
+      return max === 4 && (data === "true" || data === "True" || data === "TRUE") || max === 5 && (data === "false" || data === "False" || data === "FALSE");
+    }
+    function constructYamlBoolean(data) {
+      return data === "true" || data === "True" || data === "TRUE";
+    }
+    function isBoolean(object) {
+      return Object.prototype.toString.call(object) === "[object Boolean]";
+    }
+    module2.exports = new Type("tag:yaml.org,2002:bool", {
+      kind: "scalar",
+      resolve: resolveYamlBoolean,
+      construct: constructYamlBoolean,
+      predicate: isBoolean,
+      represent: {
+        lowercase: function(object) {
+          return object ? "true" : "false";
+        },
+        uppercase: function(object) {
+          return object ? "TRUE" : "FALSE";
+        },
+        camelcase: function(object) {
+          return object ? "True" : "False";
+        }
+      },
+      defaultStyle: "lowercase"
+    });
+  }
+});
+
+// ../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/type/int.js
+var require_int = __commonJS({
+  "../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/type/int.js"(exports2, module2) {
+    "use strict";
+    var common = require_common3();
+    var Type = require_type();
+    function isHexCode(c5) {
+      return 48 <= c5 && c5 <= 57 || 65 <= c5 && c5 <= 70 || 97 <= c5 && c5 <= 102;
+    }
+    function isOctCode(c5) {
+      return 48 <= c5 && c5 <= 55;
+    }
+    function isDecCode(c5) {
+      return 48 <= c5 && c5 <= 57;
+    }
+    function resolveYamlInteger(data) {
+      if (data === null) return false;
+      var max = data.length, index = 0, hasDigits = false, ch2;
+      if (!max) return false;
+      ch2 = data[index];
+      if (ch2 === "-" || ch2 === "+") {
+        ch2 = data[++index];
+      }
+      if (ch2 === "0") {
+        if (index + 1 === max) return true;
+        ch2 = data[++index];
+        if (ch2 === "b") {
+          index++;
+          for (; index < max; index++) {
+            ch2 = data[index];
+            if (ch2 === "_") continue;
+            if (ch2 !== "0" && ch2 !== "1") return false;
+            hasDigits = true;
+          }
+          return hasDigits && ch2 !== "_";
+        }
+        if (ch2 === "x") {
+          index++;
+          for (; index < max; index++) {
+            ch2 = data[index];
+            if (ch2 === "_") continue;
+            if (!isHexCode(data.charCodeAt(index))) return false;
+            hasDigits = true;
+          }
+          return hasDigits && ch2 !== "_";
+        }
+        if (ch2 === "o") {
+          index++;
+          for (; index < max; index++) {
+            ch2 = data[index];
+            if (ch2 === "_") continue;
+            if (!isOctCode(data.charCodeAt(index))) return false;
+            hasDigits = true;
+          }
+          return hasDigits && ch2 !== "_";
+        }
+      }
+      if (ch2 === "_") return false;
+      for (; index < max; index++) {
+        ch2 = data[index];
+        if (ch2 === "_") continue;
+        if (!isDecCode(data.charCodeAt(index))) {
+          return false;
+        }
+        hasDigits = true;
+      }
+      if (!hasDigits || ch2 === "_") return false;
+      return true;
+    }
+    function constructYamlInteger(data) {
+      var value = data, sign2 = 1, ch2;
+      if (value.indexOf("_") !== -1) {
+        value = value.replace(/_/g, "");
+      }
+      ch2 = value[0];
+      if (ch2 === "-" || ch2 === "+") {
+        if (ch2 === "-") sign2 = -1;
+        value = value.slice(1);
+        ch2 = value[0];
+      }
+      if (value === "0") return 0;
+      if (ch2 === "0") {
+        if (value[1] === "b") return sign2 * parseInt(value.slice(2), 2);
+        if (value[1] === "x") return sign2 * parseInt(value.slice(2), 16);
+        if (value[1] === "o") return sign2 * parseInt(value.slice(2), 8);
+      }
+      return sign2 * parseInt(value, 10);
+    }
+    function isInteger(object) {
+      return Object.prototype.toString.call(object) === "[object Number]" && (object % 1 === 0 && !common.isNegativeZero(object));
+    }
+    module2.exports = new Type("tag:yaml.org,2002:int", {
+      kind: "scalar",
+      resolve: resolveYamlInteger,
+      construct: constructYamlInteger,
+      predicate: isInteger,
+      represent: {
+        binary: function(obj) {
+          return obj >= 0 ? "0b" + obj.toString(2) : "-0b" + obj.toString(2).slice(1);
+        },
+        octal: function(obj) {
+          return obj >= 0 ? "0o" + obj.toString(8) : "-0o" + obj.toString(8).slice(1);
+        },
+        decimal: function(obj) {
+          return obj.toString(10);
+        },
+        /* eslint-disable max-len */
+        hexadecimal: function(obj) {
+          return obj >= 0 ? "0x" + obj.toString(16).toUpperCase() : "-0x" + obj.toString(16).toUpperCase().slice(1);
+        }
+      },
+      defaultStyle: "decimal",
+      styleAliases: {
+        binary: [2, "bin"],
+        octal: [8, "oct"],
+        decimal: [10, "dec"],
+        hexadecimal: [16, "hex"]
+      }
+    });
+  }
+});
+
+// ../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/type/float.js
+var require_float = __commonJS({
+  "../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/type/float.js"(exports2, module2) {
+    "use strict";
+    var common = require_common3();
+    var Type = require_type();
+    var YAML_FLOAT_PATTERN = new RegExp(
+      // 2.5e4, 2.5 and integers
+      "^(?:[-+]?(?:[0-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?|\\.[0-9_]+(?:[eE][-+]?[0-9]+)?|[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$"
+    );
+    function resolveYamlFloat(data) {
+      if (data === null) return false;
+      if (!YAML_FLOAT_PATTERN.test(data) || // Quick hack to not allow integers end with `_`
+      // Probably should update regexp & check speed
+      data[data.length - 1] === "_") {
+        return false;
+      }
+      return true;
+    }
+    function constructYamlFloat(data) {
+      var value, sign2;
+      value = data.replace(/_/g, "").toLowerCase();
+      sign2 = value[0] === "-" ? -1 : 1;
+      if ("+-".indexOf(value[0]) >= 0) {
+        value = value.slice(1);
+      }
+      if (value === ".inf") {
+        return sign2 === 1 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
+      } else if (value === ".nan") {
+        return NaN;
+      }
+      return sign2 * parseFloat(value, 10);
+    }
+    var SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/;
+    function representYamlFloat(object, style) {
+      var res;
+      if (isNaN(object)) {
+        switch (style) {
+          case "lowercase":
+            return ".nan";
+          case "uppercase":
+            return ".NAN";
+          case "camelcase":
+            return ".NaN";
+        }
+      } else if (Number.POSITIVE_INFINITY === object) {
+        switch (style) {
+          case "lowercase":
+            return ".inf";
+          case "uppercase":
+            return ".INF";
+          case "camelcase":
+            return ".Inf";
+        }
+      } else if (Number.NEGATIVE_INFINITY === object) {
+        switch (style) {
+          case "lowercase":
+            return "-.inf";
+          case "uppercase":
+            return "-.INF";
+          case "camelcase":
+            return "-.Inf";
+        }
+      } else if (common.isNegativeZero(object)) {
+        return "-0.0";
+      }
+      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));
+    }
+    module2.exports = new Type("tag:yaml.org,2002:float", {
+      kind: "scalar",
+      resolve: resolveYamlFloat,
+      construct: constructYamlFloat,
+      predicate: isFloat,
+      represent: representYamlFloat,
+      defaultStyle: "lowercase"
+    });
+  }
+});
+
+// ../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/schema/json.js
+var require_json = __commonJS({
+  "../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/schema/json.js"(exports2, module2) {
+    "use strict";
+    module2.exports = require_failsafe().extend({
+      implicit: [
+        require_null(),
+        require_bool(),
+        require_int(),
+        require_float()
+      ]
+    });
+  }
+});
+
+// ../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/schema/core.js
+var require_core = __commonJS({
+  "../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/schema/core.js"(exports2, module2) {
+    "use strict";
+    module2.exports = require_json();
+  }
+});
+
+// ../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/type/timestamp.js
+var require_timestamp = __commonJS({
+  "../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/type/timestamp.js"(exports2, module2) {
+    "use strict";
+    var Type = require_type();
+    var YAML_DATE_REGEXP = new RegExp(
+      "^([0-9][0-9][0-9][0-9])-([0-9][0-9])-([0-9][0-9])$"
+    );
+    var 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;
+      if (YAML_DATE_REGEXP.exec(data) !== null) return true;
+      if (YAML_TIMESTAMP_REGEXP.exec(data) !== null) return true;
+      return false;
+    }
+    function constructYamlTimestamp(data) {
+      var match, year, month, day, hour, minute, second, fraction = 0, delta = null, tz_hour, tz_minute, date;
+      match = YAML_DATE_REGEXP.exec(data);
+      if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(data);
+      if (match === null) throw new Error("Date resolve error");
+      year = +match[1];
+      month = +match[2] - 1;
+      day = +match[3];
+      if (!match[4]) {
+        return new Date(Date.UTC(year, month, day));
+      }
+      hour = +match[4];
+      minute = +match[5];
+      second = +match[6];
+      if (match[7]) {
+        fraction = match[7].slice(0, 3);
+        while (fraction.length < 3) {
+          fraction += "0";
+        }
+        fraction = +fraction;
+      }
+      if (match[9]) {
+        tz_hour = +match[10];
+        tz_minute = +(match[11] || 0);
+        delta = (tz_hour * 60 + tz_minute) * 6e4;
+        if (match[9] === "-") delta = -delta;
+      }
+      date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));
+      if (delta) date.setTime(date.getTime() - delta);
+      return date;
+    }
+    function representYamlTimestamp(object) {
+      return object.toISOString();
+    }
+    module2.exports = new Type("tag:yaml.org,2002:timestamp", {
+      kind: "scalar",
+      resolve: resolveYamlTimestamp,
+      construct: constructYamlTimestamp,
+      instanceOf: Date,
+      represent: representYamlTimestamp
+    });
+  }
+});
+
+// ../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/type/merge.js
+var require_merge = __commonJS({
+  "../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/type/merge.js"(exports2, module2) {
+    "use strict";
+    var Type = require_type();
+    function resolveYamlMerge(data) {
+      return data === "<<" || data === null;
+    }
+    module2.exports = new Type("tag:yaml.org,2002:merge", {
+      kind: "scalar",
+      resolve: resolveYamlMerge
+    });
+  }
+});
+
+// ../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/type/binary.js
+var require_binary = __commonJS({
+  "../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/type/binary.js"(exports2, module2) {
+    "use strict";
+    var Type = require_type();
+    var BASE64_MAP = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r";
+    function resolveYamlBinary(data) {
+      if (data === null) return false;
+      var code, idx, bitlen = 0, max = data.length, map = BASE64_MAP;
+      for (idx = 0; idx < max; idx++) {
+        code = map.indexOf(data.charAt(idx));
+        if (code > 64) continue;
+        if (code < 0) return false;
+        bitlen += 6;
+      }
+      return bitlen % 8 === 0;
+    }
+    function constructYamlBinary(data) {
+      var idx, tailbits, input = data.replace(/[\r\n=]/g, ""), max = input.length, map = BASE64_MAP, bits = 0, result = [];
+      for (idx = 0; idx < max; idx++) {
+        if (idx % 4 === 0 && idx) {
+          result.push(bits >> 16 & 255);
+          result.push(bits >> 8 & 255);
+          result.push(bits & 255);
+        }
+        bits = bits << 6 | map.indexOf(input.charAt(idx));
+      }
+      tailbits = max % 4 * 6;
+      if (tailbits === 0) {
+        result.push(bits >> 16 & 255);
+        result.push(bits >> 8 & 255);
+        result.push(bits & 255);
+      } else if (tailbits === 18) {
+        result.push(bits >> 10 & 255);
+        result.push(bits >> 2 & 255);
+      } else if (tailbits === 12) {
+        result.push(bits >> 4 & 255);
+      }
+      return new Uint8Array(result);
+    }
+    function representYamlBinary(object) {
+      var result = "", bits = 0, idx, tail, max = object.length, map = BASE64_MAP;
+      for (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];
+        }
+        bits = (bits << 8) + object[idx];
+      }
+      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];
+      } else if (tail === 2) {
+        result += map[bits >> 10 & 63];
+        result += map[bits >> 4 & 63];
+        result += map[bits << 2 & 63];
+        result += map[64];
+      } else if (tail === 1) {
+        result += map[bits >> 2 & 63];
+        result += map[bits << 4 & 63];
+        result += map[64];
+        result += map[64];
+      }
+      return result;
+    }
+    function isBinary(obj) {
+      return Object.prototype.toString.call(obj) === "[object Uint8Array]";
+    }
+    module2.exports = new Type("tag:yaml.org,2002:binary", {
+      kind: "scalar",
+      resolve: resolveYamlBinary,
+      construct: constructYamlBinary,
+      predicate: isBinary,
+      represent: representYamlBinary
+    });
+  }
+});
+
+// ../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/type/omap.js
+var require_omap = __commonJS({
+  "../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/type/omap.js"(exports2, module2) {
+    "use strict";
+    var Type = require_type();
+    var _hasOwnProperty = Object.prototype.hasOwnProperty;
+    var _toString = Object.prototype.toString;
+    function resolveYamlOmap(data) {
+      if (data === null) return true;
+      var objectKeys = [], index, length, pair, pairKey, pairHasKey, object = data;
+      for (index = 0, length = object.length; index < length; index += 1) {
+        pair = object[index];
+        pairHasKey = false;
+        if (_toString.call(pair) !== "[object Object]") return false;
+        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) objectKeys.push(pairKey);
+        else return false;
+      }
+      return true;
+    }
+    function constructYamlOmap(data) {
+      return data !== null ? data : [];
+    }
+    module2.exports = new Type("tag:yaml.org,2002:omap", {
+      kind: "sequence",
+      resolve: resolveYamlOmap,
+      construct: constructYamlOmap
+    });
+  }
+});
+
+// ../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/type/pairs.js
+var require_pairs = __commonJS({
+  "../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/type/pairs.js"(exports2, module2) {
+    "use strict";
+    var Type = require_type();
+    var _toString = Object.prototype.toString;
+    function resolveYamlPairs(data) {
+      if (data === null) return true;
+      var index, length, pair, keys, result, object = data;
+      result = new Array(object.length);
+      for (index = 0, length = object.length; index < length; index += 1) {
+        pair = object[index];
+        if (_toString.call(pair) !== "[object Object]") return false;
+        keys = Object.keys(pair);
+        if (keys.length !== 1) return false;
+        result[index] = [keys[0], pair[keys[0]]];
+      }
+      return true;
+    }
+    function constructYamlPairs(data) {
+      if (data === null) return [];
+      var index, length, pair, keys, result, object = data;
+      result = new Array(object.length);
+      for (index = 0, length = object.length; index < length; index += 1) {
+        pair = object[index];
+        keys = Object.keys(pair);
+        result[index] = [keys[0], pair[keys[0]]];
+      }
+      return result;
+    }
+    module2.exports = new Type("tag:yaml.org,2002:pairs", {
+      kind: "sequence",
+      resolve: resolveYamlPairs,
+      construct: constructYamlPairs
+    });
+  }
+});
+
+// ../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/type/set.js
+var require_set = __commonJS({
+  "../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/type/set.js"(exports2, module2) {
+    "use strict";
+    var Type = require_type();
+    var _hasOwnProperty = Object.prototype.hasOwnProperty;
+    function resolveYamlSet(data) {
+      if (data === null) return true;
+      var key2, object = data;
+      for (key2 in object) {
+        if (_hasOwnProperty.call(object, key2)) {
+          if (object[key2] !== null) return false;
+        }
+      }
+      return true;
+    }
+    function constructYamlSet(data) {
+      return data !== null ? data : {};
+    }
+    module2.exports = new Type("tag:yaml.org,2002:set", {
+      kind: "mapping",
+      resolve: resolveYamlSet,
+      construct: constructYamlSet
+    });
+  }
+});
+
+// ../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/schema/default.js
+var require_default = __commonJS({
+  "../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/schema/default.js"(exports2, module2) {
+    "use strict";
+    module2.exports = require_core().extend({
+      implicit: [
+        require_timestamp(),
+        require_merge()
+      ],
+      explicit: [
+        require_binary(),
+        require_omap(),
+        require_pairs(),
+        require_set()
+      ]
+    });
+  }
+});
+
+// ../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/loader.js
+var require_loader = __commonJS({
+  "../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/loader.js"(exports2, module2) {
+    "use strict";
+    var common = require_common3();
+    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 = /^(?:!|!!|![a-z\-]+!)$/i;
+    var PATTERN_TAG_URI = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i;
+    function _class(obj) {
+      return Object.prototype.toString.call(obj);
+    }
+    function is_EOL(c5) {
+      return c5 === 10 || c5 === 13;
+    }
+    function is_WHITE_SPACE(c5) {
+      return c5 === 9 || c5 === 32;
+    }
+    function is_WS_OR_EOL(c5) {
+      return c5 === 9 || c5 === 32 || c5 === 10 || c5 === 13;
+    }
+    function is_FLOW_INDICATOR(c5) {
+      return c5 === 44 || c5 === 91 || c5 === 93 || c5 === 123 || c5 === 125;
+    }
+    function fromHexCode(c5) {
+      var lc3;
+      if (48 <= c5 && c5 <= 57) {
+        return c5 - 48;
+      }
+      lc3 = c5 | 32;
+      if (97 <= lc3 && lc3 <= 102) {
+        return lc3 - 97 + 10;
+      }
+      return -1;
+    }
+    function escapedHexLen(c5) {
+      if (c5 === 120) {
+        return 2;
+      }
+      if (c5 === 117) {
+        return 4;
+      }
+      if (c5 === 85) {
+        return 8;
+      }
+      return 0;
+    }
+    function fromDecimalCode(c5) {
+      if (48 <= c5 && c5 <= 57) {
+        return c5 - 48;
+      }
+      return -1;
+    }
+    function simpleEscapeSequence(c5) {
+      return c5 === 48 ? "\0" : c5 === 97 ? "\x07" : c5 === 98 ? "\b" : c5 === 116 ? "	" : c5 === 9 ? "	" : c5 === 110 ? "\n" : c5 === 118 ? "\v" : c5 === 102 ? "\f" : c5 === 114 ? "\r" : c5 === 101 ? "\x1B" : c5 === 32 ? " " : c5 === 34 ? '"' : c5 === 47 ? "/" : c5 === 92 ? "\\" : c5 === 78 ? "\x85" : c5 === 95 ? "\xA0" : c5 === 76 ? "\u2028" : c5 === 80 ? "\u2029" : "";
+    }
+    function charFromCodepoint(c5) {
+      if (c5 <= 65535) {
+        return String.fromCharCode(c5);
+      }
+      return String.fromCharCode(
+        (c5 - 65536 >> 10) + 55296,
+        (c5 - 65536 & 1023) + 56320
+      );
+    }
+    var simpleEscapeCheck = new Array(256);
+    var simpleEscapeMap = new Array(256);
+    for (i = 0; i < 256; i++) {
+      simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0;
+      simpleEscapeMap[i] = simpleEscapeSequence(i);
+    }
+    var i;
+    function State(input, options8) {
+      this.input = input;
+      this.filename = options8["filename"] || null;
+      this.schema = options8["schema"] || DEFAULT_SCHEMA;
+      this.onWarning = options8["onWarning"] || null;
+      this.legacy = options8["legacy"] || false;
+      this.json = options8["json"] || false;
+      this.listener = options8["listener"] || null;
+      this.implicitTypes = this.schema.compiledImplicit;
+      this.typeMap = this.schema.compiledTypeMap;
+      this.length = input.length;
+      this.position = 0;
+      this.line = 0;
+      this.lineStart = 0;
+      this.lineIndent = 0;
+      this.firstTabInLine = -1;
+      this.documents = [];
+    }
+    function generateError(state, message) {
+      var mark = {
+        name: state.filename,
+        buffer: state.input.slice(0, -1),
+        // omit trailing \0
+        position: state.position,
+        line: state.line,
+        column: state.position - state.lineStart
+      };
+      mark.snippet = makeSnippet(mark);
+      return new YAMLException(message, mark);
+    }
+    function throwError(state, message) {
+      throw generateError(state, message);
+    }
+    function throwWarning(state, message) {
+      if (state.onWarning) {
+        state.onWarning.call(null, generateError(state, message));
+      }
+    }
+    var directiveHandlers = {
+      YAML: function handleYamlDirective(state, name, args) {
+        var match, major, minor;
+        if (state.version !== null) {
+          throwError(state, "duplication of %YAML directive");
+        }
+        if (args.length !== 1) {
+          throwError(state, "YAML directive accepts exactly one argument");
+        }
+        match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]);
+        if (match === null) {
+          throwError(state, "ill-formed argument of the YAML directive");
+        }
+        major = parseInt(match[1], 10);
+        minor = parseInt(match[2], 10);
+        if (major !== 1) {
+          throwError(state, "unacceptable YAML version of the document");
+        }
+        state.version = args[0];
+        state.checkLineBreaks = minor < 2;
+        if (minor !== 1 && minor !== 2) {
+          throwWarning(state, "unsupported YAML version of the document");
+        }
+      },
+      TAG: function handleTagDirective(state, name, args) {
+        var handle, prefix;
+        if (args.length !== 2) {
+          throwError(state, "TAG directive accepts exactly two arguments");
+        }
+        handle = args[0];
+        prefix = args[1];
+        if (!PATTERN_TAG_HANDLE.test(handle)) {
+          throwError(state, "ill-formed tag handle (first argument) of the TAG directive");
+        }
+        if (_hasOwnProperty.call(state.tagMap, handle)) {
+          throwError(state, 'there is a previously declared suffix for "' + handle + '" tag handle');
+        }
+        if (!PATTERN_TAG_URI.test(prefix)) {
+          throwError(state, "ill-formed tag prefix (second argument) of the TAG directive");
+        }
+        try {
+          prefix = decodeURIComponent(prefix);
+        } catch (err) {
+          throwError(state, "tag prefix is malformed: " + prefix);
+        }
+        state.tagMap[handle] = prefix;
+      }
+    };
+    function captureSegment(state, start, end, checkJson) {
+      var _position, _length, _character, _result;
+      if (start < end) {
+        _result = state.input.slice(start, end);
+        if (checkJson) {
+          for (_position = 0, _length = _result.length; _position < _length; _position += 1) {
+            _character = _result.charCodeAt(_position);
+            if (!(_character === 9 || 32 <= _character && _character <= 1114111)) {
+              throwError(state, "expected valid JSON character");
+            }
+          }
+        } else if (PATTERN_NON_PRINTABLE.test(_result)) {
+          throwError(state, "the stream contains non-printable characters");
+        }
+        state.result += _result;
+      }
+    }
+    function mergeMappings(state, destination, source2, overridableKeys) {
+      var sourceKeys, key2, index, quantity;
+      if (!common.isObject(source2)) {
+        throwError(state, "cannot merge mappings; the provided source object is unacceptable");
+      }
+      sourceKeys = Object.keys(source2);
+      for (index = 0, quantity = sourceKeys.length; index < quantity; index += 1) {
+        key2 = sourceKeys[index];
+        if (!_hasOwnProperty.call(destination, key2)) {
+          destination[key2] = source2[key2];
+          overridableKeys[key2] = true;
+        }
+      }
+    }
+    function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, startLine, startLineStart, startPos) {
+      var index, quantity;
+      if (Array.isArray(keyNode)) {
+        keyNode = Array.prototype.slice.call(keyNode);
+        for (index = 0, quantity = keyNode.length; index < quantity; index += 1) {
+          if (Array.isArray(keyNode[index])) {
+            throwError(state, "nested arrays are not supported inside keys");
+          }
+          if (typeof keyNode === "object" && _class(keyNode[index]) === "[object Object]") {
+            keyNode[index] = "[object Object]";
+          }
+        }
+      }
+      if (typeof keyNode === "object" && _class(keyNode) === "[object Object]") {
+        keyNode = "[object Object]";
+      }
+      keyNode = String(keyNode);
+      if (_result === null) {
+        _result = {};
+      }
+      if (keyTag === "tag:yaml.org,2002:merge") {
+        if (Array.isArray(valueNode)) {
+          for (index = 0, quantity = valueNode.length; index < quantity; index += 1) {
+            mergeMappings(state, _result, valueNode[index], overridableKeys);
+          }
+        } else {
+          mergeMappings(state, _result, valueNode, overridableKeys);
+        }
+      } else {
+        if (!state.json && !_hasOwnProperty.call(overridableKeys, keyNode) && _hasOwnProperty.call(_result, keyNode)) {
+          state.line = startLine || state.line;
+          state.lineStart = startLineStart || state.lineStart;
+          state.position = startPos || state.position;
+          throwError(state, "duplicated mapping key");
+        }
+        if (keyNode === "__proto__") {
+          Object.defineProperty(_result, keyNode, {
+            configurable: true,
+            enumerable: true,
+            writable: true,
+            value: valueNode
+          });
+        } else {
+          _result[keyNode] = valueNode;
+        }
+        delete overridableKeys[keyNode];
+      }
+      return _result;
+    }
+    function readLineBreak(state) {
+      var ch2;
+      ch2 = state.input.charCodeAt(state.position);
+      if (ch2 === 10) {
+        state.position++;
+      } else if (ch2 === 13) {
+        state.position++;
+        if (state.input.charCodeAt(state.position) === 10) {
+          state.position++;
+        }
+      } else {
+        throwError(state, "a line break is expected");
+      }
+      state.line += 1;
+      state.lineStart = state.position;
+      state.firstTabInLine = -1;
+    }
+    function skipSeparationSpace(state, allowComments, checkIndent) {
+      var lineBreaks = 0, ch2 = state.input.charCodeAt(state.position);
+      while (ch2 !== 0) {
+        while (is_WHITE_SPACE(ch2)) {
+          if (ch2 === 9 && state.firstTabInLine === -1) {
+            state.firstTabInLine = state.position;
+          }
+          ch2 = state.input.charCodeAt(++state.position);
+        }
+        if (allowComments && ch2 === 35) {
+          do {
+            ch2 = state.input.charCodeAt(++state.position);
+          } while (ch2 !== 10 && ch2 !== 13 && ch2 !== 0);
+        }
+        if (is_EOL(ch2)) {
+          readLineBreak(state);
+          ch2 = state.input.charCodeAt(state.position);
+          lineBreaks++;
+          state.lineIndent = 0;
+          while (ch2 === 32) {
+            state.lineIndent++;
+            ch2 = state.input.charCodeAt(++state.position);
+          }
+        } else {
+          break;
+        }
+      }
+      if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) {
+        throwWarning(state, "deficient indentation");
+      }
+      return lineBreaks;
+    }
+    function testDocumentSeparator(state) {
+      var _position = state.position, ch2;
+      ch2 = state.input.charCodeAt(_position);
+      if ((ch2 === 45 || ch2 === 46) && ch2 === state.input.charCodeAt(_position + 1) && ch2 === state.input.charCodeAt(_position + 2)) {
+        _position += 3;
+        ch2 = state.input.charCodeAt(_position);
+        if (ch2 === 0 || is_WS_OR_EOL(ch2)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function writeFoldedLines(state, count) {
+      if (count === 1) {
+        state.result += " ";
+      } else if (count > 1) {
+        state.result += common.repeat("\n", count - 1);
+      }
+    }
+    function readPlainScalar(state, nodeIndent, withinFlowCollection) {
+      var preceding, following, captureStart, captureEnd, hasPendingContent, _line, _lineStart, _lineIndent, _kind = state.kind, _result = state.result, ch2;
+      ch2 = state.input.charCodeAt(state.position);
+      if (is_WS_OR_EOL(ch2) || is_FLOW_INDICATOR(ch2) || ch2 === 35 || ch2 === 38 || ch2 === 42 || ch2 === 33 || ch2 === 124 || ch2 === 62 || ch2 === 39 || ch2 === 34 || ch2 === 37 || ch2 === 64 || ch2 === 96) {
+        return false;
+      }
+      if (ch2 === 63 || ch2 === 45) {
+        following = state.input.charCodeAt(state.position + 1);
+        if (is_WS_OR_EOL(following) || withinFlowCollection && is_FLOW_INDICATOR(following)) {
+          return false;
+        }
+      }
+      state.kind = "scalar";
+      state.result = "";
+      captureStart = captureEnd = state.position;
+      hasPendingContent = false;
+      while (ch2 !== 0) {
+        if (ch2 === 58) {
+          following = state.input.charCodeAt(state.position + 1);
+          if (is_WS_OR_EOL(following) || withinFlowCollection && is_FLOW_INDICATOR(following)) {
+            break;
+          }
+        } else if (ch2 === 35) {
+          preceding = state.input.charCodeAt(state.position - 1);
+          if (is_WS_OR_EOL(preceding)) {
+            break;
+          }
+        } else if (state.position === state.lineStart && testDocumentSeparator(state) || withinFlowCollection && is_FLOW_INDICATOR(ch2)) {
+          break;
+        } else if (is_EOL(ch2)) {
+          _line = state.line;
+          _lineStart = state.lineStart;
+          _lineIndent = state.lineIndent;
+          skipSeparationSpace(state, false, -1);
+          if (state.lineIndent >= nodeIndent) {
+            hasPendingContent = true;
+            ch2 = state.input.charCodeAt(state.position);
+            continue;
+          } else {
+            state.position = captureEnd;
+            state.line = _line;
+            state.lineStart = _lineStart;
+            state.lineIndent = _lineIndent;
+            break;
+          }
+        }
+        if (hasPendingContent) {
+          captureSegment(state, captureStart, captureEnd, false);
+          writeFoldedLines(state, state.line - _line);
+          captureStart = captureEnd = state.position;
+          hasPendingContent = false;
+        }
+        if (!is_WHITE_SPACE(ch2)) {
+          captureEnd = state.position + 1;
+        }
+        ch2 = state.input.charCodeAt(++state.position);
+      }
+      captureSegment(state, captureStart, captureEnd, false);
+      if (state.result) {
+        return true;
+      }
+      state.kind = _kind;
+      state.result = _result;
+      return false;
+    }
+    function readSingleQuotedScalar(state, nodeIndent) {
+      var ch2, captureStart, captureEnd;
+      ch2 = state.input.charCodeAt(state.position);
+      if (ch2 !== 39) {
+        return false;
+      }
+      state.kind = "scalar";
+      state.result = "";
+      state.position++;
+      captureStart = captureEnd = state.position;
+      while ((ch2 = state.input.charCodeAt(state.position)) !== 0) {
+        if (ch2 === 39) {
+          captureSegment(state, captureStart, state.position, true);
+          ch2 = state.input.charCodeAt(++state.position);
+          if (ch2 === 39) {
+            captureStart = state.position;
+            state.position++;
+            captureEnd = state.position;
+          } else {
+            return true;
+          }
+        } else if (is_EOL(ch2)) {
+          captureSegment(state, captureStart, captureEnd, true);
+          writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
+          captureStart = captureEnd = state.position;
+        } else if (state.position === state.lineStart && testDocumentSeparator(state)) {
+          throwError(state, "unexpected end of the document within a single quoted scalar");
+        } else {
+          state.position++;
+          captureEnd = state.position;
+        }
+      }
+      throwError(state, "unexpected end of the stream within a single quoted scalar");
+    }
+    function readDoubleQuotedScalar(state, nodeIndent) {
+      var captureStart, captureEnd, hexLength, hexResult, tmp, ch2;
+      ch2 = state.input.charCodeAt(state.position);
+      if (ch2 !== 34) {
+        return false;
+      }
+      state.kind = "scalar";
+      state.result = "";
+      state.position++;
+      captureStart = captureEnd = state.position;
+      while ((ch2 = state.input.charCodeAt(state.position)) !== 0) {
+        if (ch2 === 34) {
+          captureSegment(state, captureStart, state.position, true);
+          state.position++;
+          return true;
+        } else if (ch2 === 92) {
+          captureSegment(state, captureStart, state.position, true);
+          ch2 = state.input.charCodeAt(++state.position);
+          if (is_EOL(ch2)) {
+            skipSeparationSpace(state, false, nodeIndent);
+          } else if (ch2 < 256 && simpleEscapeCheck[ch2]) {
+            state.result += simpleEscapeMap[ch2];
+            state.position++;
+          } else if ((tmp = escapedHexLen(ch2)) > 0) {
+            hexLength = tmp;
+            hexResult = 0;
+            for (; hexLength > 0; hexLength--) {
+              ch2 = state.input.charCodeAt(++state.position);
+              if ((tmp = fromHexCode(ch2)) >= 0) {
+                hexResult = (hexResult << 4) + tmp;
+              } else {
+                throwError(state, "expected hexadecimal character");
+              }
+            }
+            state.result += charFromCodepoint(hexResult);
+            state.position++;
+          } else {
+            throwError(state, "unknown escape sequence");
+          }
+          captureStart = captureEnd = state.position;
+        } else if (is_EOL(ch2)) {
+          captureSegment(state, captureStart, captureEnd, true);
+          writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
+          captureStart = captureEnd = state.position;
+        } else if (state.position === state.lineStart && testDocumentSeparator(state)) {
+          throwError(state, "unexpected end of the document within a double quoted scalar");
+        } else {
+          state.position++;
+          captureEnd = state.position;
+        }
+      }
+      throwError(state, "unexpected end of the stream within a double quoted scalar");
+    }
+    function readFlowCollection(state, nodeIndent) {
+      var readNext = true, _line, _lineStart, _pos, _tag = state.tag, _result, _anchor = state.anchor, following, terminator, isPair, isExplicitPair, isMapping, overridableKeys = /* @__PURE__ */ Object.create(null), keyNode, keyTag, valueNode, ch2;
+      ch2 = state.input.charCodeAt(state.position);
+      if (ch2 === 91) {
+        terminator = 93;
+        isMapping = false;
+        _result = [];
+      } else if (ch2 === 123) {
+        terminator = 125;
+        isMapping = true;
+        _result = {};
+      } else {
+        return false;
+      }
+      if (state.anchor !== null) {
+        state.anchorMap[state.anchor] = _result;
+      }
+      ch2 = state.input.charCodeAt(++state.position);
+      while (ch2 !== 0) {
+        skipSeparationSpace(state, true, nodeIndent);
+        ch2 = state.input.charCodeAt(state.position);
+        if (ch2 === terminator) {
+          state.position++;
+          state.tag = _tag;
+          state.anchor = _anchor;
+          state.kind = isMapping ? "mapping" : "sequence";
+          state.result = _result;
+          return true;
+        } else if (!readNext) {
+          throwError(state, "missed comma between flow collection entries");
+        } else if (ch2 === 44) {
+          throwError(state, "expected the node content, but found ','");
+        }
+        keyTag = keyNode = valueNode = null;
+        isPair = isExplicitPair = false;
+        if (ch2 === 63) {
+          following = state.input.charCodeAt(state.position + 1);
+          if (is_WS_OR_EOL(following)) {
+            isPair = isExplicitPair = true;
+            state.position++;
+            skipSeparationSpace(state, true, nodeIndent);
+          }
+        }
+        _line = state.line;
+        _lineStart = state.lineStart;
+        _pos = state.position;
+        composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
+        keyTag = state.tag;
+        keyNode = state.result;
+        skipSeparationSpace(state, true, nodeIndent);
+        ch2 = state.input.charCodeAt(state.position);
+        if ((isExplicitPair || state.line === _line) && ch2 === 58) {
+          isPair = true;
+          ch2 = state.input.charCodeAt(++state.position);
+          skipSeparationSpace(state, true, nodeIndent);
+          composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
+          valueNode = state.result;
+        }
+        if (isMapping) {
+          storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos);
+        } else if (isPair) {
+          _result.push(storeMappingPair(state, null, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos));
+        } else {
+          _result.push(keyNode);
+        }
+        skipSeparationSpace(state, true, nodeIndent);
+        ch2 = state.input.charCodeAt(state.position);
+        if (ch2 === 44) {
+          readNext = true;
+          ch2 = state.input.charCodeAt(++state.position);
+        } else {
+          readNext = false;
+        }
+      }
+      throwError(state, "unexpected end of the stream within a flow collection");
+    }
+    function readBlockScalar(state, nodeIndent) {
+      var captureStart, folding, chomping = CHOMPING_CLIP, didReadContent = false, detectedIndent = false, textIndent = nodeIndent, emptyLines = 0, atMoreIndented = false, tmp, ch2;
+      ch2 = state.input.charCodeAt(state.position);
+      if (ch2 === 124) {
+        folding = false;
+      } else if (ch2 === 62) {
+        folding = true;
+      } else {
+        return false;
+      }
+      state.kind = "scalar";
+      state.result = "";
+      while (ch2 !== 0) {
+        ch2 = state.input.charCodeAt(++state.position);
+        if (ch2 === 43 || ch2 === 45) {
+          if (CHOMPING_CLIP === chomping) {
+            chomping = ch2 === 43 ? CHOMPING_KEEP : CHOMPING_STRIP;
+          } else {
+            throwError(state, "repeat of a chomping mode identifier");
+          }
+        } else if ((tmp = fromDecimalCode(ch2)) >= 0) {
+          if (tmp === 0) {
+            throwError(state, "bad explicit indentation width of a block scalar; it cannot be less than one");
+          } else if (!detectedIndent) {
+            textIndent = nodeIndent + tmp - 1;
+            detectedIndent = true;
+          } else {
+            throwError(state, "repeat of an indentation width identifier");
+          }
+        } else {
+          break;
+        }
+      }
+      if (is_WHITE_SPACE(ch2)) {
+        do {
+          ch2 = state.input.charCodeAt(++state.position);
+        } while (is_WHITE_SPACE(ch2));
+        if (ch2 === 35) {
+          do {
+            ch2 = state.input.charCodeAt(++state.position);
+          } while (!is_EOL(ch2) && ch2 !== 0);
+        }
+      }
+      while (ch2 !== 0) {
+        readLineBreak(state);
+        state.lineIndent = 0;
+        ch2 = state.input.charCodeAt(state.position);
+        while ((!detectedIndent || state.lineIndent < textIndent) && ch2 === 32) {
+          state.lineIndent++;
+          ch2 = state.input.charCodeAt(++state.position);
+        }
+        if (!detectedIndent && state.lineIndent > textIndent) {
+          textIndent = state.lineIndent;
+        }
+        if (is_EOL(ch2)) {
+          emptyLines++;
+          continue;
+        }
+        if (state.lineIndent < textIndent) {
+          if (chomping === CHOMPING_KEEP) {
+            state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines);
+          } else if (chomping === CHOMPING_CLIP) {
+            if (didReadContent) {
+              state.result += "\n";
+            }
+          }
+          break;
+        }
+        if (folding) {
+          if (is_WHITE_SPACE(ch2)) {
+            atMoreIndented = true;
+            state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines);
+          } else if (atMoreIndented) {
+            atMoreIndented = false;
+            state.result += common.repeat("\n", emptyLines + 1);
+          } else if (emptyLines === 0) {
+            if (didReadContent) {
+              state.result += " ";
+            }
+          } else {
+            state.result += common.repeat("\n", emptyLines);
+          }
+        } else {
+          state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines);
+        }
+        didReadContent = true;
+        detectedIndent = true;
+        emptyLines = 0;
+        captureStart = state.position;
+        while (!is_EOL(ch2) && ch2 !== 0) {
+          ch2 = state.input.charCodeAt(++state.position);
+        }
+        captureSegment(state, captureStart, state.position, false);
+      }
+      return true;
+    }
+    function readBlockSequence(state, nodeIndent) {
+      var _line, _tag = state.tag, _anchor = state.anchor, _result = [], following, detected = false, ch2;
+      if (state.firstTabInLine !== -1) return false;
+      if (state.anchor !== null) {
+        state.anchorMap[state.anchor] = _result;
+      }
+      ch2 = state.input.charCodeAt(state.position);
+      while (ch2 !== 0) {
+        if (state.firstTabInLine !== -1) {
+          state.position = state.firstTabInLine;
+          throwError(state, "tab characters must not be used in indentation");
+        }
+        if (ch2 !== 45) {
+          break;
+        }
+        following = state.input.charCodeAt(state.position + 1);
+        if (!is_WS_OR_EOL(following)) {
+          break;
+        }
+        detected = true;
+        state.position++;
+        if (skipSeparationSpace(state, true, -1)) {
+          if (state.lineIndent <= nodeIndent) {
+            _result.push(null);
+            ch2 = state.input.charCodeAt(state.position);
+            continue;
+          }
+        }
+        _line = state.line;
+        composeNode(state, nodeIndent, CONTEXT_BLOCK_IN, false, true);
+        _result.push(state.result);
+        skipSeparationSpace(state, true, -1);
+        ch2 = state.input.charCodeAt(state.position);
+        if ((state.line === _line || state.lineIndent > nodeIndent) && ch2 !== 0) {
+          throwError(state, "bad indentation of a sequence entry");
+        } else if (state.lineIndent < nodeIndent) {
+          break;
+        }
+      }
+      if (detected) {
+        state.tag = _tag;
+        state.anchor = _anchor;
+        state.kind = "sequence";
+        state.result = _result;
+        return true;
+      }
+      return false;
+    }
+    function readBlockMapping(state, nodeIndent, flowIndent) {
+      var following, allowCompact, _line, _keyLine, _keyLineStart, _keyPos, _tag = state.tag, _anchor = state.anchor, _result = {}, overridableKeys = /* @__PURE__ */ Object.create(null), keyTag = null, keyNode = null, valueNode = null, atExplicitKey = false, detected = false, ch2;
+      if (state.firstTabInLine !== -1) return false;
+      if (state.anchor !== null) {
+        state.anchorMap[state.anchor] = _result;
+      }
+      ch2 = state.input.charCodeAt(state.position);
+      while (ch2 !== 0) {
+        if (!atExplicitKey && state.firstTabInLine !== -1) {
+          state.position = state.firstTabInLine;
+          throwError(state, "tab characters must not be used in indentation");
+        }
+        following = state.input.charCodeAt(state.position + 1);
+        _line = state.line;
+        if ((ch2 === 63 || ch2 === 58) && is_WS_OR_EOL(following)) {
+          if (ch2 === 63) {
+            if (atExplicitKey) {
+              storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
+              keyTag = keyNode = valueNode = null;
+            }
+            detected = true;
+            atExplicitKey = true;
+            allowCompact = true;
+          } else if (atExplicitKey) {
+            atExplicitKey = false;
+            allowCompact = true;
+          } else {
+            throwError(state, "incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line");
+          }
+          state.position += 1;
+          ch2 = following;
+        } else {
+          _keyLine = state.line;
+          _keyLineStart = state.lineStart;
+          _keyPos = state.position;
+          if (!composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) {
+            break;
+          }
+          if (state.line === _line) {
+            ch2 = state.input.charCodeAt(state.position);
+            while (is_WHITE_SPACE(ch2)) {
+              ch2 = state.input.charCodeAt(++state.position);
+            }
+            if (ch2 === 58) {
+              ch2 = state.input.charCodeAt(++state.position);
+              if (!is_WS_OR_EOL(ch2)) {
+                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;
+              }
+              detected = true;
+              atExplicitKey = false;
+              allowCompact = false;
+              keyTag = state.tag;
+              keyNode = state.result;
+            } else if (detected) {
+              throwError(state, "can not read an implicit mapping pair; a colon is missed");
+            } else {
+              state.tag = _tag;
+              state.anchor = _anchor;
+              return true;
+            }
+          } else if (detected) {
+            throwError(state, "can not read a block mapping entry; a multiline key may not be an implicit key");
+          } else {
+            state.tag = _tag;
+            state.anchor = _anchor;
+            return true;
+          }
+        }
+        if (state.line === _line || state.lineIndent > nodeIndent) {
+          if (atExplicitKey) {
+            _keyLine = state.line;
+            _keyLineStart = state.lineStart;
+            _keyPos = state.position;
+          }
+          if (composeNode(state, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) {
+            if (atExplicitKey) {
+              keyNode = state.result;
+            } else {
+              valueNode = state.result;
+            }
+          }
+          if (!atExplicitKey) {
+            storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _keyLine, _keyLineStart, _keyPos);
+            keyTag = keyNode = valueNode = null;
+          }
+          skipSeparationSpace(state, true, -1);
+          ch2 = state.input.charCodeAt(state.position);
+        }
+        if ((state.line === _line || state.lineIndent > nodeIndent) && ch2 !== 0) {
+          throwError(state, "bad indentation of a mapping entry");
+        } else if (state.lineIndent < nodeIndent) {
+          break;
+        }
+      }
+      if (atExplicitKey) {
+        storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
+      }
+      if (detected) {
+        state.tag = _tag;
+        state.anchor = _anchor;
+        state.kind = "mapping";
+        state.result = _result;
+      }
+      return detected;
+    }
+    function readTagProperty(state) {
+      var _position, isVerbatim = false, isNamed = false, tagHandle, tagName, ch2;
+      ch2 = state.input.charCodeAt(state.position);
+      if (ch2 !== 33) return false;
+      if (state.tag !== null) {
+        throwError(state, "duplication of a tag property");
+      }
+      ch2 = state.input.charCodeAt(++state.position);
+      if (ch2 === 60) {
+        isVerbatim = true;
+        ch2 = state.input.charCodeAt(++state.position);
+      } else if (ch2 === 33) {
+        isNamed = true;
+        tagHandle = "!!";
+        ch2 = state.input.charCodeAt(++state.position);
+      } else {
+        tagHandle = "!";
+      }
+      _position = state.position;
+      if (isVerbatim) {
+        do {
+          ch2 = state.input.charCodeAt(++state.position);
+        } while (ch2 !== 0 && ch2 !== 62);
+        if (state.position < state.length) {
+          tagName = state.input.slice(_position, state.position);
+          ch2 = state.input.charCodeAt(++state.position);
+        } else {
+          throwError(state, "unexpected end of the stream within a verbatim tag");
+        }
+      } else {
+        while (ch2 !== 0 && !is_WS_OR_EOL(ch2)) {
+          if (ch2 === 33) {
+            if (!isNamed) {
+              tagHandle = state.input.slice(_position - 1, state.position + 1);
+              if (!PATTERN_TAG_HANDLE.test(tagHandle)) {
+                throwError(state, "named tag handle cannot contain such characters");
+              }
+              isNamed = true;
+              _position = state.position + 1;
+            } else {
+              throwError(state, "tag suffix cannot contain exclamation marks");
+            }
+          }
+          ch2 = state.input.charCodeAt(++state.position);
+        }
+        tagName = state.input.slice(_position, state.position);
+        if (PATTERN_FLOW_INDICATORS.test(tagName)) {
+          throwError(state, "tag suffix cannot contain flow indicator characters");
+        }
+      }
+      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) {
+        state.tag = tagName;
+      } else if (_hasOwnProperty.call(state.tagMap, tagHandle)) {
+        state.tag = state.tagMap[tagHandle] + tagName;
+      } else if (tagHandle === "!") {
+        state.tag = "!" + tagName;
+      } else if (tagHandle === "!!") {
+        state.tag = "tag:yaml.org,2002:" + tagName;
+      } else {
+        throwError(state, 'undeclared tag handle "' + tagHandle + '"');
+      }
+      return true;
+    }
+    function readAnchorProperty(state) {
+      var _position, ch2;
+      ch2 = state.input.charCodeAt(state.position);
+      if (ch2 !== 38) return false;
+      if (state.anchor !== null) {
+        throwError(state, "duplication of an anchor property");
+      }
+      ch2 = state.input.charCodeAt(++state.position);
+      _position = state.position;
+      while (ch2 !== 0 && !is_WS_OR_EOL(ch2) && !is_FLOW_INDICATOR(ch2)) {
+        ch2 = state.input.charCodeAt(++state.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;
+    }
+    function readAlias(state) {
+      var _position, alias, ch2;
+      ch2 = state.input.charCodeAt(state.position);
+      if (ch2 !== 42) return false;
+      ch2 = state.input.charCodeAt(++state.position);
+      _position = state.position;
+      while (ch2 !== 0 && !is_WS_OR_EOL(ch2) && !is_FLOW_INDICATOR(ch2)) {
+        ch2 = state.input.charCodeAt(++state.position);
+      }
+      if (state.position === _position) {
+        throwError(state, "name of an alias node must contain at least one character");
+      }
+      alias = state.input.slice(_position, state.position);
+      if (!_hasOwnProperty.call(state.anchorMap, alias)) {
+        throwError(state, 'unidentified alias "' + alias + '"');
+      }
+      state.result = state.anchorMap[alias];
+      skipSeparationSpace(state, true, -1);
+      return true;
+    }
+    function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact) {
+      var allowBlockStyles, allowBlockScalars, allowBlockCollections, indentStatus = 1, atNewLine = false, hasContent = false, typeIndex, typeQuantity, typeList, type, flowIndent, blockIndent;
+      if (state.listener !== null) {
+        state.listener("open", state);
+      }
+      state.tag = null;
+      state.anchor = null;
+      state.kind = null;
+      state.result = null;
+      allowBlockStyles = allowBlockScalars = allowBlockCollections = CONTEXT_BLOCK_OUT === nodeContext || CONTEXT_BLOCK_IN === nodeContext;
+      if (allowToSeek) {
+        if (skipSeparationSpace(state, true, -1)) {
+          atNewLine = true;
+          if (state.lineIndent > parentIndent) {
+            indentStatus = 1;
+          } else if (state.lineIndent === parentIndent) {
+            indentStatus = 0;
+          } else if (state.lineIndent < parentIndent) {
+            indentStatus = -1;
+          }
+        }
+      }
+      if (indentStatus === 1) {
+        while (readTagProperty(state) || readAnchorProperty(state)) {
+          if (skipSeparationSpace(state, true, -1)) {
+            atNewLine = true;
+            allowBlockCollections = allowBlockStyles;
+            if (state.lineIndent > parentIndent) {
+              indentStatus = 1;
+            } else if (state.lineIndent === parentIndent) {
+              indentStatus = 0;
+            } else if (state.lineIndent < parentIndent) {
+              indentStatus = -1;
+            }
+          } else {
+            allowBlockCollections = false;
+          }
+        }
+      }
+      if (allowBlockCollections) {
+        allowBlockCollections = atNewLine || allowCompact;
+      }
+      if (indentStatus === 1 || CONTEXT_BLOCK_OUT === nodeContext) {
+        if (CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext) {
+          flowIndent = parentIndent;
+        } else {
+          flowIndent = parentIndent + 1;
+        }
+        blockIndent = state.position - state.lineStart;
+        if (indentStatus === 1) {
+          if (allowBlockCollections && (readBlockSequence(state, blockIndent) || readBlockMapping(state, blockIndent, flowIndent)) || readFlowCollection(state, flowIndent)) {
+            hasContent = true;
+          } else {
+            if (allowBlockScalars && readBlockScalar(state, flowIndent) || readSingleQuotedScalar(state, flowIndent) || readDoubleQuotedScalar(state, flowIndent)) {
+              hasContent = true;
+            } else if (readAlias(state)) {
+              hasContent = true;
+              if (state.tag !== null || state.anchor !== null) {
+                throwError(state, "alias node should not have any properties");
               }
-              cb2(null, name);
-            });
-          } catch (err2) {
-            cb2(err2);
+            } else if (readPlainScalar(state, flowIndent, CONTEXT_FLOW_IN === nodeContext)) {
+              hasContent = true;
+              if (state.tag === null) {
+                state.tag = "?";
+              }
+            }
+            if (state.anchor !== null) {
+              state.anchorMap[state.anchor] = state.result;
+            }
           }
-        })();
-      });
+        } else if (indentStatus === 0) {
+          hasContent = allowBlockCollections && readBlockSequence(state, blockIndent);
+        }
+      }
+      if (state.tag === null) {
+        if (state.anchor !== null) {
+          state.anchorMap[state.anchor] = state.result;
+        }
+      } else if (state.tag === "?") {
+        if (state.result !== null && state.kind !== "scalar") {
+          throwError(state, 'unacceptable node kind for !<?> tag; it should be "scalar", not "' + state.kind + '"');
+        }
+        for (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) {
+              state.anchorMap[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;
+          typeList = state.typeMap.multi[state.kind || "fallback"];
+          for (typeIndex = 0, typeQuantity = typeList.length; typeIndex < typeQuantity; typeIndex += 1) {
+            if (state.tag.slice(0, typeList[typeIndex].tag.length) === typeList[typeIndex].tag) {
+              type = typeList[typeIndex];
+              break;
+            }
+          }
+        }
+        if (!type) {
+          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) {
+            state.anchorMap[state.anchor] = state.result;
+          }
+        }
+      }
+      if (state.listener !== null) {
+        state.listener("close", state);
+      }
+      return state.tag !== null || state.anchor !== null || hasContent;
     }
-    function tmpNameSync(options8) {
-      const args = _parseArguments(options8), opts = args[0];
-      const sanitizedOptions = _assertAndSanitizeOptionsSync(opts);
-      let tries = sanitizedOptions.tries;
-      do {
-        const name = _generateTmpName(sanitizedOptions);
-        try {
-          fs8.statSync(name);
-        } catch (e7) {
-          return name;
-        }
-      } while (tries-- > 0);
-      throw new Error("Could not get a unique tmp filename, max tries reached");
-    }
-    function file(options8, callback) {
-      const args = _parseArguments(options8, callback), opts = args[0], cb2 = args[1];
-      tmpName(opts, function _tmpNameCreated(err, name) {
-        if (err) return cb2(err);
-        fs8.open(name, CREATE_FLAGS, opts.mode || FILE_MODE, function _fileCreated(err2, fd2) {
-          if (err2) return cb2(err2);
-          if (opts.discardDescriptor) {
-            return fs8.close(fd2, function _discardCallback(possibleErr) {
-              return cb2(possibleErr, name, void 0, _prepareTmpFileRemoveCallback(name, -1, opts, false));
-            });
-          } else {
-            const discardOrDetachDescriptor = opts.discardDescriptor || opts.detachDescriptor;
-            cb2(null, name, fd2, _prepareTmpFileRemoveCallback(name, discardOrDetachDescriptor ? -1 : fd2, opts, false));
+    function readDocument(state) {
+      var documentStart = state.position, _position, directiveName, directiveArgs, hasDirectives = false, ch2;
+      state.version = null;
+      state.checkLineBreaks = state.legacy;
+      state.tagMap = /* @__PURE__ */ Object.create(null);
+      state.anchorMap = /* @__PURE__ */ Object.create(null);
+      while ((ch2 = state.input.charCodeAt(state.position)) !== 0) {
+        skipSeparationSpace(state, true, -1);
+        ch2 = state.input.charCodeAt(state.position);
+        if (state.lineIndent > 0 || ch2 !== 37) {
+          break;
+        }
+        hasDirectives = true;
+        ch2 = state.input.charCodeAt(++state.position);
+        _position = state.position;
+        while (ch2 !== 0 && !is_WS_OR_EOL(ch2)) {
+          ch2 = state.input.charCodeAt(++state.position);
+        }
+        directiveName = state.input.slice(_position, state.position);
+        directiveArgs = [];
+        if (directiveName.length < 1) {
+          throwError(state, "directive name must not be less than one character in length");
+        }
+        while (ch2 !== 0) {
+          while (is_WHITE_SPACE(ch2)) {
+            ch2 = state.input.charCodeAt(++state.position);
           }
-        });
-      });
+          if (ch2 === 35) {
+            do {
+              ch2 = state.input.charCodeAt(++state.position);
+            } while (ch2 !== 0 && !is_EOL(ch2));
+            break;
+          }
+          if (is_EOL(ch2)) break;
+          _position = state.position;
+          while (ch2 !== 0 && !is_WS_OR_EOL(ch2)) {
+            ch2 = state.input.charCodeAt(++state.position);
+          }
+          directiveArgs.push(state.input.slice(_position, state.position));
+        }
+        if (ch2 !== 0) readLineBreak(state);
+        if (_hasOwnProperty.call(directiveHandlers, directiveName)) {
+          directiveHandlers[directiveName](state, directiveName, directiveArgs);
+        } 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) {
+        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))) {
+        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) {
+          state.position += 3;
+          skipSeparationSpace(state, true, -1);
+        }
+        return;
+      }
+      if (state.position < state.length - 1) {
+        throwError(state, "end of the stream or a document separator is expected");
+      } else {
+        return;
+      }
     }
-    function fileSync(options8) {
-      const args = _parseArguments(options8), opts = args[0];
-      const discardOrDetachDescriptor = opts.discardDescriptor || opts.detachDescriptor;
-      const name = tmpNameSync(opts);
-      let fd2 = fs8.openSync(name, CREATE_FLAGS, opts.mode || FILE_MODE);
-      if (opts.discardDescriptor) {
-        fs8.closeSync(fd2);
-        fd2 = void 0;
+    function loadDocuments(input, options8) {
+      input = String(input);
+      options8 = options8 || {};
+      if (input.length !== 0) {
+        if (input.charCodeAt(input.length - 1) !== 10 && input.charCodeAt(input.length - 1) !== 13) {
+          input += "\n";
+        }
+        if (input.charCodeAt(0) === 65279) {
+          input = input.slice(1);
+        }
       }
-      return {
-        name,
-        fd: fd2,
-        removeCallback: _prepareTmpFileRemoveCallback(name, discardOrDetachDescriptor ? -1 : fd2, opts, true)
-      };
+      var state = new State(input, options8);
+      var nullpos = input.indexOf("\0");
+      if (nullpos !== -1) {
+        state.position = nullpos;
+        throwError(state, "null byte is not allowed in input");
+      }
+      state.input += "\0";
+      while (state.input.charCodeAt(state.position) === 32) {
+        state.lineIndent += 1;
+        state.position += 1;
+      }
+      while (state.position < state.length - 1) {
+        readDocument(state);
+      }
+      return state.documents;
     }
-    function dir(options8, callback) {
-      const args = _parseArguments(options8, callback), opts = args[0], cb2 = args[1];
-      tmpName(opts, function _tmpNameCreated(err, name) {
-        if (err) return cb2(err);
-        fs8.mkdir(name, opts.mode || DIR_MODE, function _dirCreated(err2) {
-          if (err2) return cb2(err2);
-          cb2(null, name, _prepareTmpDirRemoveCallback(name, opts, false));
-        });
-      });
+    function loadAll(input, iterator, options8) {
+      if (iterator !== null && typeof iterator === "object" && typeof options8 === "undefined") {
+        options8 = iterator;
+        iterator = null;
+      }
+      var documents = loadDocuments(input, options8);
+      if (typeof iterator !== "function") {
+        return documents;
+      }
+      for (var index = 0, length = documents.length; index < length; index += 1) {
+        iterator(documents[index]);
+      }
     }
-    function dirSync(options8) {
-      const args = _parseArguments(options8), opts = args[0];
-      const name = tmpNameSync(opts);
-      fs8.mkdirSync(name, opts.mode || DIR_MODE);
-      return {
-        name,
-        removeCallback: _prepareTmpDirRemoveCallback(name, opts, true)
-      };
+    function load(input, options8) {
+      var documents = loadDocuments(input, options8);
+      if (documents.length === 0) {
+        return void 0;
+      } else if (documents.length === 1) {
+        return documents[0];
+      }
+      throw new YAMLException("expected a single document in the stream, but found more");
+    }
+    module2.exports.loadAll = loadAll;
+    module2.exports.load = load;
+  }
+});
+
+// ../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/dumper.js
+var require_dumper = __commonJS({
+  "../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/lib/dumper.js"(exports2, module2) {
+    "use strict";
+    var common = require_common3();
+    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 = {};
+    ESCAPE_SEQUENCES[0] = "\\0";
+    ESCAPE_SEQUENCES[7] = "\\a";
+    ESCAPE_SEQUENCES[8] = "\\b";
+    ESCAPE_SEQUENCES[9] = "\\t";
+    ESCAPE_SEQUENCES[10] = "\\n";
+    ESCAPE_SEQUENCES[11] = "\\v";
+    ESCAPE_SEQUENCES[12] = "\\f";
+    ESCAPE_SEQUENCES[13] = "\\r";
+    ESCAPE_SEQUENCES[27] = "\\e";
+    ESCAPE_SEQUENCES[34] = '\\"';
+    ESCAPE_SEQUENCES[92] = "\\\\";
+    ESCAPE_SEQUENCES[133] = "\\N";
+    ESCAPE_SEQUENCES[160] = "\\_";
+    ESCAPE_SEQUENCES[8232] = "\\L";
+    ESCAPE_SEQUENCES[8233] = "\\P";
+    var DEPRECATED_BOOLEANS_SYNTAX = [
+      "y",
+      "Y",
+      "yes",
+      "Yes",
+      "YES",
+      "on",
+      "On",
+      "ON",
+      "n",
+      "N",
+      "no",
+      "No",
+      "NO",
+      "off",
+      "Off",
+      "OFF"
+    ];
+    var DEPRECATED_BASE60_SYNTAX = /^[-+]?[0-9_]+(?::[0-9_]+)+(?:\.[0-9_]*)?$/;
+    var SINGLE_LINE_KEYS = {
+      cpu: true,
+      engines: true,
+      os: true,
+      resolution: true,
+      libc: true
+    };
+    function compileStyleMap(schema, map) {
+      var result, keys, index, length, tag, style, type;
+      if (map === null) return {};
+      result = {};
+      keys = Object.keys(map);
+      for (index = 0, length = keys.length; index < length; index += 1) {
+        tag = keys[index];
+        style = String(map[tag]);
+        if (tag.slice(0, 2) === "!!") {
+          tag = "tag:yaml.org,2002:" + tag.slice(2);
+        }
+        type = schema.compiledTypeMap["fallback"][tag];
+        if (type && _hasOwnProperty.call(type.styleAliases, style)) {
+          style = type.styleAliases[style];
+        }
+        result[tag] = style;
+      }
+      return result;
     }
-    function _removeFileAsync(fdPath, next) {
-      const _handler = function(err) {
-        if (err && !_isENOENT(err)) {
-          return next(err);
+    function encodeHex(character) {
+      var string, handle, length;
+      string = character.toString(16).toUpperCase();
+      if (character <= 255) {
+        handle = "x";
+        length = 2;
+      } else if (character <= 65535) {
+        handle = "u";
+        length = 4;
+      } 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;
+    }
+    var QUOTING_TYPE_SINGLE = 1;
+    var QUOTING_TYPE_DOUBLE = 2;
+    function State(options8) {
+      this.blankLines = options8["blankLines"] || false;
+      this.schema = options8["schema"] || DEFAULT_SCHEMA;
+      this.indent = Math.max(1, options8["indent"] || 2);
+      this.noArrayIndent = options8["noArrayIndent"] || false;
+      this.skipInvalid = options8["skipInvalid"] || false;
+      this.flowLevel = common.isNothing(options8["flowLevel"]) ? -1 : options8["flowLevel"];
+      this.styleMap = compileStyleMap(this.schema, options8["styles"] || null);
+      this.sortKeys = options8["sortKeys"] || false;
+      this.lineWidth = options8["lineWidth"] || 80;
+      this.noRefs = options8["noRefs"] || false;
+      this.noCompatMode = options8["noCompatMode"] || false;
+      this.condenseFlow = options8["condenseFlow"] || false;
+      this.quotingType = options8["quotingType"] === '"' ? QUOTING_TYPE_DOUBLE : QUOTING_TYPE_SINGLE;
+      this.forceQuotes = options8["forceQuotes"] || false;
+      this.replacer = typeof options8["replacer"] === "function" ? options8["replacer"] : null;
+      this.implicitTypes = this.schema.compiledImplicit;
+      this.explicitTypes = this.schema.compiledExplicit;
+      this.tag = null;
+      this.result = "";
+      this.duplicates = [];
+      this.usedDuplicates = null;
+    }
+    function indentString(string, spaces) {
+      var ind = common.repeat(" ", spaces), position = 0, next = -1, result = "", line3, length = string.length;
+      while (position < length) {
+        next = string.indexOf("\n", position);
+        if (next === -1) {
+          line3 = string.slice(position);
+          position = length;
+        } else {
+          line3 = string.slice(position, next + 1);
+          position = next + 1;
         }
-        next();
-      };
-      if (0 <= fdPath[0])
-        fs8.close(fdPath[0], function() {
-          fs8.unlink(fdPath[1], _handler);
-        });
-      else fs8.unlink(fdPath[1], _handler);
+        if (line3.length && line3 !== "\n") result += ind;
+        result += line3;
+      }
+      return result;
     }
-    function _removeFileSync(fdPath) {
-      let rethrownException = null;
-      try {
-        if (0 <= fdPath[0]) fs8.closeSync(fdPath[0]);
-      } catch (e7) {
-        if (!_isEBADF(e7) && !_isENOENT(e7)) throw e7;
-      } finally {
-        try {
-          fs8.unlinkSync(fdPath[1]);
-        } catch (e7) {
-          if (!_isENOENT(e7)) rethrownException = e7;
-        }
-      }
-      if (rethrownException !== null) {
-        throw rethrownException;
-      }
-    }
-    function _prepareTmpFileRemoveCallback(name, fd2, opts, sync) {
-      const removeCallbackSync = _prepareRemoveCallback(_removeFileSync, [fd2, name], sync);
-      const removeCallback = _prepareRemoveCallback(_removeFileAsync, [fd2, name], sync, removeCallbackSync);
-      if (!opts.keep) _removeObjects.unshift(removeCallbackSync);
-      return sync ? removeCallbackSync : removeCallback;
-    }
-    function _prepareTmpDirRemoveCallback(name, opts, sync) {
-      const removeFunction = opts.unsafeCleanup ? rimraf : fs8.rmdir.bind(fs8);
-      const removeFunctionSync = opts.unsafeCleanup ? FN_RIMRAF_SYNC : FN_RMDIR_SYNC;
-      const removeCallbackSync = _prepareRemoveCallback(removeFunctionSync, name, sync);
-      const removeCallback = _prepareRemoveCallback(removeFunction, name, sync, removeCallbackSync);
-      if (!opts.keep) _removeObjects.unshift(removeCallbackSync);
-      return sync ? removeCallbackSync : removeCallback;
-    }
-    function _prepareRemoveCallback(removeFunction, fileOrDirName, sync, cleanupCallbackSync) {
-      let called = false;
-      return function _cleanupCallback(next) {
-        if (!called) {
-          const toRemove = cleanupCallbackSync || _cleanupCallback;
-          const index = _removeObjects.indexOf(toRemove);
-          if (index >= 0) _removeObjects.splice(index, 1);
-          called = true;
-          if (sync || removeFunction === FN_RMDIR_SYNC || removeFunction === FN_RIMRAF_SYNC) {
-            return removeFunction(fileOrDirName);
+    function generateNextLine(state, level, doubleLine) {
+      return "\n" + (doubleLine ? "\n" : "") + common.repeat(" ", state.indent * level);
+    }
+    function testImplicitResolving(state, str) {
+      var index, length, type;
+      for (index = 0, length = state.implicitTypes.length; index < length; index += 1) {
+        type = state.implicitTypes[index];
+        if (type.resolve(str)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function isWhitespace(c5) {
+      return c5 === CHAR_SPACE || c5 === CHAR_TAB;
+    }
+    function isPrintable(c5) {
+      return 32 <= c5 && c5 <= 126 || 161 <= c5 && c5 <= 55295 && c5 !== 8232 && c5 !== 8233 || 57344 <= c5 && c5 <= 65533 && c5 !== CHAR_BOM || 65536 <= c5 && c5 <= 1114111;
+    }
+    function isNsCharOrWhitespace(c5) {
+      return isPrintable(c5) && c5 !== CHAR_BOM && c5 !== CHAR_CARRIAGE_RETURN && c5 !== CHAR_LINE_FEED;
+    }
+    function isPlainSafe(c5, prev, inblock) {
+      var cIsNsCharOrWhitespace = isNsCharOrWhitespace(c5);
+      var cIsNsChar = cIsNsCharOrWhitespace && !isWhitespace(c5);
+      return (
+        // ns-plain-safe
+        (inblock ? (
+          // c = flow-in
+          cIsNsCharOrWhitespace
+        ) : cIsNsCharOrWhitespace && c5 !== CHAR_COMMA && c5 !== CHAR_LEFT_SQUARE_BRACKET && c5 !== CHAR_RIGHT_SQUARE_BRACKET && c5 !== CHAR_LEFT_CURLY_BRACKET && c5 !== CHAR_RIGHT_CURLY_BRACKET) && c5 !== CHAR_SHARP && !(prev === CHAR_COLON && !cIsNsChar) || isNsCharOrWhitespace(prev) && !isWhitespace(prev) && c5 === CHAR_SHARP || prev === CHAR_COLON && cIsNsChar
+      );
+    }
+    function isPlainSafeFirst(c5) {
+      return isPrintable(c5) && c5 !== CHAR_BOM && !isWhitespace(c5) && c5 !== CHAR_MINUS && c5 !== CHAR_QUESTION && c5 !== CHAR_COLON && c5 !== CHAR_COMMA && c5 !== CHAR_LEFT_SQUARE_BRACKET && c5 !== CHAR_RIGHT_SQUARE_BRACKET && c5 !== CHAR_LEFT_CURLY_BRACKET && c5 !== CHAR_RIGHT_CURLY_BRACKET && c5 !== CHAR_SHARP && c5 !== CHAR_AMPERSAND && c5 !== CHAR_ASTERISK && c5 !== CHAR_EXCLAMATION && c5 !== CHAR_VERTICAL_LINE && c5 !== CHAR_EQUALS && c5 !== CHAR_GREATER_THAN && c5 !== CHAR_SINGLE_QUOTE && c5 !== CHAR_DOUBLE_QUOTE && c5 !== CHAR_PERCENT && c5 !== CHAR_COMMERCIAL_AT && c5 !== CHAR_GRAVE_ACCENT;
+    }
+    function isPlainSafeLast(c5) {
+      return !isWhitespace(c5) && c5 !== CHAR_COLON;
+    }
+    function codePointAt(string, pos2) {
+      var first = string.charCodeAt(pos2), second;
+      if (first >= 55296 && first <= 56319 && pos2 + 1 < string.length) {
+        second = string.charCodeAt(pos2 + 1);
+        if (second >= 56320 && second <= 57343) {
+          return (first - 55296) * 1024 + second - 56320 + 65536;
+        }
+      }
+      return first;
+    }
+    function needIndentIndicator(string) {
+      var leadingSpaceRe = /^\n* /;
+      return leadingSpaceRe.test(string);
+    }
+    var STYLE_PLAIN = 1;
+    var STYLE_SINGLE = 2;
+    var STYLE_LITERAL = 3;
+    var STYLE_FOLDED = 4;
+    var STYLE_DOUBLE = 5;
+    function chooseScalarStyle(string, singleLineOnly, indentPerLevel, lineWidth, testAmbiguousType, quotingType, forceQuotes, inblock) {
+      var i;
+      var char = 0;
+      var prevChar = null;
+      var hasLineBreak = false;
+      var hasFoldableLine = false;
+      var shouldTrackWidth = lineWidth !== -1;
+      var previousLineBreak = -1;
+      var plain = isPlainSafeFirst(codePointAt(string, 0)) && isPlainSafeLast(codePointAt(string, string.length - 1));
+      if (singleLineOnly || forceQuotes) {
+        for (i = 0; i < string.length; char >= 65536 ? i += 2 : i++) {
+          char = codePointAt(string, i);
+          if (!isPrintable(char)) {
+            return STYLE_DOUBLE;
+          }
+          plain = plain && isPlainSafe(char, prevChar, inblock);
+          prevChar = char;
+        }
+      } else {
+        for (i = 0; i < string.length; char >= 65536 ? i += 2 : i++) {
+          char = codePointAt(string, i);
+          if (char === CHAR_LINE_FEED) {
+            hasLineBreak = true;
+            if (shouldTrackWidth) {
+              hasFoldableLine = hasFoldableLine || // Foldable line = too long, and not more-indented.
+              i - previousLineBreak - 1 > lineWidth && string[previousLineBreak + 1] !== " ";
+              previousLineBreak = i;
+            }
+          } 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] !== " ");
+      }
+      if (!hasLineBreak && !hasFoldableLine) {
+        if (plain && !forceQuotes && !testAmbiguousType(string)) {
+          return STYLE_PLAIN;
+        }
+        return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE;
+      }
+      if (indentPerLevel > 9 && needIndentIndicator(string)) {
+        return STYLE_DOUBLE;
+      }
+      if (!forceQuotes) {
+        return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL;
+      }
+      return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE;
+    }
+    function writeScalar(state, string, level, iskey, inblock, singleLO) {
+      state.dump = (function() {
+        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)) {
+            return state.quotingType === QUOTING_TYPE_DOUBLE ? '"' + string + '"' : "'" + string + "'";
+          }
+        }
+        var indent3 = state.indent * Math.max(1, level);
+        var lineWidth = state.lineWidth === -1 ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent3);
+        var singleLineOnly = iskey || singleLO || state.flowLevel > -1 && level >= state.flowLevel;
+        function testAmbiguity(string2) {
+          return testImplicitResolving(state, string2);
+        }
+        switch (chooseScalarStyle(
+          string,
+          singleLineOnly,
+          state.indent,
+          lineWidth,
+          testAmbiguity,
+          state.quotingType,
+          state.forceQuotes && !iskey,
+          inblock
+        )) {
+          case STYLE_PLAIN:
+            return string;
+          case STYLE_SINGLE:
+            return "'" + string.replace(/'/g, "''") + "'";
+          case STYLE_LITERAL:
+            return "|" + blockHeader(string, state.indent) + dropEndingNewline(indentString(string, indent3));
+          case STYLE_FOLDED:
+            return ">" + blockHeader(string, state.indent) + dropEndingNewline(indentString(foldString(string, lineWidth), indent3));
+          case STYLE_DOUBLE:
+            return '"' + escapeString(string, lineWidth) + '"';
+          default:
+            throw new YAMLException("impossible error: invalid scalar style");
+        }
+      })();
+    }
+    function blockHeader(string, indentPerLevel) {
+      var indentIndicator = needIndentIndicator(string) ? String(indentPerLevel) : "";
+      var clip = string[string.length - 1] === "\n";
+      var keep = clip && (string[string.length - 2] === "\n" || string === "\n");
+      var chomp = keep ? "+" : clip ? "" : "-";
+      return indentIndicator + chomp + "\n";
+    }
+    function dropEndingNewline(string) {
+      return string[string.length - 1] === "\n" ? string.slice(0, -1) : string;
+    }
+    function foldString(string, width) {
+      var lineRe = /(\n+)([^\n]*)/g;
+      var result = (function() {
+        var nextLF = string.indexOf("\n");
+        nextLF = nextLF !== -1 ? nextLF : string.length;
+        lineRe.lastIndex = nextLF;
+        return foldLine(string.slice(0, nextLF), width);
+      })();
+      var prevMoreIndented = string[0] === "\n" || string[0] === " ";
+      var moreIndented;
+      var match;
+      while (match = lineRe.exec(string)) {
+        var prefix = match[1], line3 = match[2];
+        moreIndented = line3[0] === " ";
+        result += prefix + (!prevMoreIndented && !moreIndented && line3 !== "" ? "\n" : "") + foldLine(line3, width);
+        prevMoreIndented = moreIndented;
+      }
+      return result;
+    }
+    function foldLine(line3, width) {
+      if (line3 === "" || line3[0] === " ") return line3;
+      var breakRe = / [^ ]/g;
+      var match;
+      var start = 0, end, curr = 0, next = 0;
+      var result = "";
+      while (match = breakRe.exec(line3)) {
+        next = match.index;
+        if (next - start > width) {
+          end = curr > start ? curr : next;
+          result += "\n" + line3.slice(start, end);
+          start = end + 1;
+        }
+        curr = next;
+      }
+      result += "\n";
+      if (line3.length - start > width && curr > start) {
+        result += line3.slice(start, curr) + "\n" + line3.slice(curr + 1);
+      } else {
+        result += line3.slice(start);
+      }
+      return result.slice(1);
+    }
+    function escapeString(string) {
+      var result = "";
+      var char = 0;
+      var escapeSeq;
+      for (var i = 0; i < string.length; char >= 65536 ? i += 2 : i++) {
+        char = codePointAt(string, i);
+        escapeSeq = ESCAPE_SEQUENCES[char];
+        if (!escapeSeq && isPrintable(char)) {
+          result += string[i];
+          if (char >= 65536) result += string[i + 1];
+        } else {
+          result += escapeSeq || encodeHex(char);
+        }
+      }
+      return result;
+    }
+    function writeFlowSequence(state, level, object) {
+      var _result = "", _tag = state.tag, index, length, value;
+      for (index = 0, length = object.length; index < length; index += 1) {
+        value = object[index];
+        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 ? " " : "");
+          _result += state.dump;
+        }
+      }
+      state.tag = _tag;
+      state.dump = "[" + _result + "]";
+    }
+    function writeBlockSequence(state, level, object, compact) {
+      var _result = "", _tag = state.tag, index, length, value;
+      for (index = 0, length = object.length; index < length; index += 1) {
+        value = object[index];
+        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 !== "") {
+            _result += generateNextLine(state, level);
+          }
+          if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
+            _result += "-";
           } else {
-            return removeFunction(fileOrDirName, next || function() {
-            });
+            _result += "- ";
           }
+          _result += state.dump;
         }
-      };
+      }
+      state.tag = _tag;
+      state.dump = _result || "[]";
     }
-    function _garbageCollector() {
-      if (!_gracefulCleanup) return;
-      while (_removeObjects.length) {
-        try {
-          _removeObjects[0]();
-        } catch (e7) {
+    function writeFlowMapping(state, level, object, singleLineOnly) {
+      var _result = "", _tag = state.tag, objectKeyList = Object.keys(object), index, length, objectKey, objectValue, pairBuffer;
+      for (index = 0, length = objectKeyList.length; index < length; index += 1) {
+        pairBuffer = "";
+        if (_result !== "") pairBuffer += ", ";
+        if (state.condenseFlow) pairBuffer += '"';
+        objectKey = objectKeyList[index];
+        objectValue = object[objectKey];
+        if (state.replacer) {
+          objectValue = state.replacer.call(object, objectKey, objectValue);
+        }
+        if (!writeNode(state, level, objectKey, false, false, singleLineOnly)) {
+          continue;
         }
+        if (state.dump.length > 1024) pairBuffer += "? ";
+        pairBuffer += state.dump + (state.condenseFlow ? '"' : "") + ":" + (state.condenseFlow ? "" : " ");
+        if (!writeNode(state, level, objectValue, false, false, singleLineOnly)) {
+          continue;
+        }
+        pairBuffer += state.dump;
+        _result += pairBuffer;
       }
+      state.tag = _tag;
+      state.dump = "{" + _result + "}";
     }
-    function _randomChars(howMany) {
-      let value = [], rnd = null;
-      try {
-        rnd = crypto.randomBytes(howMany);
-      } catch (e7) {
-        rnd = crypto.pseudoRandomBytes(howMany);
+    function writeBlockMapping(state, level, object, compact, doubleLine) {
+      var _result = "", _tag = state.tag, objectKeyList = Object.keys(object), index, length, objectKey, objectValue, explicitPair, pairBuffer;
+      if (state.sortKeys === true) {
+        objectKeyList.sort();
+      } 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");
       }
-      for (let i = 0; i < howMany; i++) {
-        value.push(RANDOM_CHARS[rnd[i] % RANDOM_CHARS.length]);
+      for (index = 0, length = objectKeyList.length; index < length; index += 1) {
+        pairBuffer = "";
+        if (!compact || _result !== "") {
+          pairBuffer += generateNextLine(state, level, doubleLine);
+        }
+        objectKey = objectKeyList[index];
+        objectValue = object[objectKey];
+        if (state.replacer) {
+          objectValue = state.replacer.call(object, objectKey, objectValue);
+        }
+        if (!writeNode(state, level + 1, objectKey, true, true, true)) {
+          continue;
+        }
+        explicitPair = state.tag !== null && state.tag !== "?" || state.dump && state.dump.length > 1024;
+        if (explicitPair) {
+          if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
+            pairBuffer += "?";
+          } else {
+            pairBuffer += "? ";
+          }
+        }
+        pairBuffer += state.dump;
+        if (explicitPair) {
+          pairBuffer += generateNextLine(state, level);
+        }
+        if (!writeNode(state, level + 1, objectValue, true, explicitPair, null, null, objectKey)) {
+          continue;
+        }
+        if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
+          pairBuffer += ":";
+        } else {
+          pairBuffer += ": ";
+        }
+        pairBuffer += state.dump;
+        _result += pairBuffer;
+      }
+      state.tag = _tag;
+      state.dump = _result || "{}";
+    }
+    function detectType(state, object, explicit) {
+      var _result, typeList, index, length, type, style;
+      typeList = explicit ? state.explicitTypes : state.implicitTypes;
+      for (index = 0, length = typeList.length; index < length; index += 1) {
+        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 {
+            state.tag = "?";
+          }
+          if (type.represent) {
+            style = state.styleMap[type.tag] || type.defaultStyle;
+            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');
+            }
+            state.dump = _result;
+          }
+          return true;
+        }
       }
-      return value.join("");
+      return false;
     }
-    function _isUndefined(obj) {
-      return typeof obj === "undefined";
+    function writeNode(state, level, object, block, compact, iskey, isblockseq, objectKey, singleLineOnly) {
+      state.tag = null;
+      state.dump = object;
+      if (!detectType(state, object, false)) {
+        detectType(state, object, true);
+      }
+      var type = _toString.call(state.dump);
+      var inblock = block;
+      var tagStr;
+      if (block) {
+        block = state.flowLevel < 0 || state.flowLevel > level;
+      }
+      var objectOrArray = type === "[object Object]" || type === "[object Array]", duplicateIndex, duplicate;
+      if (objectOrArray) {
+        duplicateIndex = state.duplicates.indexOf(object);
+        duplicate = duplicateIndex !== -1;
+      }
+      if (state.tag !== null && state.tag !== "?" || duplicate || state.indent !== 2 && level > 0) {
+        compact = false;
+      }
+      if (duplicate && state.usedDuplicates[duplicateIndex]) {
+        state.dump = "*ref_" + duplicateIndex;
+      } else {
+        if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) {
+          state.usedDuplicates[duplicateIndex] = true;
+        }
+        if (type === "[object Object]") {
+          singleLineOnly = SINGLE_LINE_KEYS[objectKey];
+          if (block && Object.keys(state.dump).length !== 0 && !singleLineOnly) {
+            var doubleLine = state.blankLines ? objectKey === "packages" || objectKey === "importers" || objectKey === "snapshots" || level === 0 : false;
+            writeBlockMapping(state, level, state.dump, compact, doubleLine);
+            if (duplicate) {
+              state.dump = "&ref_" + duplicateIndex + state.dump;
+            }
+          } else {
+            writeFlowMapping(state, level, state.dump, singleLineOnly);
+            if (duplicate) {
+              state.dump = "&ref_" + duplicateIndex + " " + state.dump;
+            }
+          }
+        } else if (type === "[object Array]") {
+          singleLineOnly = SINGLE_LINE_KEYS[objectKey];
+          if (block && state.dump.length !== 0 && !singleLineOnly) {
+            if (state.noArrayIndent && !isblockseq && level > 0) {
+              writeBlockSequence(state, level - 1, state.dump, compact);
+            } else {
+              writeBlockSequence(state, level, state.dump, compact);
+            }
+            if (duplicate) {
+              state.dump = "&ref_" + duplicateIndex + state.dump;
+            }
+          } else {
+            writeFlowSequence(state, level, state.dump, singleLineOnly);
+            if (duplicate) {
+              state.dump = "&ref_" + duplicateIndex + " " + state.dump;
+            }
+          }
+        } else if (type === "[object String]") {
+          if (state.tag !== "?") {
+            writeScalar(state, state.dump, level, iskey, inblock, singleLineOnly);
+          }
+        } else if (type === "[object Undefined]") {
+          return false;
+        } else {
+          if (state.skipInvalid) return false;
+          throw new YAMLException("unacceptable kind of an object to dump " + type);
+        }
+        if (state.tag !== null && state.tag !== "?") {
+          tagStr = encodeURI(
+            state.tag[0] === "!" ? state.tag.slice(1) : state.tag
+          ).replace(/!/g, "%21");
+          if (state.tag[0] === "!") {
+            tagStr = "!" + tagStr;
+          } else if (tagStr.slice(0, 18) === "tag:yaml.org,2002:") {
+            tagStr = "!!" + tagStr.slice(18);
+          } else {
+            tagStr = "!<" + tagStr + ">";
+          }
+          state.dump = tagStr + " " + state.dump;
+        }
+      }
+      return true;
     }
-    function _parseArguments(options8, callback) {
-      if (typeof options8 === "function") {
-        return [{}, options8];
+    function getDuplicateReferences(object, state) {
+      var objects = [], duplicatesIndexes = [], index, length;
+      inspectNode(object, objects, duplicatesIndexes);
+      for (index = 0, length = duplicatesIndexes.length; index < length; index += 1) {
+        state.duplicates.push(objects[duplicatesIndexes[index]]);
       }
-      if (_isUndefined(options8)) {
-        return [{}, callback];
+      state.usedDuplicates = new Array(length);
+    }
+    function inspectNode(object, objects, duplicatesIndexes) {
+      var objectKeyList, index, length;
+      if (object !== null && typeof object === "object") {
+        index = objects.indexOf(object);
+        if (index !== -1) {
+          if (duplicatesIndexes.indexOf(index) === -1) {
+            duplicatesIndexes.push(index);
+          }
+        } else {
+          objects.push(object);
+          if (Array.isArray(object)) {
+            for (index = 0, length = object.length; index < length; index += 1) {
+              inspectNode(object[index], objects, duplicatesIndexes);
+            }
+          } else {
+            objectKeyList = Object.keys(object);
+            for (index = 0, length = objectKeyList.length; index < length; index += 1) {
+              inspectNode(object[objectKeyList[index]], objects, duplicatesIndexes);
+            }
+          }
+        }
       }
-      const actualOptions = {};
-      for (const key2 of Object.getOwnPropertyNames(options8)) {
-        actualOptions[key2] = options8[key2];
+    }
+    function dump(input, options8) {
+      options8 = options8 || {};
+      var state = new State(options8);
+      if (!state.noRefs) getDuplicateReferences(input, state);
+      var value = input;
+      if (state.replacer) {
+        value = state.replacer.call({ "": value }, "", value);
       }
-      return [actualOptions, callback];
+      if (writeNode(state, 0, value, true, true)) return state.dump + "\n";
+      return "";
     }
-    function _resolvePath(name, tmpDir, cb2) {
-      const pathToResolve = path14.isAbsolute(name) ? name : path14.join(tmpDir, name);
-      fs8.stat(pathToResolve, function(err) {
-        if (err) {
-          fs8.realpath(path14.dirname(pathToResolve), function(err2, parentDir) {
-            if (err2) return cb2(err2);
-            cb2(null, path14.join(parentDir, path14.basename(pathToResolve)));
-          });
+    module2.exports.dump = dump;
+  }
+});
+
+// ../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/index.js
+var require_js_yaml = __commonJS({
+  "../../node_modules/.pnpm/@zkochan+js-yaml@0.0.7/node_modules/@zkochan/js-yaml/index.js"(exports2, module2) {
+    "use strict";
+    var loader = require_loader();
+    var dumper = require_dumper();
+    function renamed(from, to4) {
+      return function() {
+        throw new Error("Function yaml." + from + " is removed in js-yaml 4. Use yaml." + to4 + " instead, which is now safe by default.");
+      };
+    }
+    module2.exports.Type = require_type();
+    module2.exports.Schema = require_schema();
+    module2.exports.FAILSAFE_SCHEMA = require_failsafe();
+    module2.exports.JSON_SCHEMA = require_json();
+    module2.exports.CORE_SCHEMA = require_core();
+    module2.exports.DEFAULT_SCHEMA = require_default();
+    module2.exports.load = loader.load;
+    module2.exports.loadAll = loader.loadAll;
+    module2.exports.dump = dumper.dump;
+    module2.exports.YAMLException = require_exception();
+    module2.exports.safeLoad = renamed("safeLoad", "load");
+    module2.exports.safeLoadAll = renamed("safeLoadAll", "loadAll");
+    module2.exports.safeDump = renamed("safeDump", "dump");
+  }
+});
+
+// ../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/src/utils/catalog/pnpm-manager.js
+var require_pnpm_manager = __commonJS({
+  "../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/src/utils/catalog/pnpm-manager.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.PnpmCatalogManager = void 0;
+    var js_yaml_1 = require_js_yaml();
+    var node_fs_1 = require("fs");
+    var node_path_1 = require("path");
+    var devkit_exports_1 = require("nx/src/devkit-exports");
+    var devkit_internals_1 = require("nx/src/devkit-internals");
+    var PnpmCatalogManager = class {
+      constructor() {
+        this.name = "pnpm";
+        this.catalogProtocol = "catalog:";
+      }
+      isCatalogReference(version) {
+        return version.startsWith(this.catalogProtocol);
+      }
+      parseCatalogReference(version) {
+        if (!this.isCatalogReference(version)) {
+          return null;
+        }
+        const catalogName = version.substring(this.catalogProtocol.length);
+        const isDefault = !catalogName || catalogName === "default";
+        return {
+          catalogName: isDefault ? void 0 : catalogName,
+          isDefaultCatalog: isDefault
+        };
+      }
+      getCatalogDefinitions(treeOrRoot) {
+        if (typeof treeOrRoot === "string") {
+          const pnpmWorkspacePath = (0, node_path_1.join)(treeOrRoot, "pnpm-workspace.yaml");
+          if (!(0, node_fs_1.existsSync)(pnpmWorkspacePath)) {
+            return null;
+          }
+          return readYamlFileFromFs(pnpmWorkspacePath);
+        } else {
+          if (!treeOrRoot.exists("pnpm-workspace.yaml")) {
+            return null;
+          }
+          return readYamlFileFromTree(treeOrRoot, "pnpm-workspace.yaml");
+        }
+      }
+      resolveCatalogReference(treeOrRoot, packageName, version) {
+        const catalogRef = this.parseCatalogReference(version);
+        if (!catalogRef) {
+          return null;
+        }
+        const workspaceConfig = this.getCatalogDefinitions(treeOrRoot);
+        if (!workspaceConfig) {
+          return null;
+        }
+        let catalogToUse;
+        if (catalogRef.isDefaultCatalog) {
+          catalogToUse = workspaceConfig.catalog ?? workspaceConfig.catalogs?.default;
+        } else if (catalogRef.catalogName) {
+          catalogToUse = workspaceConfig.catalogs?.[catalogRef.catalogName];
+        }
+        return catalogToUse?.[packageName] || null;
+      }
+      validateCatalogReference(treeOrRoot, packageName, version) {
+        const catalogRef = this.parseCatalogReference(version);
+        if (!catalogRef) {
+          throw new Error(`Invalid catalog reference syntax: "${version}". Expected format: "catalog:" or "catalog:name"`);
+        }
+        const workspaceConfig = this.getCatalogDefinitions(treeOrRoot);
+        if (!workspaceConfig) {
+          throw new Error(formatCatalogError("Cannot get Pnpm Catalog definitions. No pnpm-workspace.yaml found in workspace root.", ["Create a pnpm-workspace.yaml file in your workspace root"]));
+        }
+        let catalogToUse;
+        if (catalogRef.isDefaultCatalog) {
+          const hasCatalog = !!workspaceConfig.catalog;
+          const hasCatalogsDefault = !!workspaceConfig.catalogs?.default;
+          if (hasCatalog && hasCatalogsDefault) {
+            throw new Error("The 'default' catalog was defined multiple times. Use the 'catalog' field or 'catalogs.default', but not both.");
+          }
+          catalogToUse = workspaceConfig.catalog ?? workspaceConfig.catalogs?.default;
+          if (!catalogToUse) {
+            const availableCatalogs = Object.keys(workspaceConfig.catalogs || {});
+            const suggestions = [
+              'Define a default catalog in pnpm-workspace.yaml under the "catalog" key'
+            ];
+            if (availableCatalogs.length > 0) {
+              suggestions.push(`Or select from the available named catalogs: ${availableCatalogs.map((c5) => `"catalog:${c5}"`).join(", ")}`);
+            }
+            throw new Error(formatCatalogError("No default catalog defined in pnpm-workspace.yaml", suggestions));
+          }
+        } else if (catalogRef.catalogName) {
+          catalogToUse = workspaceConfig.catalogs?.[catalogRef.catalogName];
+          if (!catalogToUse) {
+            const availableCatalogs = Object.keys(workspaceConfig.catalogs || {}).filter((c5) => c5 !== "default");
+            const defaultCatalog = !!workspaceConfig.catalog ? "catalog" : !workspaceConfig.catalogs?.default ? "catalogs.default" : null;
+            const suggestions = [
+              'Define the catalog in pnpm-workspace.yaml under the "catalogs" key'
+            ];
+            if (availableCatalogs.length > 0) {
+              suggestions.push(`Or select from the available named catalogs: ${availableCatalogs.map((c5) => `"catalog:${c5}"`).join(", ")}`);
+            }
+            if (defaultCatalog) {
+              suggestions.push(`Or use the default catalog ("${defaultCatalog}")`);
+            }
+            throw new Error(formatCatalogError(`Catalog "${catalogRef.catalogName}" not found in pnpm-workspace.yaml`, suggestions));
+          }
+        }
+        if (!catalogToUse[packageName]) {
+          let catalogName;
+          if (catalogRef.isDefaultCatalog) {
+            const hasCatalog = !!workspaceConfig.catalog;
+            catalogName = hasCatalog ? 'default catalog ("catalog")' : 'default catalog ("catalogs.default")';
+          } else {
+            catalogName = `catalog '${catalogRef.catalogName}'`;
+          }
+          const availablePackages = Object.keys(catalogToUse);
+          const suggestions = [
+            `Add "${packageName}" to ${catalogName} in pnpm-workspace.yaml`
+          ];
+          if (availablePackages.length > 0) {
+            suggestions.push(`Or select from the available packages in ${catalogName}: ${availablePackages.map((p5) => `"${p5}"`).join(", ")}`);
+          }
+          throw new Error(formatCatalogError(`Package "${packageName}" not found in ${catalogName}`, suggestions));
+        }
+      }
+      updateCatalogVersions(treeOrRoot, updates) {
+        let checkExists;
+        let readYaml;
+        let writeYaml;
+        if (typeof treeOrRoot === "string") {
+          const workspaceYamlPath = (0, node_path_1.join)(treeOrRoot, "pnpm-workspace.yaml");
+          checkExists = () => (0, node_fs_1.existsSync)(workspaceYamlPath);
+          readYaml = () => (0, node_fs_1.readFileSync)(workspaceYamlPath, "utf-8");
+          writeYaml = (content) => (0, node_fs_1.writeFileSync)(workspaceYamlPath, content, "utf-8");
         } else {
-          fs8.realpath(pathToResolve, cb2);
+          checkExists = () => treeOrRoot.exists("pnpm-workspace.yaml");
+          readYaml = () => treeOrRoot.read("pnpm-workspace.yaml", "utf-8");
+          writeYaml = (content) => treeOrRoot.write("pnpm-workspace.yaml", content);
+        }
+        if (!checkExists()) {
+          devkit_exports_1.output.warn({
+            title: "No pnpm-workspace.yaml found",
+            bodyLines: [
+              "Cannot update catalog versions without a pnpm-workspace.yaml file.",
+              "Create a pnpm-workspace.yaml file to use catalogs."
+            ]
+          });
+          return;
+        }
+        try {
+          const workspaceContent = readYaml();
+          const workspaceData = (0, js_yaml_1.load)(workspaceContent) || {};
+          let hasChanges = false;
+          for (const update of updates) {
+            const { packageName, version, catalogName } = update;
+            const normalizedCatalogName = catalogName === "default" ? void 0 : catalogName;
+            let targetCatalog;
+            if (!normalizedCatalogName) {
+              if (workspaceData.catalog) {
+                targetCatalog = workspaceData.catalog;
+              } else if (workspaceData.catalogs?.default) {
+                targetCatalog = workspaceData.catalogs.default;
+              } else {
+                workspaceData.catalog ??= {};
+                targetCatalog = workspaceData.catalog;
+              }
+            } else {
+              workspaceData.catalogs ??= {};
+              workspaceData.catalogs[normalizedCatalogName] ??= {};
+              targetCatalog = workspaceData.catalogs[normalizedCatalogName];
+            }
+            if (targetCatalog[packageName] !== version) {
+              targetCatalog[packageName] = version;
+              hasChanges = true;
+            }
+          }
+          if (hasChanges) {
+            writeYaml((0, js_yaml_1.dump)(workspaceData, {
+              indent: 2,
+              quotingType: '"',
+              forceQuotes: true
+            }));
+          }
+        } catch (error) {
+          devkit_exports_1.output.error({
+            title: "Failed to update catalog versions",
+            bodyLines: [error instanceof Error ? error.message : String(error)]
+          });
+          throw error;
         }
-      });
-    }
-    function _resolvePathSync(name, tmpDir) {
-      const pathToResolve = path14.isAbsolute(name) ? name : path14.join(tmpDir, name);
+      }
+    };
+    exports2.PnpmCatalogManager = PnpmCatalogManager;
+    function readYamlFileFromFs(path14) {
       try {
-        fs8.statSync(pathToResolve);
-        return fs8.realpathSync(pathToResolve);
-      } catch (_err) {
-        const parentDir = fs8.realpathSync(path14.dirname(pathToResolve));
-        return path14.join(parentDir, path14.basename(pathToResolve));
-      }
-    }
-    function _generateTmpName(opts) {
-      const tmpDir = opts.tmpdir;
-      if (!_isUndefined(opts.name)) {
-        return path14.join(tmpDir, opts.dir, opts.name);
-      }
-      if (!_isUndefined(opts.template)) {
-        return path14.join(tmpDir, opts.dir, opts.template).replace(TEMPLATE_PATTERN, _randomChars(6));
-      }
-      const name = [
-        opts.prefix ? opts.prefix : "tmp",
-        "-",
-        process.pid,
-        "-",
-        _randomChars(12),
-        opts.postfix ? "-" + opts.postfix : ""
-      ].join("");
-      return path14.join(tmpDir, opts.dir, name);
-    }
-    function _assertOptionsBase(options8) {
-      if (!_isUndefined(options8.name)) {
-        const name = options8.name;
-        if (path14.isAbsolute(name)) throw new Error(`name option must not contain an absolute path, found "${name}".`);
-        const basename = path14.basename(name);
-        if (basename === ".." || basename === "." || basename !== name)
-          throw new Error(`name option must not contain a path, found "${name}".`);
-      }
-      if (!_isUndefined(options8.template) && !options8.template.match(TEMPLATE_PATTERN)) {
-        throw new Error(`Invalid template, found "${options8.template}".`);
-      }
-      if (!_isUndefined(options8.tries) && isNaN(options8.tries) || options8.tries < 0) {
-        throw new Error(`Invalid tries, found "${options8.tries}".`);
-      }
-      options8.tries = _isUndefined(options8.name) ? options8.tries || DEFAULT_TRIES : 1;
-      options8.keep = !!options8.keep;
-      options8.detachDescriptor = !!options8.detachDescriptor;
-      options8.discardDescriptor = !!options8.discardDescriptor;
-      options8.unsafeCleanup = !!options8.unsafeCleanup;
-      options8.prefix = _isUndefined(options8.prefix) ? "" : options8.prefix;
-      options8.postfix = _isUndefined(options8.postfix) ? "" : options8.postfix;
-    }
-    function _getRelativePath(option, name, tmpDir, cb2) {
-      if (_isUndefined(name)) return cb2(null);
-      _resolvePath(name, tmpDir, function(err, resolvedPath) {
-        if (err) return cb2(err);
-        const relativePath = path14.relative(tmpDir, resolvedPath);
-        if (!resolvedPath.startsWith(tmpDir)) {
-          return cb2(new Error(`${option} option must be relative to "${tmpDir}", found "${relativePath}".`));
-        }
-        cb2(null, relativePath);
-      });
-    }
-    function _getRelativePathSync(option, name, tmpDir) {
-      if (_isUndefined(name)) return;
-      const resolvedPath = _resolvePathSync(name, tmpDir);
-      const relativePath = path14.relative(tmpDir, resolvedPath);
-      if (!resolvedPath.startsWith(tmpDir)) {
-        throw new Error(`${option} option must be relative to "${tmpDir}", found "${relativePath}".`);
+        return (0, devkit_internals_1.readYamlFile)(path14);
+      } catch (error) {
+        devkit_exports_1.output.warn({
+          title: "Unable to parse pnpm-workspace.yaml",
+          bodyLines: [error.toString()]
+        });
+        return null;
       }
-      return relativePath;
     }
-    function _assertAndSanitizeOptions(options8, cb2) {
-      _getTmpDir(options8, function(err, tmpDir) {
-        if (err) return cb2(err);
-        options8.tmpdir = tmpDir;
-        try {
-          _assertOptionsBase(options8, tmpDir);
-        } catch (err2) {
-          return cb2(err2);
-        }
-        _getRelativePath("dir", options8.dir, tmpDir, function(err2, dir2) {
-          if (err2) return cb2(err2);
-          options8.dir = _isUndefined(dir2) ? "" : dir2;
-          _getRelativePath("template", options8.template, tmpDir, function(err3, template) {
-            if (err3) return cb2(err3);
-            options8.template = template;
-            cb2(null, options8);
-          });
+    function readYamlFileFromTree(tree, path14) {
+      const content = tree.read(path14, "utf-8");
+      const { load } = require_js_yaml();
+      try {
+        return load(content, { filename: path14 });
+      } catch (error) {
+        devkit_exports_1.output.warn({
+          title: "Unable to parse pnpm-workspace.yaml",
+          bodyLines: [error.toString()]
         });
-      });
-    }
-    function _assertAndSanitizeOptionsSync(options8) {
-      const tmpDir = options8.tmpdir = _getTmpDirSync(options8);
-      _assertOptionsBase(options8, tmpDir);
-      const dir2 = _getRelativePathSync("dir", options8.dir, tmpDir);
-      options8.dir = _isUndefined(dir2) ? "" : dir2;
-      options8.template = _getRelativePathSync("template", options8.template, tmpDir);
-      return options8;
-    }
-    function _isEBADF(error) {
-      return _isExpectedError(error, -EBADF, "EBADF");
-    }
-    function _isENOENT(error) {
-      return _isExpectedError(error, -ENOENT, "ENOENT");
-    }
-    function _isExpectedError(error, errno, code) {
-      return IS_WIN32 ? error.code === code : error.code === code && error.errno === errno;
-    }
-    function setGracefulCleanup() {
-      _gracefulCleanup = true;
+        return null;
+      }
     }
-    function _getTmpDir(options8, cb2) {
-      return fs8.realpath(options8 && options8.tmpdir || os8.tmpdir(), cb2);
+    function formatCatalogError(error, suggestions) {
+      let message = error;
+      if (suggestions && suggestions.length > 0) {
+        message += "\n\nSuggestions:";
+        suggestions.forEach((suggestion) => {
+          message += `
+  \u2022 ${suggestion}`;
+        });
+      }
+      return message;
     }
-    function _getTmpDirSync(options8) {
-      return fs8.realpathSync(options8 && options8.tmpdir || os8.tmpdir());
+  }
+});
+
+// ../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/src/utils/catalog/manager-factory.js
+var require_manager_factory = __commonJS({
+  "../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/src/utils/catalog/manager-factory.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.getCatalogManager = getCatalogManager;
+    var devkit_exports_1 = require("nx/src/devkit-exports");
+    var pnpm_manager_1 = require_pnpm_manager();
+    function getCatalogManager(workspaceRoot) {
+      const packageManager = (0, devkit_exports_1.detectPackageManager)(workspaceRoot);
+      switch (packageManager) {
+        case "pnpm":
+          return new pnpm_manager_1.PnpmCatalogManager();
+        default:
+          return null;
+      }
     }
-    process.addListener(EXIT, _garbageCollector);
-    Object.defineProperty(module2.exports, "tmpdir", {
-      enumerable: true,
-      configurable: false,
-      get: function() {
-        return _getTmpDirSync();
+  }
+});
+
+// ../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/src/utils/catalog/index.js
+var require_catalog = __commonJS({
+  "../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/src/utils/catalog/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.getCatalogManager = void 0;
+    exports2.getCatalogDependenciesFromPackageJson = getCatalogDependenciesFromPackageJson;
+    var devkit_exports_1 = require("nx/src/devkit-exports");
+    var manager_factory_1 = require_manager_factory();
+    Object.defineProperty(exports2, "getCatalogManager", { enumerable: true, get: function() {
+      return manager_factory_1.getCatalogManager;
+    } });
+    function getCatalogDependenciesFromPackageJson(tree, packageJsonPath, manager) {
+      const catalogDeps = /* @__PURE__ */ new Map();
+      if (!tree.exists(packageJsonPath)) {
+        return catalogDeps;
       }
-    });
-    module2.exports.dir = dir;
-    module2.exports.dirSync = dirSync;
-    module2.exports.file = file;
-    module2.exports.fileSync = fileSync;
-    module2.exports.tmpName = tmpName;
-    module2.exports.tmpNameSync = tmpNameSync;
-    module2.exports.setGracefulCleanup = setGracefulCleanup;
+      try {
+        const packageJson = (0, devkit_exports_1.readJson)(tree, packageJsonPath);
+        const allDependencies = {
+          ...packageJson.dependencies,
+          ...packageJson.devDependencies,
+          ...packageJson.peerDependencies,
+          ...packageJson.optionalDependencies
+        };
+        for (const [packageName, version] of Object.entries(allDependencies || {})) {
+          if (manager.isCatalogReference(version)) {
+            const catalogRef = manager.parseCatalogReference(version);
+            if (catalogRef) {
+              catalogDeps.set(packageName, catalogRef.catalogName);
+            }
+          }
+        }
+      } catch (error) {
+      }
+      return catalogDeps;
+    }
   }
 });
 
-// ../../node_modules/.pnpm/@nx+devkit@21.5.2_nx@21.5.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_c4b3329f377a274c25d9c6b2b666ae22/node_modules/@nx/devkit/src/utils/package-json.js
+// ../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/src/utils/package-json.js
 var require_package_json = __commonJS({
-  "../../node_modules/.pnpm/@nx+devkit@21.5.2_nx@21.5.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_c4b3329f377a274c25d9c6b2b666ae22/node_modules/@nx/devkit/src/utils/package-json.js"(exports2) {
+  "../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/src/utils/package-json.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.NX_VERSION = void 0;
+    exports2.getDependencyVersionFromPackageJson = getDependencyVersionFromPackageJson;
     exports2.addDependenciesToPackageJson = addDependenciesToPackageJson;
     exports2.removeDependenciesFromPackageJson = removeDependenciesFromPackageJson;
     exports2.ensurePackage = ensurePackage;
-    var child_process_1 = require("child_process");
+    var fs_1 = require("fs");
     var module_1 = require("module");
-    var semver_1 = require_semver3();
-    var install_packages_task_1 = require_install_packages_task();
-    var tmp_1 = require_tmp();
-    var path_1 = require("path");
     var devkit_exports_1 = require("nx/src/devkit-exports");
     var devkit_internals_1 = require("nx/src/devkit-internals");
-    var fs_1 = require("fs");
+    var path_1 = require("path");
+    var semver_1 = require_semver3();
+    var install_packages_task_1 = require_install_packages_task();
+    var catalog_1 = require_catalog();
     var UNIDENTIFIED_VERSION = "UNIDENTIFIED_VERSION";
     var NON_SEMVER_TAGS = {
       "*": 2,
@@ -106210,44 +108929,123 @@ var require_package_json = __commonJS({
       previous: -1,
       legacy: -2
     };
+    function getDependencyVersionFromPackageJson(treeOrPackageName, packageNameOrRoot, packageJsonPathOrObjectOrRoot, dependencyLookup) {
+      if (typeof treeOrPackageName !== "string") {
+        return getDependencyVersionFromPackageJsonFromTree(treeOrPackageName, packageNameOrRoot, packageJsonPathOrObjectOrRoot, dependencyLookup);
+      } else {
+        return getDependencyVersionFromPackageJsonFromFileSystem(treeOrPackageName, packageNameOrRoot, packageJsonPathOrObjectOrRoot, dependencyLookup);
+      }
+    }
+    function getDependencyVersionFromPackageJsonFromTree(tree, packageName, packageJsonPathOrObject = "package.json", dependencyLookup = [
+      "dependencies",
+      "devDependencies"
+    ]) {
+      let packageJson;
+      if (typeof packageJsonPathOrObject === "object") {
+        packageJson = packageJsonPathOrObject;
+      } else if (tree.exists(packageJsonPathOrObject)) {
+        packageJson = (0, devkit_exports_1.readJson)(tree, packageJsonPathOrObject);
+      } else {
+        return null;
+      }
+      let version = null;
+      for (const section of dependencyLookup) {
+        const foundVersion = packageJson[section]?.[packageName];
+        if (foundVersion) {
+          version = foundVersion;
+          break;
+        }
+      }
+      const manager = (0, catalog_1.getCatalogManager)(tree.root);
+      if (version && manager?.isCatalogReference(version)) {
+        version = manager.resolveCatalogReference(tree, packageName, version);
+      }
+      return version;
+    }
+    function getDependencyVersionFromPackageJsonFromFileSystem(packageName, root2 = devkit_exports_1.workspaceRoot, packageJsonPathOrObject = "package.json", dependencyLookup = [
+      "dependencies",
+      "devDependencies"
+    ]) {
+      let packageJson;
+      if (typeof packageJsonPathOrObject === "object") {
+        packageJson = packageJsonPathOrObject;
+      } else {
+        const packageJsonPath = (0, path_1.resolve)(root2, packageJsonPathOrObject);
+        if ((0, fs_1.existsSync)(packageJsonPath)) {
+          packageJson = (0, devkit_exports_1.readJsonFile)(packageJsonPath);
+        } else {
+          return null;
+        }
+      }
+      let version = null;
+      for (const section of dependencyLookup) {
+        const foundVersion = packageJson[section]?.[packageName];
+        if (foundVersion) {
+          version = foundVersion;
+          break;
+        }
+      }
+      const manager = (0, catalog_1.getCatalogManager)(root2);
+      if (version && manager?.isCatalogReference(version)) {
+        version = manager.resolveCatalogReference(root2, packageName, version);
+      }
+      return version;
+    }
     function filterExistingDependencies(dependencies, existingAltDependencies) {
       if (!existingAltDependencies) {
         return dependencies;
       }
       return Object.keys(dependencies ?? {}).filter((d7) => !existingAltDependencies[d7]).reduce((acc, d7) => ({ ...acc, [d7]: dependencies[d7] }), {});
     }
-    function cleanSemver(version) {
+    function cleanSemver(tree, version, packageName) {
+      const manager = (0, catalog_1.getCatalogManager)(tree.root);
+      if (manager?.isCatalogReference(version)) {
+        const resolvedVersion = manager.resolveCatalogReference(tree, packageName, version);
+        if (!resolvedVersion) {
+          throw new Error(`Failed to resolve catalog reference '${version}' for package '${packageName}'`);
+        }
+        return (0, semver_1.clean)(resolvedVersion) ?? (0, semver_1.coerce)(resolvedVersion);
+      }
       return (0, semver_1.clean)(version) ?? (0, semver_1.coerce)(version);
     }
-    function isIncomingVersionGreater(incomingVersion, existingVersion) {
-      const incomingVersionCompareBy = incomingVersion in NON_SEMVER_TAGS ? incomingVersion : cleanSemver(incomingVersion)?.toString() ?? UNIDENTIFIED_VERSION;
-      const existingVersionCompareBy = existingVersion in NON_SEMVER_TAGS ? existingVersion : cleanSemver(existingVersion)?.toString() ?? UNIDENTIFIED_VERSION;
+    function isIncomingVersionGreater(tree, incomingVersion, existingVersion, packageName) {
+      let resolvedExistingVersion = existingVersion;
+      const manager = (0, catalog_1.getCatalogManager)(tree.root);
+      if (manager?.isCatalogReference(existingVersion)) {
+        const resolved = manager.resolveCatalogReference(tree, packageName, existingVersion);
+        if (!resolved) {
+          throw new Error(`Failed to resolve catalog reference '${existingVersion}' for package '${packageName}'`);
+        }
+        resolvedExistingVersion = resolved;
+      }
+      const incomingVersionCompareBy = incomingVersion in NON_SEMVER_TAGS ? incomingVersion : cleanSemver(tree, incomingVersion, packageName)?.toString() ?? UNIDENTIFIED_VERSION;
+      const existingVersionCompareBy = resolvedExistingVersion in NON_SEMVER_TAGS ? resolvedExistingVersion : cleanSemver(tree, resolvedExistingVersion, packageName)?.toString() ?? UNIDENTIFIED_VERSION;
       if (incomingVersionCompareBy in NON_SEMVER_TAGS && existingVersionCompareBy in NON_SEMVER_TAGS) {
         return NON_SEMVER_TAGS[incomingVersionCompareBy] > NON_SEMVER_TAGS[existingVersionCompareBy];
       }
       if (incomingVersionCompareBy in NON_SEMVER_TAGS || existingVersionCompareBy in NON_SEMVER_TAGS) {
         return true;
       }
-      return (0, semver_1.gt)(cleanSemver(incomingVersion), cleanSemver(existingVersion));
+      return (0, semver_1.gt)(cleanSemver(tree, incomingVersion, packageName), cleanSemver(tree, resolvedExistingVersion, packageName));
     }
-    function updateExistingAltDependenciesVersion(dependencies, existingAltDependencies) {
+    function updateExistingAltDependenciesVersion(tree, dependencies, existingAltDependencies, workspaceRootPath) {
       return Object.keys(existingAltDependencies || {}).filter((d7) => {
         if (!dependencies[d7]) {
           return false;
         }
         const incomingVersion = dependencies[d7];
         const existingVersion = existingAltDependencies[d7];
-        return isIncomingVersionGreater(incomingVersion, existingVersion);
+        return isIncomingVersionGreater(tree, incomingVersion, existingVersion, d7);
       }).reduce((acc, d7) => ({ ...acc, [d7]: dependencies[d7] }), {});
     }
-    function updateExistingDependenciesVersion(dependencies, existingDependencies = {}) {
+    function updateExistingDependenciesVersion(tree, dependencies, existingDependencies = {}, workspaceRootPath) {
       return Object.keys(dependencies).filter((d7) => {
         if (!existingDependencies[d7]) {
           return true;
         }
         const incomingVersion = dependencies[d7];
         const existingVersion = existingDependencies[d7];
-        return isIncomingVersionGreater(incomingVersion, existingVersion);
+        return isIncomingVersionGreater(tree, incomingVersion, existingVersion, d7);
       }).reduce((acc, d7) => ({ ...acc, [d7]: dependencies[d7] }), {});
     }
     function addDependenciesToPackageJson(tree, dependencies, devDependencies, packageJsonPath = "package.json", keepExistingVersions) {
@@ -106255,34 +109053,24 @@ var require_package_json = __commonJS({
       let filteredDependencies = filterExistingDependencies(dependencies, currentPackageJson.devDependencies);
       let filteredDevDependencies = filterExistingDependencies(devDependencies, currentPackageJson.dependencies);
       filteredDependencies = {
-        ...updateExistingDependenciesVersion(filteredDependencies, currentPackageJson.dependencies),
-        ...updateExistingAltDependenciesVersion(devDependencies, currentPackageJson.dependencies)
+        ...updateExistingDependenciesVersion(tree, filteredDependencies, currentPackageJson.dependencies, tree.root),
+        ...updateExistingAltDependenciesVersion(tree, devDependencies, currentPackageJson.dependencies, tree.root)
       };
       filteredDevDependencies = {
-        ...updateExistingDependenciesVersion(filteredDevDependencies, currentPackageJson.devDependencies),
-        ...updateExistingAltDependenciesVersion(dependencies, currentPackageJson.devDependencies)
+        ...updateExistingDependenciesVersion(tree, filteredDevDependencies, currentPackageJson.devDependencies, tree.root),
+        ...updateExistingAltDependenciesVersion(tree, dependencies, currentPackageJson.devDependencies, tree.root)
       };
       if (keepExistingVersions) {
         filteredDependencies = removeExistingDependencies(filteredDependencies, currentPackageJson.dependencies);
         filteredDevDependencies = removeExistingDependencies(filteredDevDependencies, currentPackageJson.devDependencies);
       } else {
-        filteredDependencies = removeLowerVersions(filteredDependencies, currentPackageJson.dependencies);
-        filteredDevDependencies = removeLowerVersions(filteredDevDependencies, currentPackageJson.devDependencies);
+        filteredDependencies = removeLowerVersions(tree, filteredDependencies, currentPackageJson.dependencies, tree.root);
+        filteredDevDependencies = removeLowerVersions(tree, filteredDevDependencies, currentPackageJson.devDependencies, tree.root);
       }
-      if (requiresAddingOfPackages(currentPackageJson, filteredDependencies, filteredDevDependencies)) {
-        (0, devkit_exports_1.updateJson)(tree, packageJsonPath, (json) => {
-          json.dependencies = {
-            ...json.dependencies || {},
-            ...filteredDependencies
-          };
-          json.devDependencies = {
-            ...json.devDependencies || {},
-            ...filteredDevDependencies
-          };
-          json.dependencies = sortObjectByKeys(json.dependencies);
-          json.devDependencies = sortObjectByKeys(json.devDependencies);
-          return json;
-        });
+      if (requiresAddingOfPackages(tree, currentPackageJson, filteredDependencies, filteredDevDependencies, tree.root)) {
+        const { catalogUpdates, directDependencies, directDevDependencies } = splitDependenciesByCatalogType(tree, filteredDependencies, filteredDevDependencies, packageJsonPath);
+        writeCatalogDependencies(tree, catalogUpdates);
+        writeDirectDependencies(tree, packageJsonPath, directDependencies, directDevDependencies);
         return () => {
           (0, install_packages_task_1.installPackagesTask)(tree);
         };
@@ -106290,9 +109078,79 @@ var require_package_json = __commonJS({
       return () => {
       };
     }
-    function removeLowerVersions(incomingDeps, existingDeps) {
+    function splitDependenciesByCatalogType(tree, filteredDependencies, filteredDevDependencies, packageJsonPath) {
+      const allFilteredUpdates = {
+        ...filteredDependencies,
+        ...filteredDevDependencies
+      };
+      const catalogUpdates = [];
+      let directDependencies = { ...filteredDependencies };
+      let directDevDependencies = { ...filteredDevDependencies };
+      const manager = (0, catalog_1.getCatalogManager)(tree.root);
+      if (!manager) {
+        return {
+          catalogUpdates: [],
+          directDependencies: filteredDependencies,
+          directDevDependencies: filteredDevDependencies
+        };
+      }
+      const existingCatalogDeps = (0, catalog_1.getCatalogDependenciesFromPackageJson)(tree, packageJsonPath, manager);
+      if (!existingCatalogDeps.size) {
+        return {
+          catalogUpdates: [],
+          directDependencies: filteredDependencies,
+          directDevDependencies: filteredDevDependencies
+        };
+      }
+      for (const [packageName, version] of Object.entries(allFilteredUpdates)) {
+        if (!existingCatalogDeps.has(packageName)) {
+          continue;
+        }
+        let catalogName = existingCatalogDeps.get(packageName);
+        const catalogRef = catalogName ? `catalog:${catalogName}` : "catalog:";
+        try {
+          manager.validateCatalogReference(tree, packageName, catalogRef);
+          catalogUpdates.push({ packageName, version, catalogName });
+          delete directDependencies[packageName];
+          delete directDevDependencies[packageName];
+        } catch (error) {
+          devkit_exports_1.output.error({
+            title: "Invalid catalog reference",
+            bodyLines: [
+              `Invalid catalog reference "${catalogRef}" for package "${packageName}".`,
+              error.message
+            ]
+          });
+          throw new Error(`Could not update "${packageName}" to version "${version}". See above for more details.`);
+        }
+      }
+      return { catalogUpdates, directDependencies, directDevDependencies };
+    }
+    function writeCatalogDependencies(tree, catalogUpdates) {
+      if (!catalogUpdates.length) {
+        return;
+      }
+      const manager = (0, catalog_1.getCatalogManager)(tree.root);
+      manager.updateCatalogVersions(tree, catalogUpdates);
+    }
+    function writeDirectDependencies(tree, packageJsonPath, dependencies, devDependencies) {
+      (0, devkit_exports_1.updateJson)(tree, packageJsonPath, (json) => {
+        json.dependencies = {
+          ...json.dependencies || {},
+          ...dependencies
+        };
+        json.devDependencies = {
+          ...json.devDependencies || {},
+          ...devDependencies
+        };
+        json.dependencies = sortObjectByKeys(json.dependencies);
+        json.devDependencies = sortObjectByKeys(json.devDependencies);
+        return json;
+      });
+    }
+    function removeLowerVersions(tree, incomingDeps, existingDeps, workspaceRootPath) {
       return Object.keys(incomingDeps).reduce((acc, d7) => {
-        if (!existingDeps?.[d7] || isIncomingVersionGreater(incomingDeps[d7], existingDeps[d7])) {
+        if (!existingDeps?.[d7] || isIncomingVersionGreater(tree, incomingDeps[d7], existingDeps[d7], d7)) {
           acc[d7] = incomingDeps[d7];
         }
         return acc;
@@ -106340,7 +109198,7 @@ var require_package_json = __commonJS({
         };
       }, {});
     }
-    function requiresAddingOfPackages(packageJsonFile, deps, devDeps) {
+    function requiresAddingOfPackages(tree, packageJsonFile, deps, devDeps, workspaceRootPath) {
       let needsDepsUpdate = false;
       let needsDevDepsUpdate = false;
       packageJsonFile.dependencies = packageJsonFile.dependencies || {};
@@ -106350,11 +109208,11 @@ var require_package_json = __commonJS({
           const incomingVersion = deps[entry];
           if (packageJsonFile.dependencies[entry]) {
             const existingVersion = packageJsonFile.dependencies[entry];
-            return isIncomingVersionGreater(incomingVersion, existingVersion);
+            return isIncomingVersionGreater(tree, incomingVersion, existingVersion, entry);
           }
           if (packageJsonFile.devDependencies[entry]) {
             const existingVersion = packageJsonFile.devDependencies[entry];
-            return isIncomingVersionGreater(incomingVersion, existingVersion);
+            return isIncomingVersionGreater(tree, incomingVersion, existingVersion, entry);
           }
           return true;
         });
@@ -106364,11 +109222,11 @@ var require_package_json = __commonJS({
           const incomingVersion = devDeps[entry];
           if (packageJsonFile.devDependencies[entry]) {
             const existingVersion = packageJsonFile.devDependencies[entry];
-            return isIncomingVersionGreater(incomingVersion, existingVersion);
+            return isIncomingVersionGreater(tree, incomingVersion, existingVersion, entry);
           }
           if (packageJsonFile.dependencies[entry]) {
             const existingVersion = packageJsonFile.dependencies[entry];
-            return isIncomingVersionGreater(incomingVersion, existingVersion);
+            return isIncomingVersionGreater(tree, incomingVersion, existingVersion, entry);
           }
           return true;
         });
@@ -106414,31 +109272,7 @@ var require_package_json = __commonJS({
       if (process.env.NX_DRY_RUN && process.env.NX_DRY_RUN !== "false") {
         throw new Error('NOTE: This generator does not support --dry-run. If you are running this in Nx Console, it should execute fine once you hit the "Generate" button.\n');
       }
-      const { dir: tempDir } = (0, devkit_internals_1.createTempNpmDirectory)?.() ?? {
-        dir: (0, tmp_1.dirSync)().name
-      };
-      console.log(`Fetching ${pkg}...`);
-      const packageManager = (0, devkit_exports_1.detectPackageManager)();
-      const isVerbose = process.env.NX_VERBOSE_LOGGING === "true";
-      generatePackageManagerFiles(tempDir, packageManager);
-      const preInstallCommand = (0, devkit_exports_1.getPackageManagerCommand)(packageManager).preInstall;
-      if (preInstallCommand) {
-        (0, child_process_1.execSync)(preInstallCommand, {
-          cwd: tempDir,
-          stdio: isVerbose ? "inherit" : "ignore",
-          windowsHide: false
-        });
-      }
-      const pmCommands = (0, devkit_exports_1.getPackageManagerCommand)(packageManager);
-      let addCommand = pmCommands.addDev;
-      if (packageManager === "pnpm") {
-        addCommand = "pnpm add -D";
-      }
-      (0, child_process_1.execSync)(`${addCommand} ${pkg}@${requiredVersion} ${pmCommands.ignoreScriptsFlag ?? ""}`, {
-        cwd: tempDir,
-        stdio: isVerbose ? "inherit" : "ignore",
-        windowsHide: false
-      });
+      const { tempDir } = (0, devkit_internals_1.installPackageToTmp)(pkg, requiredVersion);
       addToNodePath((0, path_1.join)(devkit_exports_1.workspaceRoot, "node_modules"));
       addToNodePath((0, path_1.join)(tempDir, "node_modules"));
       module_1.Module._initPaths();
@@ -106456,16 +109290,6 @@ var require_package_json = __commonJS({
         throw e7;
       }
     }
-    function generatePackageManagerFiles(root2, packageManager = (0, devkit_exports_1.detectPackageManager)()) {
-      const [pmMajor] = (0, devkit_exports_1.getPackageManagerVersion)(packageManager).split(".");
-      switch (packageManager) {
-        case "yarn":
-          if (+pmMajor >= 2) {
-            (0, fs_1.writeFileSync)((0, path_1.join)(root2, ".yarnrc.yml"), "nodeLinker: node-modules\nenableScripts: false");
-          }
-          break;
-      }
-    }
     function addToNodePath(dir) {
       const delimiter = require("os").platform() === "win32" ? ";" : ":";
       const paths = process.env.NODE_PATH ? process.env.NODE_PATH.split(delimiter) : [];
@@ -106475,16 +109299,16 @@ var require_package_json = __commonJS({
       paths.push(dir);
       process.env.NODE_PATH = paths.join(delimiter);
     }
-    function getPackageVersion(pkg) {
+    function getInstalledPackageModuleVersion(pkg) {
       return require((0, path_1.join)(pkg, "package.json")).version;
     }
-    exports2.NX_VERSION = getPackageVersion("nx");
+    exports2.NX_VERSION = getInstalledPackageModuleVersion("nx");
   }
 });
 
-// ../../node_modules/.pnpm/@nx+devkit@21.5.2_nx@21.5.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_c4b3329f377a274c25d9c6b2b666ae22/node_modules/@nx/devkit/src/generators/to-js.js
+// ../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/src/generators/to-js.js
 var require_to_js = __commonJS({
-  "../../node_modules/.pnpm/@nx+devkit@21.5.2_nx@21.5.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_c4b3329f377a274c25d9c6b2b666ae22/node_modules/@nx/devkit/src/generators/to-js.js"(exports2) {
+  "../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/src/generators/to-js.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.toJS = toJS;
@@ -106512,9 +109336,9 @@ var require_to_js = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/@nx+devkit@21.5.2_nx@21.5.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_c4b3329f377a274c25d9c6b2b666ae22/node_modules/@nx/devkit/src/generators/update-ts-configs-to-js.js
+// ../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/src/generators/update-ts-configs-to-js.js
 var require_update_ts_configs_to_js = __commonJS({
-  "../../node_modules/.pnpm/@nx+devkit@21.5.2_nx@21.5.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_c4b3329f377a274c25d9c6b2b666ae22/node_modules/@nx/devkit/src/generators/update-ts-configs-to-js.js"(exports2) {
+  "../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/src/generators/update-ts-configs-to-js.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.updateTsConfigsToJs = updateTsConfigsToJs;
@@ -106558,9 +109382,9 @@ var require_update_ts_configs_to_js = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/@nx+devkit@21.5.2_nx@21.5.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_c4b3329f377a274c25d9c6b2b666ae22/node_modules/@nx/devkit/src/generators/run-tasks-in-serial.js
+// ../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/src/generators/run-tasks-in-serial.js
 var require_run_tasks_in_serial = __commonJS({
-  "../../node_modules/.pnpm/@nx+devkit@21.5.2_nx@21.5.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_c4b3329f377a274c25d9c6b2b666ae22/node_modules/@nx/devkit/src/generators/run-tasks-in-serial.js"(exports2) {
+  "../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/src/generators/run-tasks-in-serial.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.runTasksInSerial = runTasksInSerial;
@@ -106574,412 +109398,16 @@ var require_run_tasks_in_serial = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/ignore@5.3.2/node_modules/ignore/index.js
-var require_ignore2 = __commonJS({
-  "../../node_modules/.pnpm/ignore@5.3.2/node_modules/ignore/index.js"(exports2, module2) {
-    function makeArray(subject) {
-      return Array.isArray(subject) ? subject : [subject];
-    }
-    var EMPTY = "";
-    var SPACE = " ";
-    var ESCAPE = "\\";
-    var REGEX_TEST_BLANK_LINE = /^\s+$/;
-    var REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
-    var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
-    var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
-    var REGEX_SPLITALL_CRLF = /\r?\n/g;
-    var REGEX_TEST_INVALID_PATH = /^\.*\/|^\.+$/;
-    var SLASH = "/";
-    var TMP_KEY_IGNORE = "node-ignore";
-    if (typeof Symbol !== "undefined") {
-      TMP_KEY_IGNORE = Symbol.for("node-ignore");
-    }
-    var KEY_IGNORE = TMP_KEY_IGNORE;
-    var define2 = (object, key2, value) => Object.defineProperty(object, key2, { value });
-    var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
-    var RETURN_FALSE = () => false;
-    var sanitizeRange = (range) => range.replace(
-      REGEX_REGEXP_RANGE,
-      (match, from, to4) => from.charCodeAt(0) <= to4.charCodeAt(0) ? match : EMPTY
-    );
-    var cleanRangeBackSlash = (slashes) => {
-      const { length } = slashes;
-      return slashes.slice(0, length - length % 2);
-    };
-    var REPLACERS = [
-      [
-        // remove BOM
-        // TODO:
-        // Other similar zero-width characters?
-        /^\uFEFF/,
-        () => EMPTY
-      ],
-      // > Trailing spaces are ignored unless they are quoted with backslash ("\")
-      [
-        // (a\ ) -> (a )
-        // (a  ) -> (a)
-        // (a ) -> (a)
-        // (a \ ) -> (a  )
-        /((?:\\\\)*?)(\\?\s+)$/,
-        (_7, m12, m24) => m12 + (m24.indexOf("\\") === 0 ? SPACE : EMPTY)
-      ],
-      // replace (\ ) with ' '
-      // (\ ) -> ' '
-      // (\\ ) -> '\\ '
-      // (\\\ ) -> '\\ '
-      [
-        /(\\+?)\s/g,
-        (_7, m12) => {
-          const { length } = m12;
-          return m12.slice(0, length - length % 2) + SPACE;
-        }
-      ],
-      // Escape metacharacters
-      // which is written down by users but means special for regular expressions.
-      // > There are 12 characters with special meanings:
-      // > - the backslash \,
-      // > - the caret ^,
-      // > - the dollar sign $,
-      // > - the period or dot .,
-      // > - the vertical bar or pipe symbol |,
-      // > - the question mark ?,
-      // > - the asterisk or star *,
-      // > - the plus sign +,
-      // > - the opening parenthesis (,
-      // > - the closing parenthesis ),
-      // > - and the opening square bracket [,
-      // > - the opening curly brace {,
-      // > These special characters are often called "metacharacters".
-      [
-        /[\\$.|*+(){^]/g,
-        (match) => `\\${match}`
-      ],
-      [
-        // > a question mark (?) matches a single character
-        /(?!\\)\?/g,
-        () => "[^/]"
-      ],
-      // leading slash
-      [
-        // > A leading slash matches the beginning of the pathname.
-        // > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c".
-        // A leading slash matches the beginning of the pathname
-        /^\//,
-        () => "^"
-      ],
-      // replace special metacharacter slash after the leading slash
-      [
-        /\//g,
-        () => "\\/"
-      ],
-      [
-        // > A leading "**" followed by a slash means match in all directories.
-        // > For example, "**/foo" matches file or directory "foo" anywhere,
-        // > the same as pattern "foo".
-        // > "**/foo/bar" matches file or directory "bar" anywhere that is directly
-        // >   under directory "foo".
-        // Notice that the '*'s have been replaced as '\\*'
-        /^\^*\\\*\\\*\\\//,
-        // '**/foo' <-> 'foo'
-        () => "^(?:.*\\/)?"
-      ],
-      // starting
-      [
-        // there will be no leading '/'
-        //   (which has been replaced by section "leading slash")
-        // If starts with '**', adding a '^' to the regular expression also works
-        /^(?=[^^])/,
-        function startingReplacer() {
-          return !/\/(?!$)/.test(this) ? "(?:^|\\/)" : "^";
-        }
-      ],
-      // two globstars
-      [
-        // Use lookahead assertions so that we could match more than one `'/**'`
-        /\\\/\\\*\\\*(?=\\\/|$)/g,
-        // Zero, one or several directories
-        // should not use '*', or it will be replaced by the next replacer
-        // Check if it is not the last `'/**'`
-        (_7, index, str) => index + 6 < str.length ? "(?:\\/[^\\/]+)*" : "\\/.+"
-      ],
-      // normal intermediate wildcards
-      [
-        // Never replace escaped '*'
-        // ignore rule '\*' will match the path '*'
-        // 'abc.*/' -> go
-        // 'abc.*'  -> skip this rule,
-        //    coz trailing single wildcard will be handed by [trailing wildcard]
-        /(^|[^\\]+)(\\\*)+(?=.+)/g,
-        // '*.js' matches '.js'
-        // '*.js' doesn't match 'abc'
-        (_7, p12, p25) => {
-          const unescaped = p25.replace(/\\\*/g, "[^\\/]*");
-          return p12 + unescaped;
-        }
-      ],
-      [
-        // unescape, revert step 3 except for back slash
-        // For example, if a user escape a '\\*',
-        // after step 3, the result will be '\\\\\\*'
-        /\\\\\\(?=[$.|*+(){^])/g,
-        () => ESCAPE
-      ],
-      [
-        // '\\\\' -> '\\'
-        /\\\\/g,
-        () => ESCAPE
-      ],
-      [
-        // > The range notation, e.g. [a-zA-Z],
-        // > can be used to match one of the characters in a range.
-        // `\` is escaped by step 3
-        /(\\)?\[([^\]/]*?)(\\*)($|\])/g,
-        (match, leadEscape, range, endEscape, close) => leadEscape === ESCAPE ? `\\[${range}${cleanRangeBackSlash(endEscape)}${close}` : close === "]" ? endEscape.length % 2 === 0 ? `[${sanitizeRange(range)}${endEscape}]` : "[]" : "[]"
-      ],
-      // ending
-      [
-        // 'js' will not match 'js.'
-        // 'ab' will not match 'abc'
-        /(?:[^*])$/,
-        // WTF!
-        // https://git-scm.com/docs/gitignore
-        // changes in [2.22.1](https://git-scm.com/docs/gitignore/2.22.1)
-        // which re-fixes #24, #38
-        // > If there is a separator at the end of the pattern then the pattern
-        // > will only match directories, otherwise the pattern can match both
-        // > files and directories.
-        // 'js*' will not match 'a.js'
-        // 'js/' will not match 'a.js'
-        // 'js' will match 'a.js' and 'a.js/'
-        (match) => /\/$/.test(match) ? `${match}$` : `${match}(?=$|\\/$)`
-      ],
-      // trailing wildcard
-      [
-        /(\^|\\\/)?\\\*$/,
-        (_7, p12) => {
-          const prefix = p12 ? `${p12}[^/]+` : "[^/]*";
-          return `${prefix}(?=$|\\/$)`;
-        }
-      ]
-    ];
-    var regexCache = /* @__PURE__ */ Object.create(null);
-    var makeRegex = (pattern, ignoreCase) => {
-      let source2 = regexCache[pattern];
-      if (!source2) {
-        source2 = REPLACERS.reduce(
-          (prev, [matcher, replacer]) => prev.replace(matcher, replacer.bind(pattern)),
-          pattern
-        );
-        regexCache[pattern] = source2;
-      }
-      return ignoreCase ? new RegExp(source2, "i") : new RegExp(source2);
-    };
-    var isString = (subject) => typeof subject === "string";
-    var checkPattern = (pattern) => pattern && isString(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0;
-    var splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF);
-    var IgnoreRule = class {
-      constructor(origin, pattern, negative, regex) {
-        this.origin = origin;
-        this.pattern = pattern;
-        this.negative = negative;
-        this.regex = regex;
-      }
-    };
-    var createRule = (pattern, ignoreCase) => {
-      const origin = pattern;
-      let negative = false;
-      if (pattern.indexOf("!") === 0) {
-        negative = true;
-        pattern = pattern.substr(1);
-      }
-      pattern = pattern.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
-      const regex = makeRegex(pattern, ignoreCase);
-      return new IgnoreRule(
-        origin,
-        pattern,
-        negative,
-        regex
-      );
-    };
-    var throwError = (message, Ctor) => {
-      throw new Ctor(message);
-    };
-    var checkPath = (path14, originalPath, doThrow) => {
-      if (!isString(path14)) {
-        return doThrow(
-          `path must be a string, but got \`${originalPath}\``,
-          TypeError
-        );
-      }
-      if (!path14) {
-        return doThrow(`path must not be empty`, TypeError);
-      }
-      if (checkPath.isNotRelative(path14)) {
-        const r4 = "`path.relative()`d";
-        return doThrow(
-          `path should be a ${r4} string, but got "${originalPath}"`,
-          RangeError
-        );
-      }
-      return true;
-    };
-    var isNotRelative = (path14) => REGEX_TEST_INVALID_PATH.test(path14);
-    checkPath.isNotRelative = isNotRelative;
-    checkPath.convert = (p5) => p5;
-    var Ignore = class {
-      constructor({
-        ignorecase = true,
-        ignoreCase = ignorecase,
-        allowRelativePaths = false
-      } = {}) {
-        define2(this, KEY_IGNORE, true);
-        this._rules = [];
-        this._ignoreCase = ignoreCase;
-        this._allowRelativePaths = allowRelativePaths;
-        this._initCache();
-      }
-      _initCache() {
-        this._ignoreCache = /* @__PURE__ */ Object.create(null);
-        this._testCache = /* @__PURE__ */ Object.create(null);
-      }
-      _addPattern(pattern) {
-        if (pattern && pattern[KEY_IGNORE]) {
-          this._rules = this._rules.concat(pattern._rules);
-          this._added = true;
-          return;
-        }
-        if (checkPattern(pattern)) {
-          const rule = createRule(pattern, this._ignoreCase);
-          this._added = true;
-          this._rules.push(rule);
-        }
-      }
-      // @param {Array<string> | string | Ignore} pattern
-      add(pattern) {
-        this._added = false;
-        makeArray(
-          isString(pattern) ? splitPattern(pattern) : pattern
-        ).forEach(this._addPattern, this);
-        if (this._added) {
-          this._initCache();
-        }
-        return this;
-      }
-      // legacy
-      addPattern(pattern) {
-        return this.add(pattern);
-      }
-      //          |           ignored : unignored
-      // negative |   0:0   |   0:1   |   1:0   |   1:1
-      // -------- | ------- | ------- | ------- | --------
-      //     0    |  TEST   |  TEST   |  SKIP   |    X
-      //     1    |  TESTIF |  SKIP   |  TEST   |    X
-      // - SKIP: always skip
-      // - TEST: always test
-      // - TESTIF: only test if checkUnignored
-      // - X: that never happen
-      // @param {boolean} whether should check if the path is unignored,
-      //   setting `checkUnignored` to `false` could reduce additional
-      //   path matching.
-      // @returns {TestResult} true if a file is ignored
-      _testOne(path14, checkUnignored) {
-        let ignored = false;
-        let unignored = false;
-        this._rules.forEach((rule) => {
-          const { negative } = rule;
-          if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
-            return;
-          }
-          const matched = rule.regex.test(path14);
-          if (matched) {
-            ignored = !negative;
-            unignored = negative;
-          }
-        });
-        return {
-          ignored,
-          unignored
-        };
-      }
-      // @returns {TestResult}
-      _test(originalPath, cache3, checkUnignored, slices) {
-        const path14 = originalPath && checkPath.convert(originalPath);
-        checkPath(
-          path14,
-          originalPath,
-          this._allowRelativePaths ? RETURN_FALSE : throwError
-        );
-        return this._t(path14, cache3, checkUnignored, slices);
-      }
-      _t(path14, cache3, checkUnignored, slices) {
-        if (path14 in cache3) {
-          return cache3[path14];
-        }
-        if (!slices) {
-          slices = path14.split(SLASH);
-        }
-        slices.pop();
-        if (!slices.length) {
-          return cache3[path14] = this._testOne(path14, checkUnignored);
-        }
-        const parent = this._t(
-          slices.join(SLASH) + SLASH,
-          cache3,
-          checkUnignored,
-          slices
-        );
-        return cache3[path14] = parent.ignored ? parent : this._testOne(path14, checkUnignored);
-      }
-      ignores(path14) {
-        return this._test(path14, this._ignoreCache, false).ignored;
-      }
-      createFilter() {
-        return (path14) => !this.ignores(path14);
-      }
-      filter(paths) {
-        return makeArray(paths).filter(this.createFilter());
-      }
-      // @returns {TestResult}
-      test(path14) {
-        return this._test(path14, this._testCache, true);
-      }
-    };
-    var factory = (options8) => new Ignore(options8);
-    var isPathValid = (path14) => checkPath(path14 && checkPath.convert(path14), path14, RETURN_FALSE);
-    factory.isPathValid = isPathValid;
-    factory.default = factory;
-    module2.exports = factory;
-    if (
-      // Detect `process` so that it can run in browsers.
-      typeof process !== "undefined" && (process.env && process.env.IGNORE_TEST_WIN32 || process.platform === "win32")
-    ) {
-      const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
-      checkPath.convert = makePosix;
-      const REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-      checkPath.isNotRelative = (path14) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path14) || isNotRelative(path14);
-    }
-  }
-});
-
-// ../../node_modules/.pnpm/@nx+devkit@21.5.2_nx@21.5.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_c4b3329f377a274c25d9c6b2b666ae22/node_modules/@nx/devkit/src/generators/visit-not-ignored-files.js
+// ../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/src/generators/visit-not-ignored-files.js
 var require_visit_not_ignored_files = __commonJS({
-  "../../node_modules/.pnpm/@nx+devkit@21.5.2_nx@21.5.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_c4b3329f377a274c25d9c6b2b666ae22/node_modules/@nx/devkit/src/generators/visit-not-ignored-files.js"(exports2) {
+  "../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/src/generators/visit-not-ignored-files.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.visitNotIgnoredFiles = visitNotIgnoredFiles;
-    var ignore_1 = require_ignore2();
+    var devkit_internals_1 = require("nx/src/devkit-internals");
     var path_1 = require("path");
     function visitNotIgnoredFiles(tree, dirPath = tree.root, visitor) {
-      let ig2;
-      if (tree.exists(".gitignore")) {
-        ig2 = (0, ignore_1.default)();
-        ig2.add(".git");
-        ig2.add(tree.read(".gitignore", "utf-8"));
-      }
-      if (tree.exists(".nxignore")) {
-        ig2 ??= (0, ignore_1.default)();
-        ig2.add(tree.read(".nxignore", "utf-8"));
-      }
+      const ig2 = (0, devkit_internals_1.getIgnoreObjectForTree)(tree);
       dirPath = normalizePathRelativeToRoot(dirPath, tree.root);
       if (dirPath !== "" && ig2?.ignores(dirPath)) {
         return;
@@ -107002,9 +109430,9 @@ var require_visit_not_ignored_files = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/@nx+devkit@21.5.2_nx@21.5.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_c4b3329f377a274c25d9c6b2b666ae22/node_modules/@nx/devkit/src/executors/parse-target-string.js
+// ../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/src/executors/parse-target-string.js
 var require_parse_target_string = __commonJS({
-  "../../node_modules/.pnpm/@nx+devkit@21.5.2_nx@21.5.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_c4b3329f377a274c25d9c6b2b666ae22/node_modules/@nx/devkit/src/executors/parse-target-string.js"(exports2) {
+  "../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/src/executors/parse-target-string.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.parseTargetString = parseTargetString;
@@ -107040,9 +109468,9 @@ var require_parse_target_string = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/@nx+devkit@21.5.2_nx@21.5.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_c4b3329f377a274c25d9c6b2b666ae22/node_modules/@nx/devkit/src/executors/read-target-options.js
+// ../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/src/executors/read-target-options.js
 var require_read_target_options = __commonJS({
-  "../../node_modules/.pnpm/@nx+devkit@21.5.2_nx@21.5.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_c4b3329f377a274c25d9c6b2b666ae22/node_modules/@nx/devkit/src/executors/read-target-options.js"(exports2) {
+  "../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/src/executors/read-target-options.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.readTargetOptions = readTargetOptions;
@@ -107065,9 +109493,9 @@ var require_read_target_options = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/@nx+devkit@21.5.2_nx@21.5.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_c4b3329f377a274c25d9c6b2b666ae22/node_modules/@nx/devkit/src/utils/names.js
+// ../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/src/utils/names.js
 var require_names = __commonJS({
-  "../../node_modules/.pnpm/@nx+devkit@21.5.2_nx@21.5.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_c4b3329f377a274c25d9c6b2b666ae22/node_modules/@nx/devkit/src/utils/names.js"(exports2) {
+  "../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/src/utils/names.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.names = names;
@@ -107099,9 +109527,9 @@ var require_names = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/@nx+devkit@21.5.2_nx@21.5.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_c4b3329f377a274c25d9c6b2b666ae22/node_modules/@nx/devkit/src/utils/get-workspace-layout.js
+// ../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/src/utils/get-workspace-layout.js
 var require_get_workspace_layout = __commonJS({
-  "../../node_modules/.pnpm/@nx+devkit@21.5.2_nx@21.5.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_c4b3329f377a274c25d9c6b2b666ae22/node_modules/@nx/devkit/src/utils/get-workspace-layout.js"(exports2) {
+  "../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/src/utils/get-workspace-layout.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.getWorkspaceLayout = getWorkspaceLayout;
@@ -107139,9 +109567,9 @@ var require_get_workspace_layout = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/@nx+devkit@21.5.2_nx@21.5.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_c4b3329f377a274c25d9c6b2b666ae22/node_modules/@nx/devkit/src/utils/string-change.js
+// ../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/src/utils/string-change.js
 var require_string_change = __commonJS({
-  "../../node_modules/.pnpm/@nx+devkit@21.5.2_nx@21.5.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_c4b3329f377a274c25d9c6b2b666ae22/node_modules/@nx/devkit/src/utils/string-change.js"(exports2) {
+  "../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/src/utils/string-change.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.ChangeType = void 0;
@@ -107218,9 +109646,9 @@ var require_string_change = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/@nx+devkit@21.5.2_nx@21.5.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_c4b3329f377a274c25d9c6b2b666ae22/node_modules/@nx/devkit/src/utils/offset-from-root.js
+// ../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/src/utils/offset-from-root.js
 var require_offset_from_root = __commonJS({
-  "../../node_modules/.pnpm/@nx+devkit@21.5.2_nx@21.5.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_c4b3329f377a274c25d9c6b2b666ae22/node_modules/@nx/devkit/src/utils/offset-from-root.js"(exports2) {
+  "../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/src/utils/offset-from-root.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.offsetFromRoot = offsetFromRoot;
@@ -107240,9 +109668,9 @@ var require_offset_from_root = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/@nx+devkit@21.5.2_nx@21.5.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_c4b3329f377a274c25d9c6b2b666ae22/node_modules/@nx/devkit/src/utils/invoke-nx-generator.js
+// ../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/src/utils/invoke-nx-generator.js
 var require_invoke_nx_generator = __commonJS({
-  "../../node_modules/.pnpm/@nx+devkit@21.5.2_nx@21.5.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_c4b3329f377a274c25d9c6b2b666ae22/node_modules/@nx/devkit/src/utils/invoke-nx-generator.js"(exports2) {
+  "../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/src/utils/invoke-nx-generator.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.convertNxGenerator = convertNxGenerator;
@@ -111407,7 +113835,7 @@ var require_uri = __commonJS({
 });
 
 // ../../node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/core.js
-var require_core = __commonJS({
+var require_core2 = __commonJS({
   "../../node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/core.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -112155,7 +114583,7 @@ var require_ref = __commonJS({
 });
 
 // ../../node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/vocabularies/core/index.js
-var require_core2 = __commonJS({
+var require_core3 = __commonJS({
   "../../node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/vocabularies/core/index.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -113683,7 +116111,7 @@ var require_draft7 = __commonJS({
   "../../node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/vocabularies/draft7.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    var core_1 = require_core2();
+    var core_1 = require_core3();
     var validation_1 = require_validation();
     var applicator_1 = require_applicator();
     var format_1 = require_format2();
@@ -113982,7 +116410,7 @@ var require_ajv = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.MissingRefError = exports2.ValidationError = exports2.CodeGen = exports2.Name = exports2.nil = exports2.stringify = exports2.str = exports2._ = exports2.KeywordCxt = exports2.Ajv = void 0;
-    var core_1 = require_core();
+    var core_1 = require_core2();
     var draft7_1 = require_draft7();
     var discriminator_1 = require_discriminator();
     var draft7MetaSchema = require_json_schema_draft_07();
@@ -118126,7 +120554,7 @@ var require_timeout = __commonJS({
 });
 
 // ../../node_modules/.pnpm/rxjs@7.8.1/node_modules/rxjs/dist/cjs/internal/operators/map.js
-var require_map2 = __commonJS({
+var require_map3 = __commonJS({
   "../../node_modules/.pnpm/rxjs@7.8.1/node_modules/rxjs/dist/cjs/internal/operators/map.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -118173,7 +120601,7 @@ var require_mapOneOrManyArgs = __commonJS({
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.mapOneOrManyArgs = void 0;
-    var map_1 = require_map2();
+    var map_1 = require_map3();
     var isArray = Array.isArray;
     function callOrApply(fn9, args) {
       return isArray(args) ? fn9.apply(void 0, __spreadArray2([], __read2(args))) : fn9(args);
@@ -118525,7 +120953,7 @@ var require_mergeMap = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.mergeMap = void 0;
-    var map_1 = require_map2();
+    var map_1 = require_map3();
     var innerFrom_1 = require_innerFrom();
     var lift_1 = require_lift();
     var mergeInternals_1 = require_mergeInternals();
@@ -119053,7 +121481,7 @@ var require_interval = __commonJS({
 });
 
 // ../../node_modules/.pnpm/rxjs@7.8.1/node_modules/rxjs/dist/cjs/internal/observable/merge.js
-var require_merge = __commonJS({
+var require_merge3 = __commonJS({
   "../../node_modules/.pnpm/rxjs@7.8.1/node_modules/rxjs/dist/cjs/internal/observable/merge.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -119150,7 +121578,7 @@ var require_onErrorResumeNext = __commonJS({
 });
 
 // ../../node_modules/.pnpm/rxjs@7.8.1/node_modules/rxjs/dist/cjs/internal/observable/pairs.js
-var require_pairs = __commonJS({
+var require_pairs2 = __commonJS({
   "../../node_modules/.pnpm/rxjs@7.8.1/node_modules/rxjs/dist/cjs/internal/observable/pairs.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -120397,7 +122825,7 @@ var require_mapTo = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.mapTo = void 0;
-    var map_1 = require_map2();
+    var map_1 = require_map3();
     function mapTo(value) {
       return map_1.map(function() {
         return value;
@@ -120687,7 +123115,7 @@ var require_exhaustMap = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.exhaustMap = void 0;
-    var map_1 = require_map2();
+    var map_1 = require_map3();
     var innerFrom_1 = require_innerFrom();
     var lift_1 = require_lift();
     var OperatorSubscriber_1 = require_OperatorSubscriber();
@@ -121160,7 +123588,7 @@ var require_mergeScan = __commonJS({
 });
 
 // ../../node_modules/.pnpm/rxjs@7.8.1/node_modules/rxjs/dist/cjs/internal/operators/merge.js
-var require_merge3 = __commonJS({
+var require_merge4 = __commonJS({
   "../../node_modules/.pnpm/rxjs@7.8.1/node_modules/rxjs/dist/cjs/internal/operators/merge.js"(exports2) {
     "use strict";
     var __read2 = exports2 && exports2.__read || function(o4, n27) {
@@ -121236,7 +123664,7 @@ var require_mergeWith = __commonJS({
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.mergeWith = void 0;
-    var merge_1 = require_merge3();
+    var merge_1 = require_merge4();
     function mergeWith() {
       var otherSources = [];
       for (var _i8 = 0; _i8 < arguments.length; _i8++) {
@@ -121368,7 +123796,7 @@ var require_pluck = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.pluck = void 0;
-    var map_1 = require_map2();
+    var map_1 = require_map3();
     function pluck() {
       var properties = [];
       for (var _i8 = 0; _i8 < arguments.length; _i8++) {
@@ -122521,13 +124949,13 @@ var require_timeoutWith = __commonJS({
 });
 
 // ../../node_modules/.pnpm/rxjs@7.8.1/node_modules/rxjs/dist/cjs/internal/operators/timestamp.js
-var require_timestamp = __commonJS({
+var require_timestamp2 = __commonJS({
   "../../node_modules/.pnpm/rxjs@7.8.1/node_modules/rxjs/dist/cjs/internal/operators/timestamp.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.timestamp = void 0;
     var dateTimestampProvider_1 = require_dateTimestampProvider();
-    var map_1 = require_map2();
+    var map_1 = require_map3();
     function timestamp(timestampProvider) {
       if (timestampProvider === void 0) {
         timestampProvider = dateTimestampProvider_1.dateTimestampProvider;
@@ -123261,7 +125689,7 @@ var require_cjs = __commonJS({
     Object.defineProperty(exports2, "interval", { enumerable: true, get: function() {
       return interval_1.interval;
     } });
-    var merge_1 = require_merge();
+    var merge_1 = require_merge3();
     Object.defineProperty(exports2, "merge", { enumerable: true, get: function() {
       return merge_1.merge;
     } });
@@ -123277,7 +125705,7 @@ var require_cjs = __commonJS({
     Object.defineProperty(exports2, "onErrorResumeNext", { enumerable: true, get: function() {
       return onErrorResumeNext_1.onErrorResumeNext;
     } });
-    var pairs_1 = require_pairs();
+    var pairs_1 = require_pairs2();
     Object.defineProperty(exports2, "pairs", { enumerable: true, get: function() {
       return pairs_1.pairs;
     } });
@@ -123494,7 +125922,7 @@ var require_cjs = __commonJS({
     Object.defineProperty(exports2, "last", { enumerable: true, get: function() {
       return last_1.last;
     } });
-    var map_1 = require_map2();
+    var map_1 = require_map3();
     Object.defineProperty(exports2, "map", { enumerable: true, get: function() {
       return map_1.map;
     } });
@@ -123714,7 +126142,7 @@ var require_cjs = __commonJS({
     Object.defineProperty(exports2, "timeoutWith", { enumerable: true, get: function() {
       return timeoutWith_1.timeoutWith;
     } });
-    var timestamp_1 = require_timestamp();
+    var timestamp_1 = require_timestamp2();
     Object.defineProperty(exports2, "timestamp", { enumerable: true, get: function() {
       return timestamp_1.timestamp;
     } });
@@ -123758,7 +126186,7 @@ var require_cjs = __commonJS({
 });
 
 // ../../node_modules/.pnpm/@angular-devkit+core@19.0.6_chokidar@4.0.3/node_modules/@angular-devkit/core/src/exception.js
-var require_exception = __commonJS({
+var require_exception2 = __commonJS({
   "../../node_modules/.pnpm/@angular-devkit+core@19.0.6_chokidar@4.0.3/node_modules/@angular-devkit/core/src/exception.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -124167,7 +126595,7 @@ var require_partially_ordered_set = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.PartiallyOrderedSet = exports2.CircularDependencyFoundException = exports2.DependencyNotFoundException = void 0;
-    var exception_1 = require_exception();
+    var exception_1 = require_exception2();
     var DependencyNotFoundException = class extends exception_1.BaseException {
       constructor() {
         super("One of the dependencies is not part of the set.");
@@ -124563,7 +126991,7 @@ var require_registry = __commonJS({
     var https = __importStar2(require("https"));
     var rxjs_1 = require_cjs();
     var Url = __importStar2(require("url"));
-    var exception_1 = require_exception();
+    var exception_1 = require_exception2();
     var utils_1 = require_utils8();
     var utils_2 = require_utils6();
     var utility_1 = require_utility();
@@ -125023,7 +127451,7 @@ var require_registry = __commonJS({
 });
 
 // ../../node_modules/.pnpm/@angular-devkit+core@19.0.6_chokidar@4.0.3/node_modules/@angular-devkit/core/src/json/schema/schema.js
-var require_schema = __commonJS({
+var require_schema2 = __commonJS({
   "../../node_modules/.pnpm/@angular-devkit+core@19.0.6_chokidar@4.0.3/node_modules/@angular-devkit/core/src/json/schema/schema.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -125061,7 +127489,7 @@ var require_schema = __commonJS({
 });
 
 // ../../node_modules/.pnpm/@angular-devkit+core@19.0.6_chokidar@4.0.3/node_modules/@angular-devkit/core/src/json/schema/index.js
-var require_schema2 = __commonJS({
+var require_schema3 = __commonJS({
   "../../node_modules/.pnpm/@angular-devkit+core@19.0.6_chokidar@4.0.3/node_modules/@angular-devkit/core/src/json/schema/index.js"(exports2) {
     "use strict";
     var __createBinding2 = exports2 && exports2.__createBinding || (Object.create ? (function(o4, m5, k8, k23) {
@@ -125101,14 +127529,14 @@ var require_schema2 = __commonJS({
     __exportStar2(require_interface(), exports2);
     __exportStar2(require_pointer(), exports2);
     __exportStar2(require_registry(), exports2);
-    __exportStar2(require_schema(), exports2);
+    __exportStar2(require_schema2(), exports2);
     __exportStar2(require_visitor(), exports2);
     __exportStar2(require_utility(), exports2);
   }
 });
 
 // ../../node_modules/.pnpm/@angular-devkit+core@19.0.6_chokidar@4.0.3/node_modules/@angular-devkit/core/src/json/index.js
-var require_json = __commonJS({
+var require_json2 = __commonJS({
   "../../node_modules/.pnpm/@angular-devkit+core@19.0.6_chokidar@4.0.3/node_modules/@angular-devkit/core/src/json/index.js"(exports2) {
     "use strict";
     var __createBinding2 = exports2 && exports2.__createBinding || (Object.create ? (function(o4, m5, k8, k23) {
@@ -125143,7 +127571,7 @@ var require_json = __commonJS({
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.schema = void 0;
-    var schema = __importStar2(require_schema2());
+    var schema = __importStar2(require_schema3());
     exports2.schema = schema;
     __exportStar2(require_utils6(), exports2);
   }
@@ -125619,7 +128047,7 @@ var require_path2 = __commonJS({
     exports2.asWindowsPath = asWindowsPath;
     exports2.asPosixPath = asPosixPath;
     exports2.getSystemPath = getSystemPath;
-    var exception_1 = require_exception();
+    var exception_1 = require_exception2();
     var InvalidPathException = class extends exception_1.BaseException {
       constructor(path15) {
         super(`Path ${JSON.stringify(path15)} is invalid.`);
@@ -125844,7 +128272,7 @@ var require_memory = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.SimpleMemoryHost = void 0;
     var rxjs_1 = require_cjs();
-    var exception_1 = require_exception();
+    var exception_1 = require_exception2();
     var path_1 = require_path2();
     var interface_1 = require_interface2();
     var SimpleMemoryHost = class {
@@ -126159,7 +128587,7 @@ var require_sync7 = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.SyncDelegateHost = exports2.SynchronousDelegateExpectedException = void 0;
-    var exception_1 = require_exception();
+    var exception_1 = require_exception2();
     var SynchronousDelegateExpectedException = class extends exception_1.BaseException {
       constructor() {
         super(`Expected a synchronous delegate but got an asynchronous one.`);
@@ -126490,7 +128918,7 @@ var require_empty2 = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.Empty = void 0;
     var rxjs_1 = require_cjs();
-    var exception_1 = require_exception();
+    var exception_1 = require_exception2();
     var Empty = class {
       capabilities = {
         synchronous: true
@@ -128073,7 +130501,7 @@ var require_record = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.CordHost = void 0;
     var rxjs_1 = require_cjs();
-    var exception_1 = require_exception();
+    var exception_1 = require_exception2();
     var memory_1 = require_memory();
     var CordHost = class _CordHost extends memory_1.SimpleMemoryHost {
       _back;
@@ -130258,7 +132686,7 @@ var require_utilities = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.createVirtualAstObject = createVirtualAstObject;
-    var json_1 = require_json();
+    var json_1 = require_json2();
     function createVirtualAstObject(root2, options8 = {}) {
       const reporter = (path14, target, oldValue, newValue) => {
         if (!options8.listener) {
@@ -130702,7 +133130,7 @@ var require_writer = __commonJS({
 });
 
 // ../../node_modules/.pnpm/@angular-devkit+core@19.0.6_chokidar@4.0.3/node_modules/@angular-devkit/core/src/workspace/core.js
-var require_core3 = __commonJS({
+var require_core4 = __commonJS({
   "../../node_modules/.pnpm/@angular-devkit+core@19.0.6_chokidar@4.0.3/node_modules/@angular-devkit/core/src/workspace/core.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -130812,7 +133240,7 @@ var require_workspace = __commonJS({
     Object.defineProperty(exports2, "createWorkspaceHost", { enumerable: true, get: function() {
       return host_1.createWorkspaceHost;
     } });
-    var core_1 = require_core3();
+    var core_1 = require_core4();
     Object.defineProperty(exports2, "WorkspaceFormat", { enumerable: true, get: function() {
       return core_1.WorkspaceFormat;
     } });
@@ -130861,14 +133289,14 @@ var require_src2 = __commonJS({
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.workspaces = exports2.logging = exports2.json = void 0;
-    var json = __importStar2(require_json());
+    var json = __importStar2(require_json2());
     exports2.json = json;
     var logging = __importStar2(require_logger2());
     exports2.logging = logging;
     var workspaces = __importStar2(require_workspace());
     exports2.workspaces = workspaces;
-    __exportStar2(require_exception(), exports2);
-    __exportStar2(require_json(), exports2);
+    __exportStar2(require_exception2(), exports2);
+    __exportStar2(require_json2(), exports2);
     __exportStar2(require_utils8(), exports2);
     __exportStar2(require_virtual_fs(), exports2);
   }
@@ -131107,7 +133535,7 @@ var require_create_job_handler = __commonJS({
 });
 
 // ../../node_modules/.pnpm/@angular-devkit+architect@0.1900.6_chokidar@4.0.3/node_modules/@angular-devkit/architect/src/jobs/exception.js
-var require_exception2 = __commonJS({
+var require_exception3 = __commonJS({
   "../../node_modules/.pnpm/@angular-devkit+architect@0.1900.6_chokidar@4.0.3/node_modules/@angular-devkit/architect/src/jobs/exception.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -131135,7 +133563,7 @@ var require_dispatcher = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.createDispatcher = createDispatcher;
     var api_1 = require_api();
-    var exception_1 = require_exception2();
+    var exception_1 = require_exception3();
     function createDispatcher(options8 = {}) {
       let defaultDelegate = null;
       const conditionalDelegateList = [];
@@ -131202,7 +133630,7 @@ var require_simple_registry = __commonJS({
     var core_1 = require_src2();
     var rxjs_1 = require_cjs();
     var api_1 = require_api();
-    var exception_1 = require_exception2();
+    var exception_1 = require_exception3();
     var SimpleJobRegistry = class {
       _jobNames = /* @__PURE__ */ new Map();
       get(name) {
@@ -131265,7 +133693,7 @@ var require_simple_scheduler = __commonJS({
     var core_1 = require_src2();
     var rxjs_1 = require_cjs();
     var api_1 = require_api();
-    var exception_1 = require_exception2();
+    var exception_1 = require_exception3();
     var JobArgumentSchemaValidationError = class extends core_1.schema.SchemaValidationException {
       constructor(errors) {
         super(errors, "Job Argument failed to validate. Errors: ");
@@ -131665,7 +134093,7 @@ var require_jobs = __commonJS({
     exports2.strategy = strategy;
     __exportStar2(require_api(), exports2);
     __exportStar2(require_create_job_handler(), exports2);
-    __exportStar2(require_exception2(), exports2);
+    __exportStar2(require_exception3(), exports2);
     __exportStar2(require_dispatcher(), exports2);
     __exportStar2(require_fallback_registry(), exports2);
     __exportStar2(require_simple_registry(), exports2);
@@ -132600,9 +135028,9 @@ var require_src3 = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/@nx+devkit@21.5.2_nx@21.5.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_c4b3329f377a274c25d9c6b2b666ae22/node_modules/@nx/devkit/src/utils/convert-nx-executor.js
+// ../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/src/utils/convert-nx-executor.js
 var require_convert_nx_executor = __commonJS({
-  "../../node_modules/.pnpm/@nx+devkit@21.5.2_nx@21.5.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_c4b3329f377a274c25d9c6b2b666ae22/node_modules/@nx/devkit/src/utils/convert-nx-executor.js"(exports2) {
+  "../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/src/utils/convert-nx-executor.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.convertNxExecutor = convertNxExecutor;
@@ -132683,9 +135111,9 @@ var require_convert_nx_executor = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/@nx+devkit@21.5.2_nx@21.5.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_c4b3329f377a274c25d9c6b2b666ae22/node_modules/@nx/devkit/src/utils/move-dir.js
+// ../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/src/utils/move-dir.js
 var require_move_dir = __commonJS({
-  "../../node_modules/.pnpm/@nx+devkit@21.5.2_nx@21.5.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_c4b3329f377a274c25d9c6b2b666ae22/node_modules/@nx/devkit/src/utils/move-dir.js"(exports2) {
+  "../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/src/utils/move-dir.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.moveFilesToNewDirectory = moveFilesToNewDirectory;
@@ -132710,12 +135138,12 @@ var require_move_dir = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/@nx+devkit@21.5.2_nx@21.5.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_c4b3329f377a274c25d9c6b2b666ae22/node_modules/@nx/devkit/public-api.js
+// ../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/public-api.js
 var require_public_api = __commonJS({
-  "../../node_modules/.pnpm/@nx+devkit@21.5.2_nx@21.5.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_c4b3329f377a274c25d9c6b2b666ae22/node_modules/@nx/devkit/public-api.js"(exports2) {
+  "../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/public-api.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.moveFilesToNewDirectory = exports2.convertNxExecutor = exports2.convertNxGenerator = exports2.offsetFromRoot = exports2.ChangeType = exports2.applyChangesToString = exports2.extractLayoutDirectory = exports2.getWorkspaceLayout = exports2.names = exports2.installPackagesTask = exports2.NX_VERSION = exports2.removeDependenciesFromPackageJson = exports2.ensurePackage = exports2.addDependenciesToPackageJson = exports2.readTargetOptions = exports2.targetToTargetString = exports2.parseTargetString = exports2.visitNotIgnoredFiles = exports2.runTasksInSerial = exports2.updateTsConfigsToJs = exports2.toJS = exports2.OverwriteStrategy = exports2.generateFiles = exports2.formatFiles = void 0;
+    exports2.moveFilesToNewDirectory = exports2.convertNxExecutor = exports2.convertNxGenerator = exports2.offsetFromRoot = exports2.ChangeType = exports2.applyChangesToString = exports2.extractLayoutDirectory = exports2.getWorkspaceLayout = exports2.names = exports2.installPackagesTask = exports2.NX_VERSION = exports2.getDependencyVersionFromPackageJson = exports2.ensurePackage = exports2.removeDependenciesFromPackageJson = exports2.addDependenciesToPackageJson = exports2.readTargetOptions = exports2.targetToTargetString = exports2.parseTargetString = exports2.visitNotIgnoredFiles = exports2.runTasksInSerial = exports2.updateTsConfigsToJs = exports2.toJS = exports2.OverwriteStrategy = exports2.generateFiles = exports2.formatFiles = void 0;
     var format_files_1 = require_format_files();
     Object.defineProperty(exports2, "formatFiles", { enumerable: true, get: function() {
       return format_files_1.formatFiles;
@@ -132758,11 +135186,14 @@ var require_public_api = __commonJS({
     Object.defineProperty(exports2, "addDependenciesToPackageJson", { enumerable: true, get: function() {
       return package_json_1.addDependenciesToPackageJson;
     } });
+    Object.defineProperty(exports2, "removeDependenciesFromPackageJson", { enumerable: true, get: function() {
+      return package_json_1.removeDependenciesFromPackageJson;
+    } });
     Object.defineProperty(exports2, "ensurePackage", { enumerable: true, get: function() {
       return package_json_1.ensurePackage;
     } });
-    Object.defineProperty(exports2, "removeDependenciesFromPackageJson", { enumerable: true, get: function() {
-      return package_json_1.removeDependenciesFromPackageJson;
+    Object.defineProperty(exports2, "getDependencyVersionFromPackageJson", { enumerable: true, get: function() {
+      return package_json_1.getDependencyVersionFromPackageJson;
     } });
     Object.defineProperty(exports2, "NX_VERSION", { enumerable: true, get: function() {
       return package_json_1.NX_VERSION;
@@ -132808,9 +135239,9 @@ var require_public_api = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/@nx+devkit@21.5.2_nx@21.5.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_c4b3329f377a274c25d9c6b2b666ae22/node_modules/@nx/devkit/index.js
+// ../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/index.js
 var require_devkit = __commonJS({
-  "../../node_modules/.pnpm/@nx+devkit@21.5.2_nx@21.5.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_c4b3329f377a274c25d9c6b2b666ae22/node_modules/@nx/devkit/index.js"(exports2) {
+  "../../node_modules/.pnpm/@nx+devkit@22.0.2_nx@22.0.2_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_188a134d6040c08c47ecd871e86bfd2b/node_modules/@nx/devkit/index.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports));
@@ -133345,15 +135776,6 @@ ejs/lib/ejs.js:
    * @license {@link http://www.apache.org/licenses/LICENSE-2.0 Apache License, Version 2.0}
    *)
 
-tmp/lib/tmp.js:
-  (*!
-   * Tmp
-   *
-   * Copyright (c) 2011-2017 KARASZI Istvan <github@spam.raszi.hu>
-   *
-   * MIT Licensed
-   *)
-
 @angular-devkit/core/src/json/utils.js:
 @angular-devkit/core/src/json/schema/utility.js:
 @angular-devkit/core/src/json/schema/transforms.js: