@storm-software/workspace-tools 1.60.4 → 1.60.6

package/index.js

@@ -384528,6 +384528,1714 @@ var require_invoke_nx_generator = __commonJS({
   }
 });
 
+// node_modules/.pnpm/@angular-devkit+architect@0.1702.0/node_modules/@angular-devkit/architect/src/jobs/api.js
+var require_api = __commonJS({
+  "node_modules/.pnpm/@angular-devkit+architect@0.1702.0/node_modules/@angular-devkit/architect/src/jobs/api.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.isJobHandler = exports2.JobState = exports2.JobOutboundMessageKind = exports2.JobInboundMessageKind = void 0;
+    var JobInboundMessageKind;
+    (function(JobInboundMessageKind2) {
+      JobInboundMessageKind2["Ping"] = "ip";
+      JobInboundMessageKind2["Stop"] = "is";
+      JobInboundMessageKind2["Input"] = "in";
+    })(JobInboundMessageKind || (exports2.JobInboundMessageKind = JobInboundMessageKind = {}));
+    var JobOutboundMessageKind;
+    (function(JobOutboundMessageKind2) {
+      JobOutboundMessageKind2["OnReady"] = "c";
+      JobOutboundMessageKind2["Start"] = "s";
+      JobOutboundMessageKind2["End"] = "e";
+      JobOutboundMessageKind2["Pong"] = "p";
+      JobOutboundMessageKind2["Output"] = "o";
+      JobOutboundMessageKind2["ChannelCreate"] = "cn";
+      JobOutboundMessageKind2["ChannelMessage"] = "cm";
+      JobOutboundMessageKind2["ChannelError"] = "ce";
+      JobOutboundMessageKind2["ChannelComplete"] = "cc";
+    })(JobOutboundMessageKind || (exports2.JobOutboundMessageKind = JobOutboundMessageKind = {}));
+    var JobState;
+    (function(JobState2) {
+      JobState2["Queued"] = "queued";
+      JobState2["Ready"] = "ready";
+      JobState2["Started"] = "started";
+      JobState2["Ended"] = "ended";
+      JobState2["Errored"] = "errored";
+    })(JobState || (exports2.JobState = JobState = {}));
+    function isJobHandler(value) {
+      const job = value;
+      return typeof job == "function" && typeof job.jobDescription == "object" && job.jobDescription !== null;
+    }
+    exports2.isJobHandler = isJobHandler;
+  }
+});
+
+// node_modules/.pnpm/@angular-devkit+architect@0.1702.0/node_modules/@angular-devkit/architect/src/jobs/strategy.js
+var require_strategy = __commonJS({
+  "node_modules/.pnpm/@angular-devkit+architect@0.1702.0/node_modules/@angular-devkit/architect/src/jobs/strategy.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.memoize = exports2.reuse = exports2.serialize = void 0;
+    var core_1 = require_src2();
+    var rxjs_1 = require_cjs();
+    var api_1 = require_api();
+    function serialize() {
+      let latest = (0, rxjs_1.of)();
+      return (handler, options8) => {
+        const newHandler = (argument, context) => {
+          const previous = latest;
+          latest = (0, rxjs_1.concat)(previous.pipe((0, rxjs_1.ignoreElements)()), new rxjs_1.Observable((o2) => handler(argument, context).subscribe(o2))).pipe((0, rxjs_1.shareReplay)(0));
+          return latest;
+        };
+        return Object.assign(newHandler, {
+          jobDescription: Object.assign({}, handler.jobDescription, options8)
+        });
+      };
+    }
+    exports2.serialize = serialize;
+    function reuse(replayMessages = false) {
+      let inboundBus = new rxjs_1.Subject();
+      let run2 = null;
+      let state = null;
+      return (handler, options8) => {
+        const newHandler = (argument, context) => {
+          const subscription = context.inboundBus.subscribe(inboundBus);
+          if (run2) {
+            return (0, rxjs_1.concat)(
+              // Update state.
+              (0, rxjs_1.of)(state),
+              run2
+            ).pipe((0, rxjs_1.finalize)(() => subscription.unsubscribe()));
+          }
+          run2 = handler(argument, { ...context, inboundBus: inboundBus.asObservable() }).pipe((0, rxjs_1.tap)((message) => {
+            if (message.kind == api_1.JobOutboundMessageKind.Start || message.kind == api_1.JobOutboundMessageKind.OnReady || message.kind == api_1.JobOutboundMessageKind.End) {
+              state = message;
+            }
+          }, void 0, () => {
+            subscription.unsubscribe();
+            inboundBus = new rxjs_1.Subject();
+            run2 = null;
+          }), replayMessages ? (0, rxjs_1.shareReplay)() : (0, rxjs_1.share)());
+          return run2;
+        };
+        return Object.assign(newHandler, handler, options8 || {});
+      };
+    }
+    exports2.reuse = reuse;
+    function memoize(replayMessages = false) {
+      const runs = /* @__PURE__ */ new Map();
+      return (handler, options8) => {
+        const newHandler = (argument, context) => {
+          const argumentJson = JSON.stringify((0, core_1.isJsonObject)(argument) ? Object.keys(argument).sort().reduce((result, key2) => {
+            result[key2] = argument[key2];
+            return result;
+          }, {}) : argument);
+          const maybeJob = runs.get(argumentJson);
+          if (maybeJob) {
+            return maybeJob;
+          }
+          const run2 = handler(argument, context).pipe(replayMessages ? (0, rxjs_1.shareReplay)() : (0, rxjs_1.share)());
+          runs.set(argumentJson, run2);
+          return run2;
+        };
+        return Object.assign(newHandler, handler, options8 || {});
+      };
+    }
+    exports2.memoize = memoize;
+  }
+});
+
+// node_modules/.pnpm/@angular-devkit+architect@0.1702.0/node_modules/@angular-devkit/architect/src/jobs/create-job-handler.js
+var require_create_job_handler = __commonJS({
+  "node_modules/.pnpm/@angular-devkit+architect@0.1702.0/node_modules/@angular-devkit/architect/src/jobs/create-job-handler.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.createLoggerJob = exports2.createJobFactory = exports2.createJobHandler = exports2.ChannelAlreadyExistException = void 0;
+    var core_1 = require_src2();
+    var rxjs_1 = require_cjs();
+    var api_1 = require_api();
+    var ChannelAlreadyExistException = class extends core_1.BaseException {
+      constructor(name) {
+        super(`Channel ${JSON.stringify(name)} already exist.`);
+      }
+    };
+    exports2.ChannelAlreadyExistException = ChannelAlreadyExistException;
+    function createJobHandler(fn6, options8 = {}) {
+      const handler = (argument, context) => {
+        const description = context.description;
+        const inboundBus = context.inboundBus;
+        const inputChannel = new rxjs_1.Subject();
+        let subscription;
+        const teardownLogics = [];
+        let tearingDown = false;
+        return new rxjs_1.Observable((subject) => {
+          function complete() {
+            if (subscription) {
+              subscription.unsubscribe();
+            }
+            subject.next({ kind: api_1.JobOutboundMessageKind.End, description });
+            subject.complete();
+            inputChannel.complete();
+          }
+          const inboundSub = inboundBus.subscribe((message) => {
+            switch (message.kind) {
+              case api_1.JobInboundMessageKind.Ping:
+                subject.next({ kind: api_1.JobOutboundMessageKind.Pong, description, id: message.id });
+                break;
+              case api_1.JobInboundMessageKind.Stop:
+                tearingDown = true;
+                if (teardownLogics.length) {
+                  Promise.all(teardownLogics.map((fn7) => fn7())).then(() => complete(), () => complete());
+                } else {
+                  complete();
+                }
+                break;
+              case api_1.JobInboundMessageKind.Input:
+                if (!tearingDown) {
+                  inputChannel.next(message.value);
+                }
+                break;
+            }
+          });
+          const channels = /* @__PURE__ */ new Map();
+          const newContext = {
+            ...context,
+            input: inputChannel.asObservable(),
+            addTeardown(teardown) {
+              teardownLogics.push(teardown);
+            },
+            createChannel(name) {
+              if (channels.has(name)) {
+                throw new ChannelAlreadyExistException(name);
+              }
+              const channelSubject = new rxjs_1.Subject();
+              const channelSub = channelSubject.subscribe((message) => {
+                subject.next({
+                  kind: api_1.JobOutboundMessageKind.ChannelMessage,
+                  description,
+                  name,
+                  message
+                });
+              }, (error) => {
+                subject.next({ kind: api_1.JobOutboundMessageKind.ChannelError, description, name, error });
+                channels.delete(name);
+              }, () => {
+                subject.next({ kind: api_1.JobOutboundMessageKind.ChannelComplete, description, name });
+                channels.delete(name);
+              });
+              channels.set(name, channelSubject);
+              if (subscription) {
+                subscription.add(channelSub);
+              }
+              return channelSubject;
+            }
+          };
+          subject.next({ kind: api_1.JobOutboundMessageKind.Start, description });
+          let result = fn6(argument, newContext);
+          if ((0, core_1.isPromise)(result)) {
+            result = (0, rxjs_1.from)(result);
+          } else if (!(0, rxjs_1.isObservable)(result)) {
+            result = (0, rxjs_1.of)(result);
+          }
+          subscription = result.subscribe((value) => subject.next({ kind: api_1.JobOutboundMessageKind.Output, description, value }), (error) => subject.error(error), () => complete());
+          subscription.add(inboundSub);
+          return subscription;
+        });
+      };
+      return Object.assign(handler, { jobDescription: options8 });
+    }
+    exports2.createJobHandler = createJobHandler;
+    function createJobFactory(loader2, options8 = {}) {
+      const handler = (argument, context) => {
+        return (0, rxjs_1.from)(loader2()).pipe((0, rxjs_1.switchMap)((fn6) => fn6(argument, context)));
+      };
+      return Object.assign(handler, { jobDescription: options8 });
+    }
+    exports2.createJobFactory = createJobFactory;
+    function createLoggerJob(job, logger) {
+      const handler = (argument, context) => {
+        context.inboundBus.pipe((0, rxjs_1.tap)((message) => logger.info(`Input: ${JSON.stringify(message)}`))).subscribe();
+        return job(argument, context).pipe((0, rxjs_1.tap)((message) => logger.info(`Message: ${JSON.stringify(message)}`), (error) => logger.warn(`Error: ${JSON.stringify(error)}`), () => logger.info(`Completed`)));
+      };
+      return Object.assign(handler, job);
+    }
+    exports2.createLoggerJob = createLoggerJob;
+  }
+});
+
+// node_modules/.pnpm/@angular-devkit+architect@0.1702.0/node_modules/@angular-devkit/architect/src/jobs/exception.js
+var require_exception4 = __commonJS({
+  "node_modules/.pnpm/@angular-devkit+architect@0.1702.0/node_modules/@angular-devkit/architect/src/jobs/exception.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.JobDoesNotExistException = exports2.JobNameAlreadyRegisteredException = void 0;
+    var core_1 = require_src2();
+    var JobNameAlreadyRegisteredException = class extends core_1.BaseException {
+      constructor(name) {
+        super(`Job named ${JSON.stringify(name)} already exists.`);
+      }
+    };
+    exports2.JobNameAlreadyRegisteredException = JobNameAlreadyRegisteredException;
+    var JobDoesNotExistException = class extends core_1.BaseException {
+      constructor(name) {
+        super(`Job name ${JSON.stringify(name)} does not exist.`);
+      }
+    };
+    exports2.JobDoesNotExistException = JobDoesNotExistException;
+  }
+});
+
+// node_modules/.pnpm/@angular-devkit+architect@0.1702.0/node_modules/@angular-devkit/architect/src/jobs/dispatcher.js
+var require_dispatcher = __commonJS({
+  "node_modules/.pnpm/@angular-devkit+architect@0.1702.0/node_modules/@angular-devkit/architect/src/jobs/dispatcher.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.createDispatcher = void 0;
+    var api_1 = require_api();
+    var exception_1 = require_exception4();
+    function createDispatcher(options8 = {}) {
+      let defaultDelegate = null;
+      const conditionalDelegateList = [];
+      const job = Object.assign((argument, context) => {
+        const maybeDelegate = conditionalDelegateList.find(([predicate]) => predicate(argument));
+        let delegate = null;
+        if (maybeDelegate) {
+          delegate = context.scheduler.schedule(maybeDelegate[1], argument);
+        } else if (defaultDelegate) {
+          delegate = context.scheduler.schedule(defaultDelegate, argument);
+        } else {
+          throw new exception_1.JobDoesNotExistException("<null>");
+        }
+        context.inboundBus.subscribe(delegate.inboundBus);
+        return delegate.outboundBus;
+      }, {
+        jobDescription: options8
+      });
+      return Object.assign(job, {
+        setDefaultJob(name) {
+          if ((0, api_1.isJobHandler)(name)) {
+            name = name.jobDescription.name === void 0 ? null : name.jobDescription.name;
+          }
+          defaultDelegate = name;
+        },
+        addConditionalJob(predicate, name) {
+          conditionalDelegateList.push([predicate, name]);
+        }
+        // TODO: Remove return-only generic from createDispatcher() API.
+      });
+    }
+    exports2.createDispatcher = createDispatcher;
+  }
+});
+
+// node_modules/.pnpm/@angular-devkit+architect@0.1702.0/node_modules/@angular-devkit/architect/src/jobs/fallback-registry.js
+var require_fallback_registry = __commonJS({
+  "node_modules/.pnpm/@angular-devkit+architect@0.1702.0/node_modules/@angular-devkit/architect/src/jobs/fallback-registry.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.FallbackRegistry = void 0;
+    var rxjs_1 = require_cjs();
+    var FallbackRegistry = class {
+      _fallbacks;
+      constructor(_fallbacks = []) {
+        this._fallbacks = _fallbacks;
+      }
+      addFallback(registry) {
+        this._fallbacks.push(registry);
+      }
+      get(name) {
+        return (0, rxjs_1.from)(this._fallbacks).pipe((0, rxjs_1.concatMap)((fb) => fb.get(name)), (0, rxjs_1.first)((x5) => x5 !== null, null));
+      }
+    };
+    exports2.FallbackRegistry = FallbackRegistry;
+  }
+});
+
+// node_modules/.pnpm/@angular-devkit+architect@0.1702.0/node_modules/@angular-devkit/architect/src/jobs/simple-registry.js
+var require_simple_registry = __commonJS({
+  "node_modules/.pnpm/@angular-devkit+architect@0.1702.0/node_modules/@angular-devkit/architect/src/jobs/simple-registry.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.SimpleJobRegistry = void 0;
+    var core_1 = require_src2();
+    var rxjs_1 = require_cjs();
+    var api_1 = require_api();
+    var exception_1 = require_exception4();
+    var SimpleJobRegistry = class {
+      _jobNames = /* @__PURE__ */ new Map();
+      get(name) {
+        return (0, rxjs_1.of)(this._jobNames.get(name) || null);
+      }
+      register(nameOrHandler, handlerOrOptions = {}, options8 = {}) {
+        if (typeof nameOrHandler == "string") {
+          if (!(0, api_1.isJobHandler)(handlerOrOptions)) {
+            throw new TypeError("Expected a JobHandler as second argument.");
+          }
+          this._register(nameOrHandler, handlerOrOptions, options8);
+        } else if ((0, api_1.isJobHandler)(nameOrHandler)) {
+          if (typeof handlerOrOptions !== "object") {
+            throw new TypeError("Expected an object options as second argument.");
+          }
+          const name = options8.name || nameOrHandler.jobDescription.name || handlerOrOptions.name;
+          if (name === void 0) {
+            throw new TypeError("Expected name to be a string.");
+          }
+          this._register(name, nameOrHandler, options8);
+        } else {
+          throw new TypeError("Unrecognized arguments.");
+        }
+      }
+      _register(name, handler, options8) {
+        if (this._jobNames.has(name)) {
+          throw new exception_1.JobNameAlreadyRegisteredException(name);
+        }
+        const argument = core_1.schema.mergeSchemas(handler.jobDescription.argument, options8.argument);
+        const input = core_1.schema.mergeSchemas(handler.jobDescription.input, options8.input);
+        const output = core_1.schema.mergeSchemas(handler.jobDescription.output, options8.output);
+        const jobDescription = {
+          name,
+          argument,
+          output,
+          input
+        };
+        const jobHandler = Object.assign(handler.bind(void 0), {
+          jobDescription
+        });
+        this._jobNames.set(name, jobHandler);
+      }
+      /**
+       * Returns the job names of all jobs.
+       */
+      getJobNames() {
+        return [...this._jobNames.keys()];
+      }
+    };
+    exports2.SimpleJobRegistry = SimpleJobRegistry;
+  }
+});
+
+// node_modules/.pnpm/@angular-devkit+architect@0.1702.0/node_modules/@angular-devkit/architect/src/jobs/simple-scheduler.js
+var require_simple_scheduler = __commonJS({
+  "node_modules/.pnpm/@angular-devkit+architect@0.1702.0/node_modules/@angular-devkit/architect/src/jobs/simple-scheduler.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.SimpleScheduler = exports2.JobOutputSchemaValidationError = exports2.JobInboundMessageSchemaValidationError = exports2.JobArgumentSchemaValidationError = void 0;
+    var core_1 = require_src2();
+    var rxjs_1 = require_cjs();
+    var api_1 = require_api();
+    var exception_1 = require_exception4();
+    var JobArgumentSchemaValidationError = class extends core_1.schema.SchemaValidationException {
+      constructor(errors) {
+        super(errors, "Job Argument failed to validate. Errors: ");
+      }
+    };
+    exports2.JobArgumentSchemaValidationError = JobArgumentSchemaValidationError;
+    var JobInboundMessageSchemaValidationError = class extends core_1.schema.SchemaValidationException {
+      constructor(errors) {
+        super(errors, "Job Inbound Message failed to validate. Errors: ");
+      }
+    };
+    exports2.JobInboundMessageSchemaValidationError = JobInboundMessageSchemaValidationError;
+    var JobOutputSchemaValidationError = class extends core_1.schema.SchemaValidationException {
+      constructor(errors) {
+        super(errors, "Job Output failed to validate. Errors: ");
+      }
+    };
+    exports2.JobOutputSchemaValidationError = JobOutputSchemaValidationError;
+    function _jobShare() {
+      return (source2) => {
+        let refCount = 0;
+        let subject;
+        let hasError = false;
+        let isComplete = false;
+        let subscription;
+        return new rxjs_1.Observable((subscriber) => {
+          let innerSub;
+          refCount++;
+          if (!subject) {
+            subject = new rxjs_1.Subject();
+            innerSub = subject.subscribe(subscriber);
+            subscription = source2.subscribe({
+              next(value) {
+                subject.next(value);
+              },
+              error(err) {
+                hasError = true;
+                subject.error(err);
+              },
+              complete() {
+                isComplete = true;
+                subject.complete();
+              }
+            });
+          } else {
+            innerSub = subject.subscribe(subscriber);
+          }
+          return () => {
+            refCount--;
+            innerSub.unsubscribe();
+            if (subscription && refCount === 0 && (isComplete || hasError)) {
+              subscription.unsubscribe();
+            }
+          };
+        });
+      };
+    }
+    var SimpleScheduler = class {
+      _jobRegistry;
+      _schemaRegistry;
+      _internalJobDescriptionMap = /* @__PURE__ */ new Map();
+      _queue = [];
+      _pauseCounter = 0;
+      constructor(_jobRegistry, _schemaRegistry = new core_1.schema.CoreSchemaRegistry()) {
+        this._jobRegistry = _jobRegistry;
+        this._schemaRegistry = _schemaRegistry;
+      }
+      _getInternalDescription(name) {
+        const maybeHandler = this._internalJobDescriptionMap.get(name);
+        if (maybeHandler !== void 0) {
+          return (0, rxjs_1.of)(maybeHandler);
+        }
+        const handler = this._jobRegistry.get(name);
+        return handler.pipe((0, rxjs_1.switchMap)((handler2) => {
+          if (handler2 === null) {
+            return (0, rxjs_1.of)(null);
+          }
+          const description = {
+            // Make a copy of it to be sure it's proper JSON.
+            ...JSON.parse(JSON.stringify(handler2.jobDescription)),
+            name: handler2.jobDescription.name || name,
+            argument: handler2.jobDescription.argument || true,
+            input: handler2.jobDescription.input || true,
+            output: handler2.jobDescription.output || true,
+            channels: handler2.jobDescription.channels || {}
+          };
+          const handlerWithExtra = Object.assign(handler2.bind(void 0), {
+            jobDescription: description,
+            argumentV: this._schemaRegistry.compile(description.argument),
+            inputV: this._schemaRegistry.compile(description.input),
+            outputV: this._schemaRegistry.compile(description.output)
+          });
+          this._internalJobDescriptionMap.set(name, handlerWithExtra);
+          return (0, rxjs_1.of)(handlerWithExtra);
+        }));
+      }
+      /**
+       * Get a job description for a named job.
+       *
+       * @param name The name of the job.
+       * @returns A description, or null if the job is not registered.
+       */
+      getDescription(name) {
+        return (0, rxjs_1.concat)(this._getInternalDescription(name).pipe((0, rxjs_1.map)((x5) => x5 && x5.jobDescription)), (0, rxjs_1.of)(null)).pipe((0, rxjs_1.first)());
+      }
+      /**
+       * Returns true if the job name has been registered.
+       * @param name The name of the job.
+       * @returns True if the job exists, false otherwise.
+       */
+      has(name) {
+        return this.getDescription(name).pipe((0, rxjs_1.map)((x5) => x5 !== null));
+      }
+      /**
+       * Pause the scheduler, temporary queueing _new_ jobs. Returns a resume function that should be
+       * used to resume execution. If multiple `pause()` were called, all their resume functions must
+       * be called before the Scheduler actually starts new jobs. Additional calls to the same resume
+       * function will have no effect.
+       *
+       * Jobs already running are NOT paused. This is pausing the scheduler only.
+       */
+      pause() {
+        let called = false;
+        this._pauseCounter++;
+        return () => {
+          if (!called) {
+            called = true;
+            if (--this._pauseCounter == 0) {
+              const q9 = this._queue;
+              this._queue = [];
+              q9.forEach((fn6) => fn6());
+            }
+          }
+        };
+      }
+      /**
+       * Schedule a job to be run, using its name.
+       * @param name The name of job to be run.
+       * @param argument The argument to send to the job when starting it.
+       * @param options Scheduling options.
+       * @returns The Job being run.
+       */
+      schedule(name, argument, options8) {
+        if (this._pauseCounter > 0) {
+          const waitable = new rxjs_1.Subject();
+          this._queue.push(() => waitable.complete());
+          return this._scheduleJob(name, argument, options8 || {}, waitable);
+        }
+        return this._scheduleJob(name, argument, options8 || {}, rxjs_1.EMPTY);
+      }
+      /**
+       * Filter messages.
+       * @private
+       */
+      _filterJobOutboundMessages(message, state) {
+        switch (message.kind) {
+          case api_1.JobOutboundMessageKind.OnReady:
+            return state == api_1.JobState.Queued;
+          case api_1.JobOutboundMessageKind.Start:
+            return state == api_1.JobState.Ready;
+          case api_1.JobOutboundMessageKind.End:
+            return state == api_1.JobState.Started || state == api_1.JobState.Ready;
+        }
+        return true;
+      }
+      /**
+       * Return a new state. This is just to simplify the reading of the _createJob method.
+       * @private
+       */
+      _updateState(message, state) {
+        switch (message.kind) {
+          case api_1.JobOutboundMessageKind.OnReady:
+            return api_1.JobState.Ready;
+          case api_1.JobOutboundMessageKind.Start:
+            return api_1.JobState.Started;
+          case api_1.JobOutboundMessageKind.End:
+            return api_1.JobState.Ended;
+        }
+        return state;
+      }
+      /**
+       * Create the job.
+       * @private
+       */
+      // eslint-disable-next-line max-lines-per-function
+      _createJob(name, argument, handler, inboundBus, outboundBus) {
+        const schemaRegistry = this._schemaRegistry;
+        const channelsSubject = /* @__PURE__ */ new Map();
+        const channels = /* @__PURE__ */ new Map();
+        let state = api_1.JobState.Queued;
+        let pingId = 0;
+        const input = new rxjs_1.Subject();
+        input.pipe((0, rxjs_1.concatMap)((message) => handler.pipe((0, rxjs_1.switchMap)(async (handler2) => {
+          if (handler2 === null) {
+            throw new exception_1.JobDoesNotExistException(name);
+          }
+          const validator = await handler2.inputV;
+          return validator(message);
+        }))), (0, rxjs_1.filter)((result) => result.success), (0, rxjs_1.map)((result) => result.data)).subscribe((value) => inboundBus.next({ kind: api_1.JobInboundMessageKind.Input, value }));
+        outboundBus = (0, rxjs_1.concat)(
+          outboundBus,
+          // Add an End message at completion. This will be filtered out if the job actually send an
+          // End.
+          handler.pipe((0, rxjs_1.switchMap)((handler2) => {
+            if (handler2) {
+              return (0, rxjs_1.of)({
+                kind: api_1.JobOutboundMessageKind.End,
+                description: handler2.jobDescription
+              });
+            } else {
+              return rxjs_1.EMPTY;
+            }
+          }))
+        ).pipe(
+          (0, rxjs_1.filter)((message) => this._filterJobOutboundMessages(message, state)),
+          // Update internal logic and Job<> members.
+          (0, rxjs_1.tap)((message) => {
+            state = this._updateState(message, state);
+            switch (message.kind) {
+              case api_1.JobOutboundMessageKind.ChannelCreate: {
+                const maybeSubject = channelsSubject.get(message.name);
+                if (!maybeSubject) {
+                  const s = new rxjs_1.Subject();
+                  channelsSubject.set(message.name, s);
+                  channels.set(message.name, s.asObservable());
+                }
+                break;
+              }
+              case api_1.JobOutboundMessageKind.ChannelMessage: {
+                const maybeSubject = channelsSubject.get(message.name);
+                if (maybeSubject) {
+                  maybeSubject.next(message.message);
+                }
+                break;
+              }
+              case api_1.JobOutboundMessageKind.ChannelComplete: {
+                const maybeSubject = channelsSubject.get(message.name);
+                if (maybeSubject) {
+                  maybeSubject.complete();
+                  channelsSubject.delete(message.name);
+                }
+                break;
+              }
+              case api_1.JobOutboundMessageKind.ChannelError: {
+                const maybeSubject = channelsSubject.get(message.name);
+                if (maybeSubject) {
+                  maybeSubject.error(message.error);
+                  channelsSubject.delete(message.name);
+                }
+                break;
+              }
+            }
+          }, () => {
+            state = api_1.JobState.Errored;
+          }),
+          // Do output validation (might include default values so this might have side
+          // effects). We keep all messages in order.
+          (0, rxjs_1.concatMap)((message) => {
+            if (message.kind !== api_1.JobOutboundMessageKind.Output) {
+              return (0, rxjs_1.of)(message);
+            }
+            return handler.pipe((0, rxjs_1.switchMap)(async (handler2) => {
+              if (handler2 === null) {
+                throw new exception_1.JobDoesNotExistException(name);
+              }
+              const validate = await handler2.outputV;
+              const output2 = await validate(message.value);
+              if (!output2.success) {
+                throw new JobOutputSchemaValidationError(output2.errors);
+              }
+              return {
+                ...message,
+                output: output2.data
+              };
+            }));
+          }),
+          _jobShare()
+        );
+        const output = outboundBus.pipe((0, rxjs_1.filter)((x5) => x5.kind == api_1.JobOutboundMessageKind.Output), (0, rxjs_1.map)((x5) => x5.value), (0, rxjs_1.shareReplay)(1));
+        return {
+          get state() {
+            return state;
+          },
+          argument,
+          description: handler.pipe((0, rxjs_1.switchMap)((handler2) => {
+            if (handler2 === null) {
+              throw new exception_1.JobDoesNotExistException(name);
+            } else {
+              return (0, rxjs_1.of)(handler2.jobDescription);
+            }
+          })),
+          output,
+          getChannel(name2, schema2 = true) {
+            let maybeObservable = channels.get(name2);
+            if (!maybeObservable) {
+              const s = new rxjs_1.Subject();
+              channelsSubject.set(name2, s);
+              channels.set(name2, s.asObservable());
+              maybeObservable = s.asObservable();
+            }
+            return maybeObservable.pipe(
+              // Keep the order of messages.
+              (0, rxjs_1.concatMap)((message) => {
+                return (0, rxjs_1.from)(schemaRegistry.compile(schema2)).pipe((0, rxjs_1.switchMap)((validate) => validate(message)), (0, rxjs_1.filter)((x5) => x5.success), (0, rxjs_1.map)((x5) => x5.data));
+              })
+            );
+          },
+          ping() {
+            const id = pingId++;
+            inboundBus.next({ kind: api_1.JobInboundMessageKind.Ping, id });
+            return outboundBus.pipe((0, rxjs_1.filter)((x5) => x5.kind === api_1.JobOutboundMessageKind.Pong && x5.id == id), (0, rxjs_1.first)(), (0, rxjs_1.ignoreElements)());
+          },
+          stop() {
+            inboundBus.next({ kind: api_1.JobInboundMessageKind.Stop });
+          },
+          input,
+          inboundBus,
+          outboundBus
+        };
+      }
+      _scheduleJob(name, argument, options8, waitable) {
+        const handler = this._getInternalDescription(name);
+        const optionsDeps = options8 && options8.dependencies || [];
+        const dependencies = Array.isArray(optionsDeps) ? optionsDeps : [optionsDeps];
+        const inboundBus = new rxjs_1.Subject();
+        const outboundBus = (0, rxjs_1.concat)(
+          // Wait for dependencies, make sure to not report messages from dependencies. Subscribe to
+          // all dependencies at the same time so they run concurrently.
+          (0, rxjs_1.merge)(...dependencies.map((x5) => x5.outboundBus)).pipe((0, rxjs_1.ignoreElements)()),
+          // Wait for pause() to clear (if necessary).
+          waitable,
+          (0, rxjs_1.from)(handler).pipe((0, rxjs_1.switchMap)((handler2) => new rxjs_1.Observable((subscriber) => {
+            if (!handler2) {
+              throw new exception_1.JobDoesNotExistException(name);
+            }
+            return (0, rxjs_1.from)(handler2.argumentV).pipe((0, rxjs_1.switchMap)((validate) => validate(argument)), (0, rxjs_1.switchMap)((output) => {
+              if (!output.success) {
+                throw new JobArgumentSchemaValidationError(output.errors);
+              }
+              const argument2 = output.data;
+              const description = handler2.jobDescription;
+              subscriber.next({ kind: api_1.JobOutboundMessageKind.OnReady, description });
+              const context = {
+                description,
+                dependencies: [...dependencies],
+                inboundBus: inboundBus.asObservable(),
+                scheduler: this
+              };
+              return handler2(argument2, context);
+            })).subscribe(subscriber);
+          })))
+        );
+        return this._createJob(name, argument, handler, inboundBus, outboundBus);
+      }
+    };
+    exports2.SimpleScheduler = SimpleScheduler;
+  }
+});
+
+// node_modules/.pnpm/@angular-devkit+architect@0.1702.0/node_modules/@angular-devkit/architect/src/jobs/index.js
+var require_jobs = __commonJS({
+  "node_modules/.pnpm/@angular-devkit+architect@0.1702.0/node_modules/@angular-devkit/architect/src/jobs/index.js"(exports2) {
+    "use strict";
+    var __createBinding2 = exports2 && exports2.__createBinding || (Object.create ? function(o2, m2, k6, k23) {
+      if (k23 === void 0)
+        k23 = k6;
+      var desc = Object.getOwnPropertyDescriptor(m2, k6);
+      if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m2[k6];
+        } };
+      }
+      Object.defineProperty(o2, k23, desc);
+    } : function(o2, m2, k6, k23) {
+      if (k23 === void 0)
+        k23 = k6;
+      o2[k23] = m2[k6];
+    });
+    var __setModuleDefault2 = exports2 && exports2.__setModuleDefault || (Object.create ? function(o2, v5) {
+      Object.defineProperty(o2, "default", { enumerable: true, value: v5 });
+    } : function(o2, v5) {
+      o2["default"] = v5;
+    });
+    var __importStar2 = exports2 && exports2.__importStar || function(mod) {
+      if (mod && mod.__esModule)
+        return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k6 in mod)
+          if (k6 !== "default" && Object.prototype.hasOwnProperty.call(mod, k6))
+            __createBinding2(result, mod, k6);
+      }
+      __setModuleDefault2(result, mod);
+      return result;
+    };
+    var __exportStar2 = exports2 && exports2.__exportStar || function(m2, exports3) {
+      for (var p4 in m2)
+        if (p4 !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p4))
+          __createBinding2(exports3, m2, p4);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.strategy = void 0;
+    var strategy = __importStar2(require_strategy());
+    exports2.strategy = strategy;
+    __exportStar2(require_api(), exports2);
+    __exportStar2(require_create_job_handler(), exports2);
+    __exportStar2(require_exception4(), exports2);
+    __exportStar2(require_dispatcher(), exports2);
+    __exportStar2(require_fallback_registry(), exports2);
+    __exportStar2(require_simple_registry(), exports2);
+    __exportStar2(require_simple_scheduler(), exports2);
+  }
+});
+
+// node_modules/.pnpm/@angular-devkit+architect@0.1702.0/node_modules/@angular-devkit/architect/src/progress-schema.js
+var require_progress_schema = __commonJS({
+  "node_modules/.pnpm/@angular-devkit+architect@0.1702.0/node_modules/@angular-devkit/architect/src/progress-schema.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.State = void 0;
+    var State;
+    (function(State2) {
+      State2["Error"] = "error";
+      State2["Running"] = "running";
+      State2["Stopped"] = "stopped";
+      State2["Waiting"] = "waiting";
+    })(State || (exports2.State = State = {}));
+  }
+});
+
+// node_modules/.pnpm/@angular-devkit+architect@0.1702.0/node_modules/@angular-devkit/architect/src/api.js
+var require_api2 = __commonJS({
+  "node_modules/.pnpm/@angular-devkit+architect@0.1702.0/node_modules/@angular-devkit/architect/src/api.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.scheduleTargetAndForget = exports2.targetFromTargetString = exports2.targetStringFromTarget = exports2.fromAsyncIterable = exports2.isBuilderOutput = exports2.BuilderProgressState = void 0;
+    var rxjs_1 = require_cjs();
+    var progress_schema_1 = require_progress_schema();
+    Object.defineProperty(exports2, "BuilderProgressState", { enumerable: true, get: function() {
+      return progress_schema_1.State;
+    } });
+    function isBuilderOutput(obj) {
+      if (!obj || typeof obj.then === "function" || typeof obj.subscribe === "function") {
+        return false;
+      }
+      if (typeof obj[Symbol.asyncIterator] === "function") {
+        return false;
+      }
+      return typeof obj.success === "boolean";
+    }
+    exports2.isBuilderOutput = isBuilderOutput;
+    function fromAsyncIterable(iterable) {
+      return new rxjs_1.Observable((subscriber) => {
+        handleAsyncIterator(subscriber, iterable[Symbol.asyncIterator]()).then(() => subscriber.complete(), (error) => subscriber.error(error));
+      });
+    }
+    exports2.fromAsyncIterable = fromAsyncIterable;
+    async function handleAsyncIterator(subscriber, iterator) {
+      const teardown = new Promise((resolve3) => subscriber.add(() => resolve3()));
+      try {
+        while (!subscriber.closed) {
+          const result = await Promise.race([teardown, iterator.next()]);
+          if (!result || result.done) {
+            break;
+          }
+          subscriber.next(result.value);
+        }
+      } finally {
+        await iterator.return?.();
+      }
+    }
+    function targetStringFromTarget({ project, target, configuration }) {
+      return `${project}:${target}${configuration !== void 0 ? ":" + configuration : ""}`;
+    }
+    exports2.targetStringFromTarget = targetStringFromTarget;
+    function targetFromTargetString(specifier, abbreviatedProjectName, abbreviatedTargetName) {
+      const tuple = specifier.split(":", 3);
+      if (tuple.length < 2) {
+        throw new Error("Invalid target string: " + JSON.stringify(specifier));
+      }
+      return {
+        project: tuple[0] || abbreviatedProjectName || "",
+        target: tuple[1] || abbreviatedTargetName || "",
+        ...tuple[2] !== void 0 && { configuration: tuple[2] }
+      };
+    }
+    exports2.targetFromTargetString = targetFromTargetString;
+    function scheduleTargetAndForget(context, target, overrides, scheduleOptions) {
+      let resolve3 = null;
+      const promise = new Promise((r4) => resolve3 = r4);
+      context.addTeardown(() => promise);
+      return (0, rxjs_1.from)(context.scheduleTarget(target, overrides, scheduleOptions)).pipe((0, rxjs_1.switchMap)((run2) => new rxjs_1.Observable((observer) => {
+        const subscription = run2.output.subscribe(observer);
+        return () => {
+          subscription.unsubscribe();
+          run2.stop().then(resolve3);
+        };
+      })));
+    }
+    exports2.scheduleTargetAndForget = scheduleTargetAndForget;
+  }
+});
+
+// node_modules/.pnpm/@angular-devkit+architect@0.1702.0/node_modules/@angular-devkit/architect/src/progress-schema.json
+var require_progress_schema2 = __commonJS({
+  "node_modules/.pnpm/@angular-devkit+architect@0.1702.0/node_modules/@angular-devkit/architect/src/progress-schema.json"(exports2, module2) {
+    module2.exports = {
+      $schema: "http://json-schema.org/draft-07/schema",
+      $id: "BuilderProgressSchema",
+      title: "Progress schema for builders.",
+      type: "object",
+      allOf: [
+        {
+          type: "object",
+          oneOf: [
+            {
+              type: "object",
+              properties: {
+                state: {
+                  type: "string",
+                  enum: ["stopped"]
+                }
+              },
+              required: ["state"]
+            },
+            {
+              type: "object",
+              properties: {
+                state: {
+                  type: "string",
+                  enum: ["waiting"]
+                },
+                status: {
+                  type: "string"
+                }
+              },
+              required: ["state"]
+            },
+            {
+              type: "object",
+              properties: {
+                state: {
+                  type: "string",
+                  enum: ["running"]
+                },
+                current: {
+                  type: "number",
+                  minimum: 0
+                },
+                total: {
+                  type: "number",
+                  minimum: 0
+                },
+                status: {
+                  type: "string"
+                }
+              },
+              required: ["state"]
+            },
+            {
+              type: "object",
+              properties: {
+                state: {
+                  type: "string",
+                  enum: ["error"]
+                },
+                error: true
+              },
+              required: ["state"]
+            }
+          ]
+        },
+        {
+          type: "object",
+          properties: {
+            builder: {
+              type: "object"
+            },
+            target: {
+              type: "object"
+            },
+            id: {
+              type: "number"
+            }
+          },
+          required: ["builder", "id"]
+        }
+      ]
+    };
+  }
+});
+
+// node_modules/.pnpm/@angular-devkit+architect@0.1702.0/node_modules/@angular-devkit/architect/src/schedule-by-name.js
+var require_schedule_by_name = __commonJS({
+  "node_modules/.pnpm/@angular-devkit+architect@0.1702.0/node_modules/@angular-devkit/architect/src/schedule-by-name.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.scheduleByTarget = exports2.scheduleByName = void 0;
+    var rxjs_1 = require_cjs();
+    var api_1 = require_api2();
+    var jobs_1 = require_jobs();
+    var progressSchema = require_progress_schema2();
+    var _uniqueId = 0;
+    async function scheduleByName(name, buildOptions, options8) {
+      const childLoggerName = options8.target ? `{${(0, api_1.targetStringFromTarget)(options8.target)}}` : name;
+      const logger = options8.logger.createChild(childLoggerName);
+      const job = options8.scheduler.schedule(name, {});
+      let stateSubscription;
+      const workspaceRoot = await options8.workspaceRoot;
+      const currentDirectory = await options8.currentDirectory;
+      const description = await (0, rxjs_1.firstValueFrom)(job.description);
+      const info = description.info;
+      const id = ++_uniqueId;
+      const message = {
+        id,
+        currentDirectory,
+        workspaceRoot,
+        info,
+        options: buildOptions,
+        ...options8.target ? { target: options8.target } : {}
+      };
+      if (job.state !== jobs_1.JobState.Started) {
+        stateSubscription = job.outboundBus.subscribe({
+          next: (event) => {
+            if (event.kind === jobs_1.JobOutboundMessageKind.Start) {
+              job.input.next(message);
+            }
+          },
+          error: () => {
+          }
+        });
+      } else {
+        job.input.next(message);
+      }
+      const logChannelSub = job.getChannel("log").subscribe({
+        next: (entry) => {
+          logger.next(entry);
+        },
+        error: () => {
+        }
+      });
+      const outboundBusSub = job.outboundBus.subscribe({
+        error() {
+        },
+        complete() {
+          outboundBusSub.unsubscribe();
+          logChannelSub.unsubscribe();
+          stateSubscription.unsubscribe();
+        }
+      });
+      const output = job.output.pipe((0, rxjs_1.map)((output2) => ({
+        ...output2,
+        ...options8.target ? { target: options8.target } : 0,
+        info
+      })), (0, rxjs_1.shareReplay)());
+      output.pipe((0, rxjs_1.first)()).subscribe({
+        error: () => {
+        }
+      });
+      return {
+        id,
+        info,
+        // This is a getter so that it always returns the next output, and not the same one.
+        get result() {
+          return (0, rxjs_1.firstValueFrom)(output);
+        },
+        get lastOutput() {
+          return (0, rxjs_1.lastValueFrom)(output);
+        },
+        output,
+        progress: job.getChannel("progress", progressSchema).pipe((0, rxjs_1.shareReplay)(1)),
+        stop() {
+          job.stop();
+          return job.outboundBus.pipe((0, rxjs_1.ignoreElements)(), (0, rxjs_1.catchError)(() => rxjs_1.EMPTY)).toPromise();
+        }
+      };
+    }
+    exports2.scheduleByName = scheduleByName;
+    async function scheduleByTarget(target, overrides, options8) {
+      return scheduleByName(`{${(0, api_1.targetStringFromTarget)(target)}}`, overrides, {
+        ...options8,
+        target,
+        logger: options8.logger
+      });
+    }
+    exports2.scheduleByTarget = scheduleByTarget;
+  }
+});
+
+// node_modules/.pnpm/@angular-devkit+architect@0.1702.0/node_modules/@angular-devkit/architect/src/input-schema.json
+var require_input_schema = __commonJS({
+  "node_modules/.pnpm/@angular-devkit+architect@0.1702.0/node_modules/@angular-devkit/architect/src/input-schema.json"(exports2, module2) {
+    module2.exports = {
+      $schema: "http://json-schema.org/draft-07/schema",
+      $id: "BuilderInputSchema",
+      title: "Input schema for builders.",
+      type: "object",
+      properties: {
+        workspaceRoot: {
+          type: "string"
+        },
+        currentDirectory: {
+          type: "string"
+        },
+        id: {
+          type: "number"
+        },
+        target: {
+          type: "object",
+          properties: {
+            project: {
+              type: "string"
+            },
+            target: {
+              type: "string"
+            },
+            configuration: {
+              type: "string"
+            }
+          },
+          required: ["project", "target"]
+        },
+        info: {
+          type: "object"
+        },
+        options: {
+          type: "object"
+        }
+      },
+      required: ["currentDirectory", "id", "info", "workspaceRoot"]
+    };
+  }
+});
+
+// node_modules/.pnpm/@angular-devkit+architect@0.1702.0/node_modules/@angular-devkit/architect/src/output-schema.json
+var require_output_schema = __commonJS({
+  "node_modules/.pnpm/@angular-devkit+architect@0.1702.0/node_modules/@angular-devkit/architect/src/output-schema.json"(exports2, module2) {
+    module2.exports = {
+      $schema: "http://json-schema.org/draft-07/schema",
+      $id: "BuilderOutputSchema",
+      title: "Output schema for builders.",
+      type: "object",
+      properties: {
+        success: {
+          type: "boolean"
+        },
+        error: {
+          type: "string"
+        },
+        target: {
+          type: "object",
+          properties: {
+            project: {
+              type: "string"
+            },
+            target: {
+              type: "string"
+            },
+            configuration: {
+              type: "string"
+            }
+          }
+        },
+        info: {
+          type: "object"
+        }
+      },
+      additionalProperties: true,
+      required: ["success"]
+    };
+  }
+});
+
+// node_modules/.pnpm/@angular-devkit+architect@0.1702.0/node_modules/@angular-devkit/architect/src/architect.js
+var require_architect = __commonJS({
+  "node_modules/.pnpm/@angular-devkit+architect@0.1702.0/node_modules/@angular-devkit/architect/src/architect.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.Architect = void 0;
+    var core_1 = require_src2();
+    var rxjs_1 = require_cjs();
+    var api_1 = require_api2();
+    var jobs_1 = require_jobs();
+    var schedule_by_name_1 = require_schedule_by_name();
+    var inputSchema = require_input_schema();
+    var outputSchema = require_output_schema();
+    function _createJobHandlerFromBuilderInfo(info, target, host, registry, baseOptions) {
+      const jobDescription = {
+        name: target ? `{${(0, api_1.targetStringFromTarget)(target)}}` : info.builderName,
+        argument: { type: "object" },
+        input: inputSchema,
+        output: outputSchema,
+        info
+      };
+      function handler(argument, context) {
+        const inboundBusWithInputValidation = context.inboundBus.pipe(
+          (0, rxjs_1.concatMap)(async (message) => {
+            if (message.kind === jobs_1.JobInboundMessageKind.Input) {
+              const v5 = message.value;
+              const options8 = {
+                ...baseOptions,
+                ...v5.options
+              };
+              const validation = await registry.compile(info.optionSchema);
+              const validationResult = await validation(options8);
+              const { data, success, errors } = validationResult;
+              if (!success) {
+                throw new core_1.json.schema.SchemaValidationException(errors);
+              }
+              return { ...message, value: { ...v5, options: data } };
+            } else {
+              return message;
+            }
+          }),
+          // Using a share replay because the job might be synchronously sending input, but
+          // asynchronously listening to it.
+          (0, rxjs_1.shareReplay)(1)
+        );
+        const inboundBus = (0, rxjs_1.onErrorResumeNext)(inboundBusWithInputValidation);
+        const output = (0, rxjs_1.from)(host.loadBuilder(info)).pipe(
+          (0, rxjs_1.concatMap)((builder) => {
+            if (builder === null) {
+              throw new Error(`Cannot load builder for builderInfo ${JSON.stringify(info, null, 2)}`);
+            }
+            return builder.handler(argument, { ...context, inboundBus }).pipe((0, rxjs_1.map)((output2) => {
+              if (output2.kind === jobs_1.JobOutboundMessageKind.Output) {
+                return {
+                  ...output2,
+                  value: {
+                    ...output2.value,
+                    ...target ? { target } : 0
+                  }
+                };
+              } else {
+                return output2;
+              }
+            }));
+          }),
+          // Share subscriptions to the output, otherwise the handler will be re-run.
+          (0, rxjs_1.shareReplay)()
+        );
+        const inboundBusErrors = inboundBusWithInputValidation.pipe((0, rxjs_1.ignoreElements)(), (0, rxjs_1.takeUntil)((0, rxjs_1.onErrorResumeNext)(output.pipe((0, rxjs_1.last)()))));
+        return (0, rxjs_1.merge)(inboundBusErrors, output);
+      }
+      return (0, rxjs_1.of)(Object.assign(handler, { jobDescription }));
+    }
+    var ArchitectBuilderJobRegistry = class {
+      _host;
+      _registry;
+      _jobCache;
+      _infoCache;
+      constructor(_host, _registry, _jobCache, _infoCache) {
+        this._host = _host;
+        this._registry = _registry;
+        this._jobCache = _jobCache;
+        this._infoCache = _infoCache;
+      }
+      _resolveBuilder(name) {
+        const cache3 = this._infoCache;
+        if (cache3) {
+          const maybeCache = cache3.get(name);
+          if (maybeCache !== void 0) {
+            return maybeCache;
+          }
+          const info = (0, rxjs_1.from)(this._host.resolveBuilder(name)).pipe((0, rxjs_1.shareReplay)(1));
+          cache3.set(name, info);
+          return info;
+        }
+        return (0, rxjs_1.from)(this._host.resolveBuilder(name));
+      }
+      _createBuilder(info, target, options8) {
+        const cache3 = this._jobCache;
+        if (target) {
+          const maybeHit = cache3 && cache3.get((0, api_1.targetStringFromTarget)(target));
+          if (maybeHit) {
+            return maybeHit;
+          }
+        } else {
+          const maybeHit = cache3 && cache3.get(info.builderName);
+          if (maybeHit) {
+            return maybeHit;
+          }
+        }
+        const result = _createJobHandlerFromBuilderInfo(info, target, this._host, this._registry, options8 || {});
+        if (cache3) {
+          if (target) {
+            cache3.set((0, api_1.targetStringFromTarget)(target), result.pipe((0, rxjs_1.shareReplay)(1)));
+          } else {
+            cache3.set(info.builderName, result.pipe((0, rxjs_1.shareReplay)(1)));
+          }
+        }
+        return result;
+      }
+      get(name) {
+        const m2 = name.match(/^([^:]+):([^:]+)$/i);
+        if (!m2) {
+          return (0, rxjs_1.of)(null);
+        }
+        return (0, rxjs_1.from)(this._resolveBuilder(name)).pipe((0, rxjs_1.concatMap)((builderInfo) => builderInfo ? this._createBuilder(builderInfo) : (0, rxjs_1.of)(null)), (0, rxjs_1.first)(null, null));
+      }
+    };
+    var ArchitectTargetJobRegistry = class extends ArchitectBuilderJobRegistry {
+      get(name) {
+        const m2 = name.match(/^{([^:]+):([^:]+)(?::([^:]*))?}$/i);
+        if (!m2) {
+          return (0, rxjs_1.of)(null);
+        }
+        const target = {
+          project: m2[1],
+          target: m2[2],
+          configuration: m2[3]
+        };
+        return (0, rxjs_1.from)(Promise.all([
+          this._host.getBuilderNameForTarget(target),
+          this._host.getOptionsForTarget(target)
+        ])).pipe((0, rxjs_1.concatMap)(([builderStr, options8]) => {
+          if (builderStr === null || options8 === null) {
+            return (0, rxjs_1.of)(null);
+          }
+          return this._resolveBuilder(builderStr).pipe((0, rxjs_1.concatMap)((builderInfo) => {
+            if (builderInfo === null) {
+              return (0, rxjs_1.of)(null);
+            }
+            return this._createBuilder(builderInfo, target, options8);
+          }));
+        }), (0, rxjs_1.first)(null, null));
+      }
+    };
+    function _getTargetOptionsFactory(host) {
+      return (0, jobs_1.createJobHandler)((target) => {
+        return host.getOptionsForTarget(target).then((options8) => {
+          if (options8 === null) {
+            throw new Error(`Invalid target: ${JSON.stringify(target)}.`);
+          }
+          return options8;
+        });
+      }, {
+        name: "..getTargetOptions",
+        output: { type: "object" },
+        argument: inputSchema.properties.target
+      });
+    }
+    function _getProjectMetadataFactory(host) {
+      return (0, jobs_1.createJobHandler)((target) => {
+        return host.getProjectMetadata(target).then((options8) => {
+          if (options8 === null) {
+            throw new Error(`Invalid target: ${JSON.stringify(target)}.`);
+          }
+          return options8;
+        });
+      }, {
+        name: "..getProjectMetadata",
+        output: { type: "object" },
+        argument: {
+          oneOf: [{ type: "string" }, inputSchema.properties.target]
+        }
+      });
+    }
+    function _getBuilderNameForTargetFactory(host) {
+      return (0, jobs_1.createJobHandler)(async (target) => {
+        const builderName = await host.getBuilderNameForTarget(target);
+        if (!builderName) {
+          throw new Error(`No builder were found for target ${(0, api_1.targetStringFromTarget)(target)}.`);
+        }
+        return builderName;
+      }, {
+        name: "..getBuilderNameForTarget",
+        output: { type: "string" },
+        argument: inputSchema.properties.target
+      });
+    }
+    function _validateOptionsFactory(host, registry) {
+      return (0, jobs_1.createJobHandler)(async ([builderName, options8]) => {
+        const builderInfo = await host.resolveBuilder(builderName);
+        if (!builderInfo) {
+          throw new Error(`No builder info were found for builder ${JSON.stringify(builderName)}.`);
+        }
+        const validation = await registry.compile(builderInfo.optionSchema);
+        const { data, success, errors } = await validation(options8);
+        if (!success) {
+          throw new core_1.json.schema.SchemaValidationException(errors);
+        }
+        return data;
+      }, {
+        name: "..validateOptions",
+        output: { type: "object" },
+        argument: {
+          type: "array",
+          items: [{ type: "string" }, { type: "object" }]
+        }
+      });
+    }
+    var Architect = class {
+      _host;
+      _scheduler;
+      _jobCache = /* @__PURE__ */ new Map();
+      _infoCache = /* @__PURE__ */ new Map();
+      constructor(_host, registry = new core_1.json.schema.CoreSchemaRegistry(), additionalJobRegistry) {
+        this._host = _host;
+        const privateArchitectJobRegistry = new jobs_1.SimpleJobRegistry();
+        privateArchitectJobRegistry.register(_getTargetOptionsFactory(_host));
+        privateArchitectJobRegistry.register(_getBuilderNameForTargetFactory(_host));
+        privateArchitectJobRegistry.register(_validateOptionsFactory(_host, registry));
+        privateArchitectJobRegistry.register(_getProjectMetadataFactory(_host));
+        const jobRegistry = new jobs_1.FallbackRegistry([
+          new ArchitectTargetJobRegistry(_host, registry, this._jobCache, this._infoCache),
+          new ArchitectBuilderJobRegistry(_host, registry, this._jobCache, this._infoCache),
+          privateArchitectJobRegistry,
+          ...additionalJobRegistry ? [additionalJobRegistry] : []
+        ]);
+        this._scheduler = new jobs_1.SimpleScheduler(jobRegistry, registry);
+      }
+      has(name) {
+        return this._scheduler.has(name);
+      }
+      scheduleBuilder(name, options8, scheduleOptions = {}) {
+        if (!/^[^:]+:[^:]+(:[^:]+)?$/.test(name)) {
+          throw new Error("Invalid builder name: " + JSON.stringify(name));
+        }
+        return (0, schedule_by_name_1.scheduleByName)(name, options8, {
+          scheduler: this._scheduler,
+          logger: scheduleOptions.logger || new core_1.logging.NullLogger(),
+          currentDirectory: this._host.getCurrentDirectory(),
+          workspaceRoot: this._host.getWorkspaceRoot()
+        });
+      }
+      scheduleTarget(target, overrides = {}, scheduleOptions = {}) {
+        return (0, schedule_by_name_1.scheduleByTarget)(target, overrides, {
+          scheduler: this._scheduler,
+          logger: scheduleOptions.logger || new core_1.logging.NullLogger(),
+          currentDirectory: this._host.getCurrentDirectory(),
+          workspaceRoot: this._host.getWorkspaceRoot()
+        });
+      }
+    };
+    exports2.Architect = Architect;
+  }
+});
+
+// node_modules/.pnpm/@angular-devkit+architect@0.1702.0/node_modules/@angular-devkit/architect/src/internal.js
+var require_internal = __commonJS({
+  "node_modules/.pnpm/@angular-devkit+architect@0.1702.0/node_modules/@angular-devkit/architect/src/internal.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.BuilderVersionSymbol = exports2.BuilderSymbol = void 0;
+    exports2.BuilderSymbol = Symbol.for("@angular-devkit/architect:builder");
+    exports2.BuilderVersionSymbol = Symbol.for("@angular-devkit/architect:version");
+  }
+});
+
+// node_modules/.pnpm/@angular-devkit+architect@0.1702.0/node_modules/@angular-devkit/architect/package.json
+var require_package3 = __commonJS({
+  "node_modules/.pnpm/@angular-devkit+architect@0.1702.0/node_modules/@angular-devkit/architect/package.json"(exports2, module2) {
+    module2.exports = {
+      name: "@angular-devkit/architect",
+      version: "0.1702.0",
+      description: "Angular Build Facade",
+      experimental: true,
+      main: "src/index.js",
+      typings: "src/index.d.ts",
+      dependencies: {
+        "@angular-devkit/core": "17.2.0",
+        rxjs: "7.8.1"
+      },
+      builders: "./builders/builders.json",
+      keywords: [
+        "Angular CLI",
+        "Angular DevKit",
+        "angular",
+        "devkit",
+        "sdk"
+      ],
+      repository: {
+        type: "git",
+        url: "https://github.com/angular/angular-cli.git"
+      },
+      engines: {
+        node: "^18.13.0 || >=20.9.0",
+        npm: "^6.11.0 || ^7.5.6 || >=8.0.0",
+        yarn: ">= 1.13.0"
+      },
+      author: "Angular Authors",
+      license: "MIT",
+      bugs: {
+        url: "https://github.com/angular/angular-cli/issues"
+      },
+      homepage: "https://github.com/angular/angular-cli"
+    };
+  }
+});
+
+// node_modules/.pnpm/@angular-devkit+architect@0.1702.0/node_modules/@angular-devkit/architect/src/create-builder.js
+var require_create_builder = __commonJS({
+  "node_modules/.pnpm/@angular-devkit+architect@0.1702.0/node_modules/@angular-devkit/architect/src/create-builder.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.createBuilder = void 0;
+    var core_1 = require_src2();
+    var rxjs_1 = require_cjs();
+    var api_1 = require_api2();
+    var internal_1 = require_internal();
+    var jobs_1 = require_jobs();
+    var schedule_by_name_1 = require_schedule_by_name();
+    function createBuilder2(fn6) {
+      const cjh = jobs_1.createJobHandler;
+      const handler = cjh((options8, context) => {
+        const scheduler = context.scheduler;
+        const progressChannel = context.createChannel("progress");
+        const logChannel = context.createChannel("log");
+        const addTeardown = context.addTeardown.bind(context);
+        let currentState = api_1.BuilderProgressState.Stopped;
+        let current = 0;
+        let status = "";
+        let total = 1;
+        function log(entry) {
+          logChannel.next(entry);
+        }
+        function progress(progress2, context2) {
+          currentState = progress2.state;
+          if (progress2.state === api_1.BuilderProgressState.Running) {
+            current = progress2.current;
+            total = progress2.total !== void 0 ? progress2.total : total;
+            if (progress2.status === void 0) {
+              progress2.status = status;
+            } else {
+              status = progress2.status;
+            }
+          }
+          progressChannel.next({
+            ...progress2,
+            ...context2.target && { target: context2.target },
+            ...context2.builder && { builder: context2.builder },
+            id: context2.id
+          });
+        }
+        return new rxjs_1.Observable((observer) => {
+          const subscriptions = [];
+          const inputSubscription = context.inboundBus.subscribe((i3) => {
+            switch (i3.kind) {
+              case jobs_1.JobInboundMessageKind.Input:
+                onInput(i3.value);
+                break;
+            }
+          });
+          function onInput(i3) {
+            const builder = i3.info;
+            const loggerName = i3.target ? (0, api_1.targetStringFromTarget)(i3.target) : builder.builderName;
+            const logger = new core_1.logging.Logger(loggerName);
+            subscriptions.push(logger.subscribe((entry) => log(entry)));
+            const context2 = {
+              builder,
+              workspaceRoot: i3.workspaceRoot,
+              currentDirectory: i3.currentDirectory,
+              target: i3.target,
+              logger,
+              id: i3.id,
+              async scheduleTarget(target, overrides = {}, scheduleOptions = {}) {
+                const run2 = await (0, schedule_by_name_1.scheduleByTarget)(target, overrides, {
+                  scheduler,
+                  logger: scheduleOptions.logger || logger.createChild(""),
+                  workspaceRoot: i3.workspaceRoot,
+                  currentDirectory: i3.currentDirectory
+                });
+                subscriptions.push(run2.progress.subscribe((event) => progressChannel.next(event)));
+                return run2;
+              },
+              async scheduleBuilder(builderName, options9 = {}, scheduleOptions = {}) {
+                const run2 = await (0, schedule_by_name_1.scheduleByName)(builderName, options9, {
+                  scheduler,
+                  target: scheduleOptions.target,
+                  logger: scheduleOptions.logger || logger.createChild(""),
+                  workspaceRoot: i3.workspaceRoot,
+                  currentDirectory: i3.currentDirectory
+                });
+                subscriptions.push(run2.progress.subscribe((event) => progressChannel.next(event)));
+                return run2;
+              },
+              async getTargetOptions(target) {
+                return (0, rxjs_1.firstValueFrom)(scheduler.schedule("..getTargetOptions", target).output);
+              },
+              async getProjectMetadata(target) {
+                return (0, rxjs_1.firstValueFrom)(scheduler.schedule("..getProjectMetadata", target).output);
+              },
+              async getBuilderNameForTarget(target) {
+                return (0, rxjs_1.firstValueFrom)(scheduler.schedule("..getBuilderNameForTarget", target).output);
+              },
+              async validateOptions(options9, builderName) {
+                return (0, rxjs_1.firstValueFrom)(scheduler.schedule("..validateOptions", [builderName, options9]).output);
+              },
+              reportRunning() {
+                switch (currentState) {
+                  case api_1.BuilderProgressState.Waiting:
+                  case api_1.BuilderProgressState.Stopped:
+                    progress({ state: api_1.BuilderProgressState.Running, current: 0, total }, context2);
+                    break;
+                }
+              },
+              reportStatus(status2) {
+                switch (currentState) {
+                  case api_1.BuilderProgressState.Running:
+                    progress({ state: currentState, status: status2, current, total }, context2);
+                    break;
+                  case api_1.BuilderProgressState.Waiting:
+                    progress({ state: currentState, status: status2 }, context2);
+                    break;
+                }
+              },
+              reportProgress(current2, total2, status2) {
+                switch (currentState) {
+                  case api_1.BuilderProgressState.Running:
+                    progress({ state: currentState, current: current2, total: total2, status: status2 }, context2);
+                }
+              },
+              addTeardown
+            };
+            context2.reportRunning();
+            let result;
+            try {
+              result = fn6(i3.options, context2);
+              if ((0, api_1.isBuilderOutput)(result)) {
+                result = (0, rxjs_1.of)(result);
+              } else if (!(0, rxjs_1.isObservable)(result) && isAsyncIterable(result)) {
+                result = (0, api_1.fromAsyncIterable)(result);
+              } else {
+                result = (0, rxjs_1.from)(result);
+              }
+            } catch (e3) {
+              result = (0, rxjs_1.throwError)(e3);
+            }
+            progress({ state: api_1.BuilderProgressState.Running, current: 0, total: 1 }, context2);
+            subscriptions.push(result.pipe((0, rxjs_1.defaultIfEmpty)({ success: false }), (0, rxjs_1.tap)(() => {
+              progress({ state: api_1.BuilderProgressState.Running, current: total }, context2);
+              progress({ state: api_1.BuilderProgressState.Stopped }, context2);
+            }), (0, rxjs_1.mergeMap)(async (value) => {
+              await new Promise(setImmediate);
+              return value;
+            })).subscribe((message) => observer.next(message), (error) => observer.error(error), () => observer.complete()));
+          }
+          return () => {
+            subscriptions.forEach((x5) => x5.unsubscribe());
+            inputSubscription.unsubscribe();
+          };
+        });
+      });
+      return {
+        handler,
+        [internal_1.BuilderSymbol]: true,
+        [internal_1.BuilderVersionSymbol]: require_package3().version
+      };
+    }
+    exports2.createBuilder = createBuilder2;
+    function isAsyncIterable(obj) {
+      return !!obj && typeof obj[Symbol.asyncIterator] === "function";
+    }
+  }
+});
+
+// node_modules/.pnpm/@angular-devkit+architect@0.1702.0/node_modules/@angular-devkit/architect/src/index.js
+var require_src4 = __commonJS({
+  "node_modules/.pnpm/@angular-devkit+architect@0.1702.0/node_modules/@angular-devkit/architect/src/index.js"(exports2) {
+    "use strict";
+    var __createBinding2 = exports2 && exports2.__createBinding || (Object.create ? function(o2, m2, k6, k23) {
+      if (k23 === void 0)
+        k23 = k6;
+      var desc = Object.getOwnPropertyDescriptor(m2, k6);
+      if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m2[k6];
+        } };
+      }
+      Object.defineProperty(o2, k23, desc);
+    } : function(o2, m2, k6, k23) {
+      if (k23 === void 0)
+        k23 = k6;
+      o2[k23] = m2[k6];
+    });
+    var __setModuleDefault2 = exports2 && exports2.__setModuleDefault || (Object.create ? function(o2, v5) {
+      Object.defineProperty(o2, "default", { enumerable: true, value: v5 });
+    } : function(o2, v5) {
+      o2["default"] = v5;
+    });
+    var __importStar2 = exports2 && exports2.__importStar || function(mod) {
+      if (mod && mod.__esModule)
+        return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k6 in mod)
+          if (k6 !== "default" && Object.prototype.hasOwnProperty.call(mod, k6))
+            __createBinding2(result, mod, k6);
+      }
+      __setModuleDefault2(result, mod);
+      return result;
+    };
+    var __exportStar2 = exports2 && exports2.__exportStar || function(m2, exports3) {
+      for (var p4 in m2)
+        if (p4 !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p4))
+          __createBinding2(exports3, m2, p4);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.jobs = exports2.createBuilder = exports2.Architect = void 0;
+    var jobs = __importStar2(require_jobs());
+    exports2.jobs = jobs;
+    __exportStar2(require_api2(), exports2);
+    var architect_1 = require_architect();
+    Object.defineProperty(exports2, "Architect", { enumerable: true, get: function() {
+      return architect_1.Architect;
+    } });
+    var create_builder_1 = require_create_builder();
+    Object.defineProperty(exports2, "createBuilder", { enumerable: true, get: function() {
+      return create_builder_1.createBuilder;
+    } });
+  }
+});
+
 // node_modules/.pnpm/@nx+devkit@18.0.4_nx@18.0.4/node_modules/@nx/devkit/src/utils/convert-nx-executor.js
 var require_convert_nx_executor = __commonJS({
   "node_modules/.pnpm/@nx+devkit@18.0.4_nx@18.0.4/node_modules/@nx/devkit/src/utils/convert-nx-executor.js"(exports2) {
@@ -384570,7 +386278,7 @@ var require_convert_nx_executor = __commonJS({
         };
         return toObservable(promise());
       };
-      return require("@angular-devkit/architect").createBuilder(builderFunction);
+      return require_src4().createBuilder(builderFunction);
     }
     exports2.convertNxExecutor = convertNxExecutor;
     function toObservable(promiseOrAsyncIterator) {
@@ -389598,7 +391306,7 @@ var require_project_name_and_root_utils = __commonJS({
 });
 
 // node_modules/.pnpm/@nx+js@18.0.4_@swc-node+register@1.8.0_@swc+core@1.3.106_@swc+wasm@1.4.2_@types+node@20.11.8__oaspw4qzot3q5cbpg4tbrofywy/node_modules/@nx/js/package.json
-var require_package3 = __commonJS({
+var require_package4 = __commonJS({
   "node_modules/.pnpm/@nx+js@18.0.4_@swc-node+register@1.8.0_@swc+core@1.3.106_@swc+wasm@1.4.2_@types+node@20.11.8__oaspw4qzot3q5cbpg4tbrofywy/node_modules/@nx/js/package.json"(exports2, module2) {
     module2.exports = {
       name: "@nx/js",
@@ -389685,7 +391393,7 @@ var require_versions2 = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.supportedTypescriptVersions = exports2.typescriptVersion = exports2.verdaccioVersion = exports2.typesNodeVersion = exports2.tsLibVersion = exports2.swcNodeVersion = exports2.swcHelpersVersion = exports2.swcCoreVersion = exports2.swcCliVersion = exports2.prettierVersion = exports2.esbuildVersion = exports2.nxVersion = void 0;
-    exports2.nxVersion = require_package3().version;
+    exports2.nxVersion = require_package4().version;
     exports2.esbuildVersion = "^0.19.2";
     exports2.prettierVersion = "^2.6.2";
     exports2.swcCliVersion = "~0.1.62";
@@ -397226,7 +398934,7 @@ var require_library = __commonJS({
 });
 
 // node_modules/.pnpm/@nx+js@18.0.4_@swc-node+register@1.8.0_@swc+core@1.3.106_@swc+wasm@1.4.2_@types+node@20.11.8__oaspw4qzot3q5cbpg4tbrofywy/node_modules/@nx/js/src/index.js
-var require_src4 = __commonJS({
+var require_src5 = __commonJS({
   "node_modules/.pnpm/@nx+js@18.0.4_@swc-node+register@1.8.0_@swc+core@1.3.106_@swc+wasm@1.4.2_@types+node@20.11.8__oaspw4qzot3q5cbpg4tbrofywy/node_modules/@nx/js/src/index.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -398387,7 +400095,7 @@ var require_update_package_scripts = __commonJS({
 });
 
 // node_modules/.pnpm/@nx+eslint@18.0.4_@swc-node+register@1.8.0_@swc+core@1.3.106_@swc+wasm@1.4.2_@types+node@20.1_7aktmktxtgbbkeb4gyh2xljcra/node_modules/@nx/eslint/package.json
-var require_package4 = __commonJS({
+var require_package5 = __commonJS({
   "node_modules/.pnpm/@nx+eslint@18.0.4_@swc-node+register@1.8.0_@swc+core@1.3.106_@swc+wasm@1.4.2_@types+node@20.1_7aktmktxtgbbkeb4gyh2xljcra/node_modules/@nx/eslint/package.json"(exports2, module2) {
     module2.exports = {
       name: "@nx/eslint",
@@ -398450,7 +400158,7 @@ var require_versions3 = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.typescriptESLintVersion = exports2.eslintConfigPrettierVersion = exports2.eslintrcVersion = exports2.eslintVersion = exports2.nxVersion = void 0;
-    exports2.nxVersion = require_package4().version;
+    exports2.nxVersion = require_package5().version;
     exports2.eslintVersion = "~8.48.0";
     exports2.eslintrcVersion = "^2.1.1";
     exports2.eslintConfigPrettierVersion = "^9.0.0";
@@ -399321,7 +401029,7 @@ var require_esbuild_decorators = __commonJS({
 });
 
 // node_modules/.pnpm/@anatine+esbuild-decorators@0.2.19_esbuild@0.19.12/node_modules/@anatine/esbuild-decorators/src/index.js
-var require_src5 = __commonJS({
+var require_src6 = __commonJS({
   "node_modules/.pnpm/@anatine+esbuild-decorators@0.2.19_esbuild@0.19.12/node_modules/@anatine/esbuild-decorators/src/index.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -481546,7 +483254,7 @@ var require_update_lock_file = __commonJS({
 });
 
 // node_modules/.pnpm/@nx+js@18.0.4_@swc-node+register@1.8.0_@swc+core@1.3.106_@swc+wasm@1.4.2_@types+node@20.11.8__oaspw4qzot3q5cbpg4tbrofywy/node_modules/@nx/js/src/generators/release-version/utils/package.js
-var require_package5 = __commonJS({
+var require_package6 = __commonJS({
   "node_modules/.pnpm/@nx+js@18.0.4_@swc-node+register@1.8.0_@swc+core@1.3.106_@swc+wasm@1.4.2_@types+node@20.11.8__oaspw4qzot3q5cbpg4tbrofywy/node_modules/@nx/js/src/generators/release-version/utils/package.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -483852,7 +485560,7 @@ var require_resolve_local_package_dependencies = __commonJS({
     exports2.resolveLocalPackageDependencies = void 0;
     var devkit_1 = require_devkit();
     var semver_1 = require_semver3();
-    var package_1 = require_package5();
+    var package_1 = require_package6();
     var resolve_version_spec_1 = require_resolve_version_spec();
     function resolveLocalPackageDependencies2(tree, projectGraph, filteredProjects, projectNameToPackageRootMap, resolvePackageRoot, includeAll = false) {
       const localPackageDependencies = {};
@@ -484373,7 +486081,7 @@ var outExtension = ({ format: format3 }) => {
 // packages/workspace-tools/src/base/typescript-library-generator.ts
 var import_devkit2 = __toESM(require_devkit());
 var import_project_name_and_root_utils = __toESM(require_project_name_and_root_utils());
-var import_js = __toESM(require_src4());
+var import_js = __toESM(require_src5());
 var import_init = __toESM(require_init());
 var import_generator = __toESM(require_generator());
 
@@ -484763,7 +486471,7 @@ ${commentStart} ----------------------------------------------------------------
 
 // packages/workspace-tools/src/utils/run-tsup-build.ts
 var import_node_path5 = require("node:path");
-var import_esbuild_decorators = __toESM(require_src5());
+var import_esbuild_decorators = __toESM(require_src6());
 var import_devkit3 = __toESM(require_devkit());
 var import_get_custom_transformers_factory = __toESM(require_get_custom_transformers_factory());
 var import_normalize_options = __toESM(require_normalize_options());
@@ -485020,7 +486728,7 @@ var createTypeScriptCompilationOptions = (normalizedOptions, projectName) => {
 // packages/workspace-tools/src/executors/tsup/executor.ts
 var import_node_fs3 = require("node:fs");
 var import_devkit4 = __toESM(require_devkit());
-var import_js2 = __toESM(require_src4());
+var import_js2 = __toESM(require_src5());
 init_src2();
 var import_fs_extra = __toESM(require_lib());
 
@@ -491200,7 +492908,6 @@ glob.glob = glob;
 
 // packages/workspace-tools/src/executors/tsup/executor.ts
 var import_fileutils = require("nx/src/utils/fileutils.js");
-init_prettier();
 
 // packages/workspace-tools/src/utils/get-project-configurations.ts
 var import_retrieve_workspace_files = require("nx/src/project-graph/utils/retrieve-workspace-files");
@@ -491390,6 +493097,7 @@ ${externalDependencies.map((dep) => {
       return `name: ${dep.name}, node: ${dep.node}, outputs: ${dep.outputs}`;
     }).join("\n")}`
   );
+  const prettier = await Promise.resolve().then(() => (init_prettier(), prettier_exports));
   const prettierOptions = {
     plugins: ["prettier-plugin-packagejson"],
     trailingComma: "none",
@@ -491547,7 +493255,7 @@ ${externalDependencies.map((dep) => {
     writeDebug(config, `\u26A1 Writing package.json file to: ${packageJsonPath}`);
     (0, import_node_fs3.writeFileSync)(
       packageJsonPath,
-      await format2(JSON.stringify(packageJson), {
+      await prettier.format(JSON.stringify(packageJson), {
         ...prettierOptions,
         parser: "json"
       })
@@ -491566,7 +493274,7 @@ ${externalDependencies.map((dep) => {
       files.map(
         async (file) => (0, import_fs_extra.writeFile)(
           file,
-          await format2(
+          await prettier.format(
             `${options8.banner ? options8.banner.startsWith("//") ? options8.banner : `// ${options8.banner}` : ""}
 
 ${(0, import_node_fs3.readFileSync)(file, "utf-8")}`,
@@ -494963,6 +496671,141 @@ safe-buffer/index.js:
    * found in the LICENSE file at https://angular.io/license
    *)
 
+@angular-devkit/architect/src/jobs/api.js:
+  (**
+   * @license
+   * Copyright Google LLC All Rights Reserved.
+   *
+   * Use of this source code is governed by an MIT-style license that can be
+   * found in the LICENSE file at https://angular.io/license
+   *)
+
+@angular-devkit/architect/src/jobs/strategy.js:
+  (**
+   * @license
+   * Copyright Google LLC All Rights Reserved.
+   *
+   * Use of this source code is governed by an MIT-style license that can be
+   * found in the LICENSE file at https://angular.io/license
+   *)
+
+@angular-devkit/architect/src/jobs/create-job-handler.js:
+  (**
+   * @license
+   * Copyright Google LLC All Rights Reserved.
+   *
+   * Use of this source code is governed by an MIT-style license that can be
+   * found in the LICENSE file at https://angular.io/license
+   *)
+
+@angular-devkit/architect/src/jobs/exception.js:
+  (**
+   * @license
+   * Copyright Google LLC All Rights Reserved.
+   *
+   * Use of this source code is governed by an MIT-style license that can be
+   * found in the LICENSE file at https://angular.io/license
+   *)
+
+@angular-devkit/architect/src/jobs/dispatcher.js:
+  (**
+   * @license
+   * Copyright Google LLC All Rights Reserved.
+   *
+   * Use of this source code is governed by an MIT-style license that can be
+   * found in the LICENSE file at https://angular.io/license
+   *)
+
+@angular-devkit/architect/src/jobs/fallback-registry.js:
+  (**
+   * @license
+   * Copyright Google LLC All Rights Reserved.
+   *
+   * Use of this source code is governed by an MIT-style license that can be
+   * found in the LICENSE file at https://angular.io/license
+   *)
+
+@angular-devkit/architect/src/jobs/simple-registry.js:
+  (**
+   * @license
+   * Copyright Google LLC All Rights Reserved.
+   *
+   * Use of this source code is governed by an MIT-style license that can be
+   * found in the LICENSE file at https://angular.io/license
+   *)
+
+@angular-devkit/architect/src/jobs/simple-scheduler.js:
+  (**
+   * @license
+   * Copyright Google LLC All Rights Reserved.
+   *
+   * Use of this source code is governed by an MIT-style license that can be
+   * found in the LICENSE file at https://angular.io/license
+   *)
+
+@angular-devkit/architect/src/jobs/index.js:
+  (**
+   * @license
+   * Copyright Google LLC All Rights Reserved.
+   *
+   * Use of this source code is governed by an MIT-style license that can be
+   * found in the LICENSE file at https://angular.io/license
+   *)
+
+@angular-devkit/architect/src/api.js:
+  (**
+   * @license
+   * Copyright Google LLC All Rights Reserved.
+   *
+   * Use of this source code is governed by an MIT-style license that can be
+   * found in the LICENSE file at https://angular.io/license
+   *)
+
+@angular-devkit/architect/src/schedule-by-name.js:
+  (**
+   * @license
+   * Copyright Google LLC All Rights Reserved.
+   *
+   * Use of this source code is governed by an MIT-style license that can be
+   * found in the LICENSE file at https://angular.io/license
+   *)
+
+@angular-devkit/architect/src/architect.js:
+  (**
+   * @license
+   * Copyright Google LLC All Rights Reserved.
+   *
+   * Use of this source code is governed by an MIT-style license that can be
+   * found in the LICENSE file at https://angular.io/license
+   *)
+
+@angular-devkit/architect/src/internal.js:
+  (**
+   * @license
+   * Copyright Google LLC All Rights Reserved.
+   *
+   * Use of this source code is governed by an MIT-style license that can be
+   * found in the LICENSE file at https://angular.io/license
+   *)
+
+@angular-devkit/architect/src/create-builder.js:
+  (**
+   * @license
+   * Copyright Google LLC All Rights Reserved.
+   *
+   * Use of this source code is governed by an MIT-style license that can be
+   * found in the LICENSE file at https://angular.io/license
+   *)
+
+@angular-devkit/architect/src/index.js:
+  (**
+   * @license
+   * Copyright Google LLC All Rights Reserved.
+   *
+   * Use of this source code is governed by an MIT-style license that can be
+   * found in the LICENSE file at https://angular.io/license
+   *)
+
 queue-microtask/index.js:
   (*! queue-microtask. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> *)