https://wyber.ai/chunk-4BWSLYHL.js

1import {
2  ChangeDetectorRef,
3  Directive,
4  ElementRef,
5  EventEmitter,
6  Host,
7  Inject,
8  Injectable,
9  InjectionToken,
10  Injector,
11  Input,
12  NgModule,
13  Optional,
14  Output,
15  Renderer2,
16  RuntimeError,
17  Self,
18  SkipSelf,
19  Subject,
20  Version,
21  booleanAttribute,
22  computed,
23  forkJoin,
24  forwardRef,
25  from,
26  getDOM,
27  inject,
28  isPromise,
29  isSubscribable,
30  map,
31  setClassMetadata,
32  signal,
33  untracked,
34  ɵɵInheritDefinitionFeature,
35  ɵɵNgOnChangesFeature,
36  ɵɵProvidersFeature,
37  ɵɵattribute,
38  ɵɵclassProp,
39  ɵɵdefineDirective,
40  ɵɵdefineInjectable,
41  ɵɵdefineInjector,
42  ɵɵdefineNgModule,
43  ɵɵdirectiveInject,
44  ɵɵgetInheritedFactory,
45  ɵɵlistener
46} from "./chunk-6GJQIPT2.js";
47import {
48  __spreadProps,
49  __spreadValues
50} from "./chunk-RK4NW2NR.js";
51
52// node_modules/@angular/forms/fesm2022/forms.mjs
53var BaseControlValueAccessor = class _BaseControlValueAccessor {
54  _renderer;
55  _elementRef;
56  /**
57   * The registered callback function called when a change or input event occurs on the input
58   * element.
59   * @docs-private
60   */
61  onChange = (_) => {
62  };
63  /**
64   * The registered callback function called when a blur event occurs on the input element.
65   * @docs-private
66   */
67  onTouched = () => {
68  };
69  constructor(_renderer, _elementRef) {
70    this._renderer = _renderer;
71    this._elementRef = _elementRef;
72  }
73  /**
74   * Helper method that sets a property on a target element using the current Renderer
75   * implementation.
76   * @docs-private
77   */
78  setProperty(key, value) {
79    this._renderer.setProperty(this._elementRef.nativeElement, key, value);
80  }
81  /**
82   * Registers a function called when the control is touched.
83   * @docs-private
84   */
85  registerOnTouched(fn) {
86    this.onTouched = fn;
87  }
88  /**
89   * Registers a function called when the control value changes.
90   * @docs-private
91   */
92  registerOnChange(fn) {
93    this.onChange = fn;
94  }
95  /**
96   * Sets the "disabled" property on the range input element.
97   * @docs-private
98   */
99  setDisabledState(isDisabled) {
100    this.setProperty("disabled", isDisabled);
101  }
102  static \u0275fac = function BaseControlValueAccessor_Factory(__ngFactoryType__) {
103    return new (__ngFactoryType__ || _BaseControlValueAccessor)(\u0275\u0275directiveInject(Renderer2), \u0275\u0275directiveInject(ElementRef));
104  };
105  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
106    type: _BaseControlValueAccessor
107  });
108};
109(() => {
110  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(BaseControlValueAccessor, [{
111    type: Directive
112  }], () => [{
113    type: Renderer2
114  }, {
115    type: ElementRef
116  }], null);
117})();
118var BuiltInControlValueAccessor = class _BuiltInControlValueAccessor extends BaseControlValueAccessor {
119  static \u0275fac = /* @__PURE__ */ (() => {
120    let \u0275BuiltInControlValueAccessor_BaseFactory;
121    return function BuiltInControlValueAccessor_Factory(__ngFactoryType__) {
122      return (\u0275BuiltInControlValueAccessor_BaseFactory || (\u0275BuiltInControlValueAccessor_BaseFactory = \u0275\u0275getInheritedFactory(_BuiltInControlValueAccessor)))(__ngFactoryType__ || _BuiltInControlValueAccessor);
123    };
124  })();
125  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
126    type: _BuiltInControlValueAccessor,
127    features: [\u0275\u0275InheritDefinitionFeature]
128  });
129};
130(() => {
131  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(BuiltInControlValueAccessor, [{
132    type: Directive
133  }], null, null);
134})();
135var NG_VALUE_ACCESSOR = new InjectionToken(ngDevMode ? "NgValueAccessor" : "");
136var CHECKBOX_VALUE_ACCESSOR = {
137  provide: NG_VALUE_ACCESSOR,
138  useExisting: forwardRef(() => CheckboxControlValueAccessor),
139  multi: true
140};
141var CheckboxControlValueAccessor = class _CheckboxControlValueAccessor extends BuiltInControlValueAccessor {
142  /**
143   * Sets the "checked" property on the input element.
144   * @docs-private
145   */
146  writeValue(value) {
147    this.setProperty("checked", value);
148  }
149  static \u0275fac = /* @__PURE__ */ (() => {
150    let \u0275CheckboxControlValueAccessor_BaseFactory;
151    return function CheckboxControlValueAccessor_Factory(__ngFactoryType__) {
152      return (\u0275CheckboxControlValueAccessor_BaseFactory || (\u0275CheckboxControlValueAccessor_BaseFactory = \u0275\u0275getInheritedFactory(_CheckboxControlValueAccessor)))(__ngFactoryType__ || _CheckboxControlValueAccessor);
153    };
154  })();
155  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
156    type: _CheckboxControlValueAccessor,
157    selectors: [["input", "type", "checkbox", "formControlName", ""], ["input", "type", "checkbox", "formControl", ""], ["input", "type", "checkbox", "ngModel", ""]],
158    hostBindings: function CheckboxControlValueAccessor_HostBindings(rf, ctx) {
159      if (rf & 1) {
160        \u0275\u0275listener("change", function CheckboxControlValueAccessor_change_HostBindingHandler($event) {
161          return ctx.onChange($event.target.checked);
162        })("blur", function CheckboxControlValueAccessor_blur_HostBindingHandler() {
163          return ctx.onTouched();
164        });
165      }
166    },
167    standalone: false,
168    features: [\u0275\u0275ProvidersFeature([CHECKBOX_VALUE_ACCESSOR]), \u0275\u0275InheritDefinitionFeature]
169  });
170};
171(() => {
172  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(CheckboxControlValueAccessor, [{
173    type: Directive,
174    args: [{
175      selector: "input[type=checkbox][formControlName],input[type=checkbox][formControl],input[type=checkbox][ngModel]",
176      host: {
177        "(change)": "onChange($event.target.checked)",
178        "(blur)": "onTouched()"
179      },
180      providers: [CHECKBOX_VALUE_ACCESSOR],
181      standalone: false
182    }]
183  }], null, null);
184})();
185var DEFAULT_VALUE_ACCESSOR = {
186  provide: NG_VALUE_ACCESSOR,
187  useExisting: forwardRef(() => DefaultValueAccessor),
188  multi: true
189};
190function _isAndroid() {
191  const userAgent = getDOM() ? getDOM().getUserAgent() : "";
192  return /android (\d+)/.test(userAgent.toLowerCase());
193}
194var COMPOSITION_BUFFER_MODE = new InjectionToken(ngDevMode ? "CompositionEventMode" : "");
195var DefaultValueAccessor = class _DefaultValueAccessor extends BaseControlValueAccessor {
196  _compositionMode;
197  /** Whether the user is creating a composition string (IME events). */
198  _composing = false;
199  constructor(renderer, elementRef, _compositionMode) {
200    super(renderer, elementRef);
201    this._compositionMode = _compositionMode;
202    if (this._compositionMode == null) {
203      this._compositionMode = !_isAndroid();
204    }
205  }
206  /**
207   * Sets the "value" property on the input element.
208   * @docs-private
209   */
210  writeValue(value) {
211    const normalizedValue = value == null ? "" : value;
212    this.setProperty("value", normalizedValue);
213  }
214  /** @internal */
215  _handleInput(value) {
216    if (!this._compositionMode || this._compositionMode && !this._composing) {
217      this.onChange(value);
218    }
219  }
220  /** @internal */
221  _compositionStart() {
222    this._composing = true;
223  }
224  /** @internal */
225  _compositionEnd(value) {
226    this._composing = false;
227    this._compositionMode && this.onChange(value);
228  }
229  static \u0275fac = function DefaultValueAccessor_Factory(__ngFactoryType__) {
230    return new (__ngFactoryType__ || _DefaultValueAccessor)(\u0275\u0275directiveInject(Renderer2), \u0275\u0275directiveInject(ElementRef), \u0275\u0275directiveInject(COMPOSITION_BUFFER_MODE, 8));
231  };
232  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
233    type: _DefaultValueAccessor,
234    selectors: [["input", "formControlName", "", 3, "type", "checkbox"], ["textarea", "formControlName", ""], ["input", "formControl", "", 3, "type", "checkbox"], ["textarea", "formControl", ""], ["input", "ngModel", "", 3, "type", "checkbox"], ["textarea", "ngModel", ""], ["", "ngDefaultControl", ""]],
235    hostBindings: function DefaultValueAccessor_HostBindings(rf, ctx) {
236      if (rf & 1) {
237        \u0275\u0275listener("input", function DefaultValueAccessor_input_HostBindingHandler($event) {
238          return ctx._handleInput($event.target.value);
239        })("blur", function DefaultValueAccessor_blur_HostBindingHandler() {
240          return ctx.onTouched();
241        })("compositionstart", function DefaultValueAccessor_compositionstart_HostBindingHandler() {
242          return ctx._compositionStart();
243        })("compositionend", function DefaultValueAccessor_compositionend_HostBindingHandler($event) {
244          return ctx._compositionEnd($event.target.value);
245        });
246      }
247    },
248    standalone: false,
249    features: [\u0275\u0275ProvidersFeature([DEFAULT_VALUE_ACCESSOR]), \u0275\u0275InheritDefinitionFeature]
250  });
251};
252(() => {
253  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(DefaultValueAccessor, [{
254    type: Directive,
255    args: [{
256      selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]",
257      // TODO: vsavkin replace the above selector with the one below it once
258      // https://github.com/angular/angular/issues/3011 is implemented
259      // selector: '[ngModel],[formControl],[formControlName]',
260      host: {
261        "(input)": "$any(this)._handleInput($event.target.value)",
262        "(blur)": "onTouched()",
263        "(compositionstart)": "$any(this)._compositionStart()",
264        "(compositionend)": "$any(this)._compositionEnd($event.target.value)"
265      },
266      providers: [DEFAULT_VALUE_ACCESSOR],
267      standalone: false
268    }]
269  }], () => [{
270    type: Renderer2
271  }, {
272    type: ElementRef
273  }, {
274    type: void 0,
275    decorators: [{
276      type: Optional
277    }, {

648 null;
649  };
650}
651function patternValidator(pattern) {
652  if (!pattern) return nullValidator;
653  let regex;
654  let regexStr;
655  if (typeof pattern === "string") {
656    regexStr = "";
657    if (pattern.charAt(0) !== "^") regexStr += "^";
658    regexStr += pattern;
659    if (pattern.charAt(pattern.length - 1) !== "$") regexStr += "$";
660    regex = new RegExp(regexStr);
661  } else {
662    regexStr = pattern.toString();
663    regex = pattern;
664  }
665  return (control) => {
666    if (isEmptyInputValue(control.value)) {
667      return null;
668    }
669    const value = control.value;
670    return regex.test(value) ? null : {
671      "pattern": {
672        "requiredPattern": regexStr,
673        "actualValue": value
674      }
675    };
676  };
677}
678function nullValidator(control) {
679  return null;
680}
681function isPresent(o) {
682  return o != null;
683}
684function toObservable(value) {
685  const obs = isPromise(value) ? from(value) : value;
686  if ((typeof ngDevMode === "undefined" || ngDevMode) && !isSubscribable(obs)) {
687    let errorMessage = `Expected async validator to return Promise or Observable.`;
688    if (typeof value === "object") {
689      errorMessage += " Are you using a synchronous validator where an async validator is expected?";
690    }
691    throw new RuntimeError(-1101, errorMessage);
692  }
693  return obs;
694}
695function mergeErrors(arrayOfErrors) {
696  let res = {};
697  arrayOfErrors.forEach((errors) => {
698    res = errors != null ? __spreadValues(__spreadValues({}, res), errors) : res;
699  });
700  return Object.keys(res).length === 0 ? null : res;
701}
702function executeValidators(control, validators) {
703  return validators.map((validator) => validator(control));
704}
705function isValidatorFn(validator) {
706  return !validator.validate;
707}
708function normalizeValidators(validators) {
709  return validators.map((validator) => {
710    return isValidatorFn(validator) ? validator : (c) => validator.validate(c);
711  });
712}
713function compose(validators) {
714  if (!validators) return null;
715  const presentValidators = validators.filter(isPresent);
716  if (presentValidators.length == 0) return null;
717  return function(control) {
718    return mergeErrors(executeValidators(control, presentValidators));
719  };
720}
721function composeValidators(validators) {
722  return validators != null ? compose(normalizeValidators(validators)) : null;
723}
724function composeAsync(validators) {
725  if (!validators) return null;
726  const presentValidators = validators.filter(isPresent);
727  if (presentValidators.length == 0) return null;
728  return function(control) {
729    const observables = executeValidators(control, presentValidators).map(toObservable);
730    return forkJoin(observables).pipe(map(mergeErrors));
731  };
732}
733function composeAsyncValidators(validators) {
734  return validators != null ? composeAsync(normalizeValidators(validators)) : null;
735}
736function mergeValidators(controlValidators, dirValidator) {
737  if (controlValidators === null) return [dirValidator];
738  return Array.isArray(controlValidators) ? [...controlValidators, dirValidator] : [controlValidators, dirValidator];
739}
740function getControlValidators(control) {
741  return control._rawValidators;
742}
743function getControlAsyncValidators(control) {
744  return control._rawAsyncValidators;
745}
746function makeValidatorsArray(validators) {
747  if (!validators) return [];
748  return Array.isArray(validators) ? validators : [validators];
749}
750function hasValidator(validators, validator) {
751  return Array.isArray(validators) ? validators.includes(validator) : validators === validator;
752}
753function addValidators(validators, currentValidators) {
754  const current = makeValidatorsArray(currentValidators);
755  const validatorsToAdd = makeValidatorsArray(validators);
756  validatorsToAdd.forEach((v) => {
757    if (!hasValidator(current, v)) {
758      current.push(v);
759    }
760  });
761  return current;
762}
763function removeValidators(validators, currentValidators) {
764  return makeValidatorsArray(currentValidators).filter((v) => !hasValidator(validators, v));
765}
766var AbstractControlDirective = class {
767  /**
768   * @description
769   * Reports the value of the control if it is present, otherwise null.
770   */
771  get value() {
772    return this.control ? this.control.value : null;
773  }
774  /**
775   * @description
776   * Reports whether the control is valid. A control is considered valid if no
777   * validation errors exist with the current value.
778   * If the control is not present, null is returned.
779   */
780  get valid() {
781    return this.control ? this.control.valid : null;
782  }
783  /**
784   * @description
785   * Reports whether the control is invalid, meaning that an error exists in the input value.
786   * If the control is not present, null is returned.
787   */
788  get invalid() {
789    return this.control ? this.control.invalid : null;
790  }
791  /**
792   * @description
793   * Reports whether a control is pending, meaning that async validation is occurring and
794   * errors are not yet available for the input value. If the control is not present, null is
795   * returned.
796   */
797  get pending() {
798    return this.control ? this.control.pending : null;
799  }
800  /**
801   * @description
802   * Reports whether the control is disabled, meaning that the control is disabled
803   * in the UI and is exempt from validation checks and excluded from aggregate
804   * values of ancestor controls. If the control is not present, null is returned.
805   */
806  get disabled() {
807    return this.control ? this.control.disabled : null;
808  }
809  /**
810   * @description
811   * Reports whether the control is enabled, meaning that the control is included in ancestor
812   * calculations of validity or value. If the control is not present, null is returned.
813   */
814  get enabled() {
815    return this.control ? this.control.enabled : null;
816  }
817  /**
818   * @description
819   * Reports the control's validation errors. If the control is not present, null is returned.
820   */
821  get errors() {
822    return this.control ? this.control.errors : null;
823  }
824  /**
825   * @description
826   * Reports whether the control is pristine, meaning that the user has not yet changed
827   * the value in the UI. If the control is not present, null is returned.
828   */
829  get pristine() {
830    return this.control ? this.control.pristine : null;
831  }
832  /**
833   * @description
834   * Reports whether the control is dirty, meaning that the user has changed
835   * the value in the UI. If the control is not present, null is returned.
836   */
837  get dirty() {
838    return this.control ? this.control.dirty : null;
839  }
840  /**
841   * @description
842   * Reports whether the control is touched, meaning that the user has triggered
843   * a `blur` event on it. If the control is not present, null is returned.
844   */
845  get touched() {
846    return this.control ? this.control.touched : null;
847  }
848  /**
849   * @description
850   * Reports the validation status of the control. Possible values include:
851   * 'VALID', 'INVALID', 'DISABLED', and 'PENDING'.
852   * If the control is not present, null is returned.
853   */
854  get status() {
855    return this.control ? this.control.status : null;
856  }
857  /**
858   * @description
859   * Reports whether the control is untouched, meaning that the user has not yet triggered
860   * a `blur` event on it. If the control is not present, null is returned.
861   */
862  get untouched() {
863    return this.control ? this.control.untouched : null;
864  }
865  /**
866   * @description
867   * Returns a multicasting observable that emits a validation status whenever it is
868   * calculated for the control. If the control is not present, null is returned.
869   */
870  get statusChanges() {
871    return this.control ? this.control.statusChanges : null;
872  }
873  /**
874   * @description
875   * Returns a multicasting observable of value changes for the control that emits every time the
876   * value of the control changes in the UI or programmatically.
877   * If the control is not present, null is returned.
878   */
879  get valueChanges() {
880    return this.control ? this.control.valueChanges : null;
881  }
882  /**
883   * @description
884   * Returns an array that represents the path from the top-level form to this control.
885   * Each index is the string name of the control on that level.
886   */
887  get path() {
888    return null;
889  }
890  /**
891   * Contains the result of merging synchronous validators into a single validator function
892   * (combined using `Validators.compose`).
893   */
894  _composedValidatorFn;
895  /**
896   * Contains the result of merging asynchronous validators into a single validator function
897   * (combined using `Validators.composeAsync`).
898   */
899  _composedAsyncValidatorFn;
900  /**
901   * Set of synchronous validators as they were provided while calling `setValidators` function.
902   * @internal
903   */
904  _rawValidators = [];
905  /**
906   * Set of asynchronous validators as they were provided while calling `setAsyncValidators`
907   * function.
908   * @internal
909   */
910  _rawAsyncValidators = [];
911  /**
912   * Sets synchronous validators for this directive.
913   * @internal
914   */
915  _setValidators(validators) {
916    this._rawValidators = validators || [];
917    this._composedValidatorFn = composeValidators(this._rawValidators);
918  }
919  /**
920   * Sets asynchronous validators for this directive.
921   * @internal
922   */
923  _setAsyncValidators(validators) {
924    this._rawAsyncValidators = validators || [];
925    this._composedAsyncValidatorFn = composeAsyncValidators(this._rawAsyncValidators);
926  }
927  /**
928   * @description
929   * Synchronous validator function composed of all the synchronous validators registered with this
930   * directive.
931   */
932  get validator() {
933    return this._composedValidatorFn || null;
934  }
935  /**
936   * @description
937   * Asynchronous validator function composed of all the asynchronous validators registered with
938   * this directive.
939   */
940  get asyncValidator() {
941    return this._composedAsyncValidatorFn || null;
942  }
943  /*
944   * The set of callbacks to be invoked when directive instance is being destroyed.
945   */
946  _onDestroyCallbacks = [];
947  /**
948   * Internal function to register callbacks that should be invoked
949   * when directive instance is being destroyed.
950   * @internal
951   */
952  _registerOnDestroy(fn) {
953    this._onDestroyCallbacks.push(fn);
954  }
955  /**
956   * Internal function to invoke all registered "on destroy" callbacks.
957   * Note: calling this function also clears the list of callbacks.
958   * @internal
959   */
960  _invokeOnDestroyCallbacks() {
961    this._onDestroyCallbacks.forEach((fn) => fn());
962    this._onDestroyCallbacks = [];
963  }
964  /**
965   * @description
966   * Resets the control with the provided value if the control is present.
967   */
968  reset(value = void 0) {
969    if (this.control) this.control.reset(value);
970  }
971  /**
972   * @description
973   * Reports whether the control with the given path has the error specified.
974   *
975   * @param errorCode The code of the error to check
976   * @param path A list of control names that designates how to move from the current control
977   * to the control that should be queried for errors.
978   *
979   * @usageNotes
980   * For example, for the following `FormGroup`:
981   *
982   * ```ts
983   * form = new FormGroup({
984   *   address: new FormGroup({ street: new FormControl() })
985   * });
986   * ```
987   *
988   * The path to the 'street' control from the root form would be 'address' -> 'street'.
989   *
990   * It can be provided to this method in one of two formats:
991   *
992   * 1. An array of string control names, e.g. `['address', 'street']`
993   * 1. A period-delimited list of control names in one string, e.g. `'address.street'`
994   *
995   * If no path is given, this method checks for the error on the current control.
996   *
997   * @returns whether the given error is present in the control at the given path.
998   *
999   * If the control is not present, false is returned.
1000   */
1001  hasError(errorCode, path) {
1002    return this.control ? this.control.hasError(errorCode, path) : false;
1003  }
1004  /**
1005   * @description
1006   * Reports error data for the control with the given path.
1007   *
1008   * @param errorCode The code of the error to check
1009   * @param path A list of control names that designates how to move from the current control
1010   * to the control that should be queried for errors.
1011   *
1012   * @usageNotes
1013   * For example, for the following `FormGroup`:
1014   *
1015   * ```ts
1016   * form = new FormGroup({
1017   *   address: new FormGroup({ street: new FormControl() })
1018   * });
1019   * ```
1020   *
1021   * The path to the 'street' control from the root form would be 'address' -> 'street'.
1022   *
1023   * It can be provided to this method in one of two formats:
1024   *
1025   * 1. An array of string control names, e.g. `['address', 'street']`
1026   * 1. A period-delimited list of control names in one string, e.g. `'address.street'`
1027   *
1028   * @returns error data for that particular error. If the control or error is not present,
1029   * null is returned.
1030   */
1031  getError(errorCode, path) {
1032    return this.control ? this.control.getError(errorCode, path) : null;
1033  }
1034};
1035var ControlContainer = class extends AbstractControlDirective {
1036  /**
1037   * @description
1038   * The name for the control
1039   */
1040  name;
1041  /**
1042   * @description
1043   * The top-level form directive for the control.
1044   */
1045  get formDirective() {
1046    return null;
1047  }
1048  /**
1049   * @description
1050   * The path to this group.
1051   */
1052  get path() {
1053    return null;
1054  }
1055};
1056var NgControl = class extends AbstractControlDirective {
1057  /**
1058   * @description
1059   * The parent form for the control.
1060   *
1061   * @internal
1062   */
1063  _parent = null;
1064  /**
1065   * @description
1066   * The name for the control
1067   */
1068  name = null;
1069  /**
1070   * @description
1071   * The value accessor for the control
1072   */
1073  valueAccessor = null;
1074};
1075var AbstractControlStatus = class {
1076  _cd;
1077  constructor(cd) {
1078    this._cd = cd;
1079  }
1080  get isTouched() {
1081    this._cd?.control?._touched?.();
1082    return !!this._cd?.control?.touched;
1083  }
1084  get isUntouched() {
1085    return !!this._cd?.control?.untouched;
1086  }
1087  get isPristine() {
1088    this._cd?.control?._pristine?.();
1089    return !!this._cd?.control?.pristine;
1090  }
1091  get isDirty() {
1092    return !!this._cd?.control?.dirty;
1093  }
1094  get isValid() {
1095    this._cd?.control?._status?.();
1096    return !!this._cd?.control?.valid;
1097  }
1098  get isInvalid() {
1099    return !!this._cd?.control?.invalid;
1100  }
1101  get isPending() {
1102    return !!this._cd?.control?.pending;
1103  }
1104  get isSubmitted() {
1105    this._cd?._submitted?.();
1106    return !!this._cd?.submitted;
1107  }
1108};
1109var ngControlStatusHost = {
1110  "[class.ng-untouched]": "isUntouched",
1111  "[class.ng-touched]": "isTouched",
1112  "[class.ng-pristine]": "isPristine",
1113  "[class.ng-dirty]": "isDirty",
1114  "[class.ng-valid]": "isValid",
1115  "[class.ng-invalid]": "isInvalid",
1116  "[class.ng-pending]": "isPending"
1117};
1118var ngGroupStatusHost = __spreadProps(__spreadValues({}, ngControlStatusHost), {
1119  "[class.ng-submitted]": "isSubmitted"
1120});
1121var NgControlStatus = class _NgControlStatus extends AbstractControlStatus {
1122  constructor(cd) {
1123    super(cd);
1124  }
1125  static \u0275fac = function NgControlStatus_Factory(__ngFactoryType__) {
1126    return new (__ngFactoryType__ || _NgControlStatus)(\u0275\u0275directiveInject(NgControl, 2));
1127  };
1128  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
1129    type: _NgControlStatus,
1130    selectors: [["", "formControlName", ""], ["", "ngModel", ""], ["", "formControl", ""]],
1131    hostVars: 14,
1132    hostBindings: function NgControlStatus_HostBindings(rf, ctx) {
1133      if (rf & 2) {
1134        \u0275\u0275classProp("ng-untouched", ctx.isUntouched)("ng-touched", ctx.isTouched)("ng-pristine", ctx.isPristine)("ng-dirty", ctx.isDirty)("ng-valid", ctx.isValid)("ng-invalid", ctx.isInvalid)("ng-pending", ctx.isPending);
1135      }
1136    },
1137    standalone: false,
1138    features: [\u0275\u0275InheritDefinitionFeature]
1139  });
1140};
1141(() => {
1142  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgControlStatus, [{
1143    type: Directive,
1144    args: [{
1145      selector: "[formControlName],[ngModel],[formControl]",
1146      host: ngControlStatusHost,
1147      standalone: false
1148    }]
1149  }], () => [{
1150    type: NgControl,
1151    decorators: [{
1152      type: Self
1153    }]
1154  }], null);
1155})();
1156var NgControlStatusGroup = class _NgControlStatusGroup extends AbstractControlStatus {
1157  constructor(cd) {
1158    super(cd);
1159  }
1160  static \u0275fac = function NgControlStatusGroup_Factory(__ngFactoryType__) {
1161    return new (__ngFactoryType__ || _NgControlStatusGroup)(\u0275\u0275directiveInject(ControlContainer, 10));
1162  };
1163  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
1164    type: _NgControlStatusGroup,
1165    selectors: [["", "formGroupName", ""], ["", "formArrayName", ""], ["", "ngModelGroup", ""], ["", "formGroup", ""], ["form", 3, "ngNoForm", ""], ["", "ngForm", ""]],
1166    hostVars: 16,
1167    hostBindings: function NgControlStatusGroup_HostBindings(rf, ctx) {
1168      if (rf & 2) {
1169        \u0275\u0275classProp("ng-untouched", ctx.isUntouched)("ng-touched", ctx.isTouched)("ng-pristine", ctx.isPristine)("ng-dirty", ctx.isDirty)("ng-valid", ctx.isValid)("ng-invalid", ctx.isInvalid)("ng-pending", ctx.isPending)("ng-submitted", ctx.isSubmitted);
1170      }
1171    },
1172    standalone: false,
1173    features: [\u0275\u0275InheritDefinitionFeature]
1174  });
1175};
1176(() => {
1177  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgControlStatusGroup, [{
1178    type: Directive,
1179    args: [{
1180      selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]",
1181      host: ngGroupStatusHost,
1182      standalone: false
1183    }]
1184  }], () => [{
1185    type: ControlContainer,
1186    decorators: [{
1187      type: Optional
1188    }, {
1189      type: Self
1190    }]
1191  }], null);
1192})();
1193var formControlNameExample = `
1194  <div [formGroup]="myGroup">
1195    <input formControlName="firstName">
1196  </div>
1197
1198  In your class:
1199
1200  this.myGroup = new FormGroup({
1201      firstName: new FormControl()
1202  });`;
1203var formGroupNameExample = `
1204  <div [formGroup]="myGroup">
1205      <div formGroupName="person">
1206        <input formControlName="firstName">
1207      </div>
1208  </div>
1209
1210  In your class:
1211
1212  this.myGroup = new FormGroup({
1213      person: new FormGroup({ firstName: new FormControl() })
1214  });`;
1215var formArrayNameExample = `
1216  <div [formGroup]="myGroup">
1217    <div formArrayName="cities">
1218      <div *ngFor="let city of cityArray.controls; index as i">
1219        <input [formControlName]="i">
1220      </div>
1221    </div>
1222  </div>
1223
1224  In your class:
1225
1226  this.cityArray = new FormArray([new FormControl('SF')]);
1227  this.myGroup = new FormGroup({
1228    cities: this.cityArray
1229  });`;
1230var ngModelGroupExample = `
1231  <form>
1232      <div ngModelGroup="person">
1233        <input [(ngModel)]="person.name" name="firstName">
1234      </div>
1235  </form>`;
1236var ngModelWithFormGroupExample = `
1237  <div [formGroup]="myGroup">
1238      <input formControlName="firstName">
1239      <input [(ngModel)]="showMoreControls" [ngModelOptions]="{standalone: true}">
1240  </div>
1241`;
1242function controlParentException(nameOrIndex) {
1243  return new RuntimeError(1050, `formControlName must be used with a parent formGroup directive. You'll want to add a formGroup
1244      directive and pass it an existing FormGroup instance (you can create one in your class).
1245
1246      ${describeFormControl(nameOrIndex)}
1247
1248    Example:
1249
1250    ${formControlNameExample}`);
1251}
1252function describeFormControl(nameOrIndex) {
1253  if (nameOrIndex == null || nameOrIndex === "") {
1254    return "";
1255  }
1256  const valueType = typeof nameOrIndex === "string" ? "name" : "index";
1257  return `Affected Form Control ${valueType}: "${nameOrIndex}"`;
1258}
1259function ngModelGroupException() {
1260  return new RuntimeError(1051, `formControlName cannot be used with an ngModelGroup parent. It is only compatible with parents
1261      that also have a "form" prefix: formGroupName, formArrayName, or formGroup.
1262
1263      Option 1:  Update the parent to be formGroupName (reactive form strategy)
1264
1265      ${formGroupNameExample}
1266
1267      Option 2: Use ngModel instead of formControlName (template-driven strategy)
1268
1269      ${ngModelGroupExample}`);
1270}
1271function missingFormException() {
1272  return new RuntimeError(1052, `formGroup expects a FormGroup instance. Please pass one in.
1273
1274      Example:
1275
1276      ${formControlNameExample}`);
1277}
1278function groupParentException() {
1279  return new RuntimeError(1053, `formGroupName must be used with a parent formGroup directive.  You'll want to add a formGroup
1280    directive and pass it an existing FormGroup instance (you can create one in your class).
1281
1282    Example:
1283
1284    ${formGroupNameExample}`);
1285}
1286function arrayParentException() {
1287  return new RuntimeError(1054, `formArrayName must be used with a parent formGroup directive.  You'll want to add a formGroup
1288      directive and pass it an existing FormGroup instance (you can create one in your class).
1289
1290      Example:
1291
1292      ${formArrayNameExample}`);
1293}
1294var disabledAttrWarning = `
1295  It looks like you're using the disabled attribute with a reactive form directive. If you set disabled to true
1296  when you set up this control in your component class, the disabled attribute will actually be set in the DOM for
1297  you. We recommend using this approach to avoid 'changed after checked' errors.
1298
1299  Example:
1300  // Specify the \`disabled\` property at control creation time:
1301  form = new FormGroup({
1302    first: new FormControl({value: 'Nancy', disabled: true}, Validators.required),
1303    last: new FormControl('Drew', Validators.required)
1304  });
1305
1306  // Controls can also be enabled/disabled after creation:
1307  form.get('first')?.enable();
1308  form.get('last')?.disable();
1309`;
1310var asyncValidatorsDroppedWithOptsWarning = `
1311  It looks like you're constructing using a FormControl with both an options argument and an
1312  async validators argument. Mixing these arguments will cause your async validators to be dropped.
1313  You should either put all your validators in the options object, or in separate validators
1314  arguments. For example:
1315
1316  // Using validators arguments
1317  fc = new FormControl(42, Validators.required, myAsyncValidator);
1318
1319  // Using AbstractControlOptions
1320  fc = new FormControl(42, {validators: Validators.required, asyncValidators: myAV});
1321
1322  // Do NOT mix them: async validators will be dropped!
1323  fc = new FormControl(42, {validators: Validators.required}, /* Oops! */ myAsyncValidator);
1324`;
1325function ngModelWarning(directiveName) {
1326  return `
1327  It looks like you're using ngModel on the same form field as ${directiveName}.
1328  Support for using the ngModel input property and ngModelChange event with
1329  reactive form directives has been deprecated in Angular v6 and will be removed
1330  in a future version of Angular.
1331
1332  For more information on this, see our API docs here:
1333  https://angular.io/api/forms/${directiveName === "formControl" ? "FormControlDirective" : "FormControlName"}#use-with-ngmodel
1334  `;
1335}
1336function describeKey(isFormGroup, key) {
1337  return isFormGroup ? `with name: '${key}'` : `at index: ${key}`;
1338}
1339function noControlsError(isFormGroup) {
1340  return `
1341    There are no form controls registered with this ${isFormGroup ? "group" : "array"} yet. If you're using ngModel,
1342    you may want to check next tick (e.g. use setTimeout).
1343  `;
1344}
1345function missingControlError(isFormGroup, key) {
1346  return `Cannot find form control ${describeKey(isFormGroup, key)}`;
1347}
1348function missingControlValueError(isFormGroup, key) {
1349  return `Must supply a value for form control ${describeKey(isFormGroup, key)}`;
1350}
1351var VALID = "VALID";
1352var INVALID = "INVALID";
1353var PENDING = "PENDING";
1354var DISABLED = "DISABLED";
1355var ControlEvent = class {
1356};
1357var ValueChangeEvent = class extends ControlEvent {
1358  value;
1359  source;
1360  constructor(value, source) {
1361    super();
1362    this.value = value;
1363    this.source = source;
1364  }
1365};
1366var PristineChangeEvent = class extends ControlEvent {
1367  pristine;
1368  source;
1369  constructor(pristine, source) {
1370    super();
1371    this.pristine = pristine;
1372    this.source = source;
1373  }
1374};
1375var TouchedChangeEvent = class extends ControlEvent {
1376  touched;
1377  source;
1378  constructor(touched, source) {
1379    super();
1380    this.touched = touched;
1381    this.source = source;
1382  }
1383};
1384var StatusChangeEvent = class extends ControlEvent {
1385  status;
1386  source;
1387  constructor(status, source) {
1388    super();
1389    this.status = status;
1390    this.source = source;
1391  }
1392};
1393var FormSubmittedEvent = class extends ControlEvent {
1394  source;
1395  constructor(source) {
1396    super();
1397    this.source = source;
1398  }
1399};
1400var FormResetEvent = class extends ControlEvent {
1401  source;
1402  constructor(source) {
1403    super();
1404    this.source = source;
1405  }
1406};
1407function pickValidators(validatorOrOpts) {
1408  return (isOptionsObj(validatorOrOpts) ? validatorOrOpts.validators : validatorOrOpts) || null;
1409}
1410function coerceToValidator(validator) {
1411  return Array.isArray(validator) ? composeValidators(validator) : validator || null;
1412}
1413function pickAsyncValidators(asyncValidator, validatorOrOpts) {
1414  if (typeof ngDevMode === "undefined" || ngDevMode) {
1415    if (isOptionsObj(validatorOrOpts) && asyncValidator) {
1416      console.warn(asyncValidatorsDroppedWithOptsWarning);
1417    }
1418  }
1419  return (isOptionsObj(validatorOrOpts) ? validatorOrOpts.asyncValidators : asyncValidator) || null;
1420}
1421function coerceToAsyncValidator(asyncValidator) {
1422  return Array.isArray(asyncValidator) ? composeAsyncValidators(asyncValidator) : asyncValidator || null;
1423}
1424function isOptionsObj(validatorOrOpts) {
1425  return validatorOrOpts != null && !Array.isArray(validatorOrOpts) && typeof validatorOrOpts === "object";
1426}
1427function assertControlPresent(parent, isGroup, key) {
1428  const controls = parent.controls;
1429  const collection = isGroup ? Object.keys(controls) : controls;
1430  if (!collection.length) {
1431    throw new RuntimeError(1e3, typeof ngDevMode === "undefined" || ngDevMode ? noControlsError(isGroup) : "");
1432  }
1433  if (!controls[key]) {
1434    throw new RuntimeError(1001, typeof ngDevMode === "undefined" || ngDevMode ? missingControlError(isGroup, key) : "");
1435  }
1436}
1437function assertAllValuesPresent(control, isGroup, value) {
1438  control._forEachChild((_, key) => {
1439    if (value[key] === void 0) {
1440      throw new RuntimeError(1002, typeof ngDevMode === "undefined" || ngDevMode ? missingControlValueError(isGroup, key) : "");
1441    }
1442  });
1443}
1444var AbstractControl = class {
1445  /** @internal */
1446  _pendingDirty = false;
1447  /**
1448   * Indicates that a control has its own pending asynchronous validation in progress.
1449   * It also stores if the control should emit events when the validation status changes.
1450   *
1451   * @internal
1452   */
1453  _hasOwnPendingAsyncValidator = null;
1454  /** @internal */
1455  _pendingTouched = false;
1456  /** @internal */
1457  _onCollectionChange = () => {
1458  };
1459  /** @internal */
1460  _updateOn;
1461  _parent = null;
1462  _asyncValidationSubscription;
1463  /**
1464   * Contains the result of merging synchronous validators into a single validator function
1465   * (combined using `Validators.compose`).
1466   *
1467   * @internal
1468   */
1469  _composedValidatorFn;
1470  /**
1471   * Contains the result of merging asynchronous validators into a single validator function
1472   * (combined using `Validators.composeAsync`).
1473   *
1474   * @internal
1475   */
1476  _composedAsyncValidatorFn;
1477  /**
1478   * Synchronous validators as they were provided:
1479   *  - in `AbstractControl` constructor
1480   *  - as an argument while calling `setValidators` function
1481   *  - while calling the setter on the `validator` field (e.g. `control.validator = validatorFn`)
1482   *
1483   * @internal
1484   */
1485  _rawValidators;
1486  /**
1487   * Asynchronous validators as they were provided:
1488   *  - in `AbstractControl` constructor
1489   *  - as an argument while calling `setAsyncValidators` function
1490   *  - while calling the setter on the `asyncValidator` field (e.g. `control.asyncValidator =
1491   * asyncValidatorFn`)
1492   *
1493   * @internal
1494   */
1495  _rawAsyncValidators;
1496  /**
1497   * The current value of the control.
1498   *
1499   * * For a `FormControl`, the current value.
1500   * * For an enabled `FormGroup`, the values of enabled controls as an object
1501   * with a key-value pair for each member of the group.
1502   * * For a disabled `FormGroup`, the values of all controls as an object
1503   * with a key-value pair for each member of the group.
1504   * * For a `FormArray`, the values of enabled controls as an array.
1505   *
1506   */
1507  value;
1508  /**
1509   * Initialize the AbstractControl instance.
1510   *
1511   * @param validators The function or array of functions that is used to determine the validity of
1512   *     this control synchronously.
1513   * @param asyncValidators The function or array of functions that is used to determine validity of
1514   *     this control asynchronously.
1515   */
1516  constructor(validators, asyncValidators) {
1517    this._assignValidators(validators);
1518    this._assignAsyncValidators(asyncValidators);
1519  }
1520  /**
1521   * Returns the function that is used to determine the validity of this control synchronously.
1522   * If multiple validators have been added, this will be a single composed function.
1523   * See `Validators.compose()` for additional information.
1524   */
1525  get validator() {
1526    return this._composedValidatorFn;
1527  }
1528  set validator(validatorFn) {
1529    this._rawValidators = this._composedValidatorFn = validatorFn;
1530  }
1531  /**
1532   * Returns the function that is used to determine the validity of this control asynchronously.
1533   * If multiple validators have been added, this will be a single composed function.
1534   * See `Validators.compose()` for additional information.
1535   */
1536  get asyncValidator() {
1537    return this._composedAsyncValidatorFn;
1538  }
1539  set asyncValidator(asyncValidatorFn) {
1540    this._rawAsyncValidators = this._composedAsyncValidatorFn = asyncValidatorFn;
1541  }
1542  /**
1543   * The parent control.
1544   */
1545  get parent() {
1546    return this._parent;
1547  }
1548  /**
1549   * The validation status of the control.
1550   *
1551   * @see {@link FormControlStatus}
1552   *
1553   * These status values are mutually exclusive, so a control cannot be
1554   * both valid AND invalid or invalid AND disabled.
1555   */
1556  get status() {
1557    return untracked(this.statusReactive);
1558  }
1559  set status(v) {
1560    untracked(() => this.statusReactive.set(v));
1561  }
1562  /** @internal */
1563  _status = computed(() => this.statusReactive());
1564  statusReactive = signal(void 0);
1565  /**
1566   * A control is `valid` when its `status` is `VALID`.
1567   *
1568   * @see {@link AbstractControl.status}
1569   *
1570   * @returns True if the control has passed all of its validation tests,
1571   * false otherwise.
1572   */
1573  get valid() {
1574    return this.status === VALID;
1575  }
1576  /**
1577   * A control is `invalid` when its `status` is `INVALID`.
1578   *
1579   * @see {@link AbstractControl.status}
1580   *
1581   * @returns True if this control has failed one or more of its validation checks,
1582   * false otherwise.
1583   */
1584  get invalid() {
1585    return this.status === INVALID;
1586  }
1587  /**
1588   * A control is `pending` when its `status` is `PENDING`.
1589   *
1590   * @see {@link AbstractControl.status}
1591   *
1592   * @returns True if this control is in the process of conducting a validation check,
1593   * false otherwise.
1594   */
1595  get pending() {
1596    return this.status == PENDING;
1597  }
1598  /**
1599   * A control is `disabled` when its `status` is `DISABLED`.
1600   *
1601   * Disabled controls are exempt from validation checks and
1602   * are not included in the aggregate value of their ancestor
1603   * controls.
1604   *
1605   * @see {@link AbstractControl.status}
1606   *
1607   * @returns True if the control is disabled, false otherwise.
1608   */
1609  get disabled() {
1610    return this.status === DISABLED;
1611  }
1612  /**
1613   * A control is `enabled` as long as its `status` is not `DISABLED`.
1614   *
1615   * @returns True if the control has any status other than 'DISABLED',
1616   * false if the status is 'DISABLED'.
1617   *
1618   * @see {@link AbstractControl.status}
1619   *
1620   */
1621  get enabled() {
1622    return this.status !== DISABLED;
1623  }
1624  /**
1625   * An object containing any errors generated by failing validation,
1626   * or null if there are no errors.
1627   */
1628  errors;
1629  /**
1630   * A control is `pristine` if the user has not yet changed
1631   * the value in the UI.
1632   *
1633   * @returns True if the user has not yet changed the value in the UI; compare `dirty`.
1634   * Programmatic changes to a control's value do not mark it dirty.
1635   */
1636  get pristine() {
1637    return untracked(this.pristineReactive);
1638  }
1639  set pristine(v) {
1640    untracked(() => this.pristineReactive.set(v));
1641  }
1642  /** @internal */
1643  _pristine = computed(() => this.pristineReactive());
1644  pristineReactive = signal(true);
1645  /**
1646   * A control is `dirty` if the user has changed the value
1647   * in the UI.
1648   *
1649   * @returns True if the user has changed the value of this control in the UI; compare `pristine`.
1650   * Programmatic changes to a control's value do not mark it dirty.
1651   */
1652  get dirty() {
1653    return !this.pristine;
1654  }
1655  /**
1656   * True if the control is marked as `touched`.
1657   *
1658   * A control is marked `touched` once the user has triggered
1659   * a `blur` event on it.
1660   */
1661  get touched() {
1662    return untracked(this.touchedReactive);
1663  }
1664  set touched(v) {
1665    untracked(() => this.touchedReactive.set(v));
1666  }
1667  /** @internal */
1668  _touched = computed(() => this.touchedReactive());
1669  touchedReactive = signal(false);
1670  /**
1671   * True if the control has not been marked as touched
1672   *
1673   * A control is `untouched` if the user has not yet triggered
1674   * a `blur` event on it.
1675   */
1676  get untouched() {
1677    return !this.touched;
1678  }
1679  /**
1680   * Exposed as observable, see below.
1681   *
1682   * @internal
1683   */
1684  _events = new Subject();
1685  /**
1686   * A multicasting observable that emits an event every time the state of the control changes.
1687   * It emits for value, status, pristine or touched changes.
1688   *
1689   * **Note**: On value change, the emit happens right after a value of this control is updated. The
1690   * value of a parent control (for example if this FormControl is a part of a FormGroup) is updated
1691   * later, so accessing a value of a parent control (using the `value` property) from the callback
1692   * of this event might result in getting a value that has not been updated yet. Subscribe to the
1693   * `events` of the parent control instead.
1694   * For other event types, the events are emitted after the parent control has been updated.
1695   *
1696   */
1697  events = this._events.asObservable();
1698  /**
1699   * A multicasting observable that emits an event every time the value of the control changes, in
1700   * the UI or programmatically. It also emits an event each time you call enable() or disable()
1701   * without passing along {emitEvent: false} as a function argument.
1702   *
1703   * **Note**: the emit happens right after a value of this control is updated. The value of a
1704   * parent control (for example if this FormControl is a part of a FormGroup) is updated later, so
1705   * accessing a value of a parent control (using the `value` property) from the callback of this
1706   * event might result in getting a value that has not been updated yet. Subscribe to the
1707   * `valueChanges` event of the parent control instead.
1708   *

1715
1716   */
1717  statusChanges;
1718  /**
1719   * Reports the update strategy of the `AbstractControl` (meaning
1720   * the event on which the control updates itself).
1721   * Possible values: `'change'` | `'blur'` | `'submit'`
1722   * Default value: `'change'`
1723   */
1724  get updateOn() {
1725    return this._updateOn ? this._updateOn : this.parent ? this.parent.updateOn : "change";
1726  }
1727  /**
1728   * Sets the synchronous validators that are active on this control.  Calling
1729   * this overwrites any existing synchronous validators.
1730   *
1731   * When you add or remove a validator at run time, you must call
1732   * `updateValueAndValidity()` for the new validation to take effect.
1733   *
1734   * If you want to add a new validator without affecting existing ones, consider
1735   * using `addValidators()` method instead.
1736   */
1737  setValidators(validators) {
1738    this._assignValidators(validators);
1739  }
1740  /**
1741   * Sets the asynchronous validators that are active on this control. Calling this
1742   * overwrites any existing asynchronous validators.
1743   *
1744   * When you add or remove a validator at run time, you must call
1745   * `updateValueAndValidity()` for the new validation to take effect.
1746   *
1747   * If you want to add a new validator without affecting existing ones, consider
1748   * using `addAsyncValidators()` method instead.
1749   */
1750  setAsyncValidators(validators) {
1751    this._assignAsyncValidators(validators);
1752  }
1753  /**
1754   * Add a synchronous validator or validators to this control, without affecting other validators.
1755   *
1756   * When you add or remove a validator at run time, you must call
1757   * `updateValueAndValidity()` for the new validation to take effect.
1758   *
1759   * Adding a validator that already exists will have no effect. If duplicate validator functions
1760   * are present in the `validators` array, only the first instance would be added to a form
1761   * control.
1762   *
1763   * @param validators The new validator function or functions to add to this control.
1764   */
1765  addValidators(validators) {
1766    this.setValidators(addValidators(validators, this._rawValidators));
1767  }
1768  /**
1769   * Add an asynchronous validator or validators to this control, without affecting other
1770   * validators.
1771   *
1772   * When you add or remove a validator at run time, you must call
1773   * `updateValueAndValidity()` for the new validation to take effect.
1774   *
1775   * Adding a validator that already exists will have no effect.
1776   *
1777   * @param validators The new asynchronous validator function or functions to add to this control.
1778   */
1779  addAsyncValidators(validators) {
1780    this.setAsyncValidators(addValidators(validators, this._rawAsyncValidators));
1781  }
1782  /**
1783   * Remove a synchronous validator from this control, without affecting other validators.
1784   * Validators are compared by function reference; you must pass a reference to the exact same
1785   * validator function as the one that was originally set. If a provided validator is not found,
1786   * it is ignored.
1787   *
1788   * @usageNotes
1789   *
1790   * ### Reference to a ValidatorFn
1791   *
1792   * ```
1793   * // Reference to the RequiredValidator
1794   * const ctrl = new FormControl<string | null>('', Validators.required);
1795   * ctrl.removeValidators(Validators.required);
1796   *
1797   * // Reference to anonymous function inside MinValidator
1798   * const minValidator = Validators.min(3);
1799   * const ctrl = new FormControl<string | null>('', minValidator);
1800   * expect(ctrl.hasValidator(minValidator)).toEqual(true)
1801   * expect(ctrl.hasValidator(Validators.min(3))).toEqual(false)
1802   *
1803   * ctrl.removeValidators(minValidator);
1804   * ```
1805   *
1806   * When you add or remove a validator at run time, you must call
1807   * `updateValueAndValidity()` for the new validation to take effect.
1808   *
1809   * @param validators The validator or validators to remove.
1810   */
1811  removeValidators(validators) {
1812    this.setValidators(removeValidators(validators, this._rawValidators));
1813  }
1814  /**
1815   * Remove an asynchronous validator from this control, without affecting other validators.
1816   * Validators are compared by function reference; you must pass a reference to the exact same
1817   * validator function as the one that was originally set. If a provided validator is not found, it
1818   * is ignored.
1819   *
1820   * When you add or remove a validator at run time, you must call
1821   * `updateValueAndValidity()` for the new validation to take effect.
1822   *
1823   * @param validators The asynchronous validator or validators to remove.
1824   */
1825  removeAsyncValidators(validators) {
1826    this.setAsyncValidators(removeValidators(validators, this._rawAsyncValidators));
1827  }
1828  /**
1829   * Check whether a synchronous validator function is present on this control. The provided
1830   * validator must be a reference to the exact same function that was provided.
1831   *
1832   * @usageNotes
1833   *
1834   * ### Reference to a ValidatorFn
1835   *
1836   * ```
1837   * // Reference to the RequiredValidator
1838   * const ctrl = new FormControl<number | null>(0, Validators.required);
1839   * expect(ctrl.hasValidator(Validators.required)).toEqual(true)
1840   *
1841   * // Reference to anonymous function inside MinValidator
1842   * const minValidator = Validators.min(3);
1843   * const ctrl = new FormControl<number | null>(0, minValidator);
1844   * expect(ctrl.hasValidator(minValidator)).toEqual(true)
1845   * expect(ctrl.hasValidator(Validators.min(3))).toEqual(false)
1846   * ```
1847   *
1848   * @param validator The validator to check for presence. Compared by function reference.
1849   * @returns Whether the provided validator was found on this control.
1850   */
1851  hasValidator(validator) {
1852    return hasValidator(this._rawValidators, validator);
1853  }
1854  /**
1855   * Check whether an asynchronous validator function is present on this control. The provided
1856   * validator must be a reference to the exact same function that was provided.
1857   *
1858   * @param validator The asynchronous validator to check for presence. Compared by function
1859   *     reference.
1860   * @returns Whether the provided asynchronous validator was found on this control.
1861   */
1862  hasAsyncValidator(validator) {
1863    return hasValidator(this._rawAsyncValidators, validator);
1864  }
1865  /**
1866   * Empties out the synchronous validator list.
1867   *
1868   * When you add or remove a validator at run time, you must call
1869   * `updateValueAndValidity()` for the new validation to take effect.
1870   *
1871   */
1872  clearValidators() {
1873    this.validator = null;
1874  }
1875  /**
1876   * Empties out the async validator list.
1877   *
1878   * When you add or remove a validator at run time, you must call
1879   * `updateValueAndValidity()` for the new validation to take effect.
1880   *
1881   */
1882  clearAsyncValidators() {
1883    this.asyncValidator = null;
1884  }
1885  markAsTouched(opts = {}) {
1886    const changed = this.touched === false;
1887    this.touched = true;
1888    const sourceControl = opts.sourceControl ?? this;
1889    if (this._parent && !opts.onlySelf) {
1890      this._parent.markAsTouched(__spreadProps(__spreadValues({}, opts), {
1891        sourceControl
1892      }));
1893    }
1894    if (changed && opts.emitEvent !== false) {
1895      this._events.next(new TouchedChangeEvent(true, sourceControl));
1896    }
1897  }
1898  /**
1899   * Marks the control and all its descendant controls as `touched`.
1900   * @see {@link markAsTouched()}
1901   *
1902   * @param opts Configuration options that determine how the control propagates changes
1903   * and emits events after marking is applied.
1904   * * `emitEvent`: When true or not supplied (the default), the `events`
1905   * observable emits a `TouchedChangeEvent` with the `touched` property being `true`.
1906   * When false, no events are emitted.
1907   */
1908  markAllAsTouched(opts = {}) {
1909    this.markAsTouched({
1910      onlySelf: true,
1911      emitEvent: opts.emitEvent,
1912      sourceControl: this
1913    });
1914    this._forEachChild((control) => control.markAllAsTouched(opts));
1915  }
1916  markAsUntouched(opts = {}) {
1917    const changed = this.touched === true;
1918    this.touched = false;
1919    this._pendingTouched = false;
1920    const sourceControl = opts.sourceControl ?? this;
1921    this._forEachChild((control) => {
1922      control.markAsUntouched({
1923        onlySelf: true,
1924        emitEvent: opts.emitEvent,
1925        sourceControl
1926      });
1927    });
1928    if (this._parent && !opts.onlySelf) {
1929      this._parent._updateTouched(opts, sourceControl);
1930    }
1931    if (changed && opts.emitEvent !== false) {
1932      this._events.next(new TouchedChangeEvent(false, sourceControl));
1933    }
1934  }
1935  markAsDirty(opts = {}) {
1936    const changed = this.pristine === true;
1937    this.pristine = false;
1938    const sourceControl = opts.sourceControl ?? this;
1939    if (this._parent && !opts.onlySelf) {
1940      this._parent.markAsDirty(__spreadProps(__spreadValues({}, opts), {
1941        sourceControl
1942      }));
1943    }
1944    if (changed && opts.emitEvent !== false) {
1945      this._events.next(new PristineChangeEvent(false, sourceControl));
1946    }
1947  }
1948  markAsPristine(opts = {}) {
1949    const changed = this.pristine === false;
1950    this.pristine = true;
1951    this._pendingDirty = false;
1952    const sourceControl = opts.sourceControl ?? this;
1953    this._forEachChild((control) => {
1954      control.markAsPristine({
1955        onlySelf: true,
1956        emitEvent: opts.emitEvent
1957      });
1958    });
1959    if (this._parent && !opts.onlySelf) {
1960      this._parent._updatePristine(opts, sourceControl);
1961    }
1962    if (changed && opts.emitEvent !== false) {
1963      this._events.next(new PristineChangeEvent(true, sourceControl));
1964    }
1965  }
1966  markAsPending(opts = {}) {
1967    this.status = PENDING;
1968    const sourceControl = opts.sourceControl ?? this;
1969    if (opts.emitEvent !== false) {
1970      this._events.next(new StatusChangeEvent(this.status, sourceControl));
1971      this.statusChanges.emit(this.status);
1972    }
1973    if (this._parent && !opts.onlySelf) {
1974      this._parent.markAsPending(__spreadProps(__spreadValues({}, opts), {
1975        sourceControl
1976      }));
1977    }
1978  }
1979  disable(opts = {}) {
1980    const skipPristineCheck = this._parentMarkedDirty(opts.onlySelf);
1981    this.status = DISABLED;
1982    this.errors = null;
1983    this._forEachChild((control) => {
1984      control.disable(__spreadProps(__spreadValues({}, opts), {
1985        onlySelf: true
1986      }));
1987    });
1988    this._updateValue();
1989    const sourceControl = opts.sourceControl ?? this;
1990    if (opts.emitEvent !== false) {
1991      this._events.next(new ValueChangeEvent(this.value, sourceControl));
1992      this._events.next(new StatusChangeEvent(this.status, sourceControl));
1993      this.valueChanges.emit(this.value);
1994      this.statusChanges.emit(this.status);
1995    }
1996    this._updateAncestors(__spreadProps(__spreadValues({}, opts), {
1997      skipPristineCheck
1998    }), this);
1999    this._onDisabledChange.forEach((changeFn) => changeFn(true));
2000  }
2001  /**
2002   * Enables the control. This means the control is included in validation checks and
2003   * the aggregate value of its parent. Its status recalculates based on its value and
2004   * its validators.
2005   *
2006   * By default, if the control has children, all children are enabled.
2007   *
2008   * @see {@link AbstractControl.status}
2009   *
2010   * @param opts Configure options that control how the control propagates changes and
2011   * emits events when marked as untouched
2012   * * `onlySelf`: When true, mark only this control. When false or not supplied,
2013   * marks all direct ancestors. Default is false.
2014   * * `emitEvent`: When true or not supplied (the default), the `statusChanges`,
2015   * `valueChanges` and `events`
2016   * observables emit events with the latest status and value when the control is enabled.
2017   * When false, no events are emitted.
2018   */
2019  enable(opts = {}) {
2020    const skipPristineCheck = this._parentMarkedDirty(opts.onlySelf);
2021    this.status = VALID;
2022    this._forEachChild((control) => {
2023      control.enable(__spreadProps(__spreadValues({}, opts), {
2024        onlySelf: true
2025      }));
2026    });
2027    this.updateValueAndValidity({
2028      onlySelf: true,
2029      emitEvent: opts.emitEvent
2030    });
2031    this._updateAncestors(__spreadProps(__spreadValues({}, opts), {
2032      skipPristineCheck
2033    }), this);
2034    this._onDisabledChange.forEach((changeFn) => changeFn(false));
2035  }
2036  _updateAncestors(opts, sourceControl) {
2037    if (this._parent && !opts.onlySelf) {
2038      this._parent.updateValueAndValidity(opts);
2039      if (!opts.skipPristineCheck) {
2040        this._parent._updatePristine({}, sourceControl);
2041      }
2042      this._parent._updateTouched({}, sourceControl);
2043    }
2044  }
2045  /**
2046   * Sets the parent of the control
2047   *
2048   * @param parent The new parent.
2049   */
2050  setParent(parent) {
2051    this._parent = parent;
2052  }
2053  /**
2054   * The raw value of this control. For most control implementations, the raw value will include
2055   * disabled children.
2056   */
2057  getRawValue() {
2058    return this.value;
2059  }
2060  updateValueAndValidity(opts = {}) {
2061    this._setInitialStatus();
2062    this._updateValue();
2063    if (this.enabled) {
2064      const shouldHaveEmitted = this._cancelExistingSubscription();
2065      this.errors = this._runValidator();
2066      this.status = this._calculateStatus();
2067      if (this.status === VALID || this.status === PENDING) {
2068        this._runAsyncValidator(shouldHaveEmitted, opts.emitEvent);
2069      }
2070    }
2071    const sourceControl = opts.sourceControl ?? this;
2072    if (opts.emitEvent !== false) {
2073      this._events.next(new ValueChangeEvent(this.value, sourceControl));
2074      this._events.next(new StatusChangeEvent(this.status, sourceControl));
2075      this.valueChanges.emit(this.value);
2076      this.statusChanges.emit(this.status);
2077    }
2078    if (this._parent && !opts.onlySelf) {
2079      this._parent.updateValueAndValidity(__spreadProps(__spreadValues({}, opts), {
2080        sourceControl
2081      }));
2082    }
2083  }
2084  /** @internal */
2085  _updateTreeValidity(opts = {
2086    emitEvent: true
2087  }) {
2088    this._forEachChild((ctrl) => ctrl._updateTreeValidity(opts));
2089    this.updateValueAndValidity({
2090      onlySelf: true,
2091      emitEvent: opts.emitEvent
2092    });
2093  }
2094  _setInitialStatus() {
2095    this.status = this._allControlsDisabled() ? DISABLED : VALID;
2096  }
2097  _runValidator() {
2098    return this.validator ? this.validator(this) : null;
2099  }
2100  _runAsyncValidator(shouldHaveEmitted, emitEvent) {
2101    if (this.asyncValidator) {
2102      this.status = PENDING;
2103      this._hasOwnPendingAsyncValidator = {
2104        emitEvent: emitEvent !== false
2105      };
2106      const obs = toObservable(this.asyncValidator(this));
2107      this._asyncValidationSubscription = obs.subscribe((errors) => {
2108        this._hasOwnPendingAsyncValidator = null;
2109        this.setErrors(errors, {
2110          emitEvent,
2111          shouldHaveEmitted
2112        });
2113      });
2114    }
2115  }
2116  _cancelExistingSubscription() {
2117    if (this._asyncValidationSubscription) {
2118      this._asyncValidationSubscription.unsubscribe();
2119      const shouldHaveEmitted = this._hasOwnPendingAsyncValidator?.emitEvent ?? false;
2120      this._hasOwnPendingAsyncValidator = null;
2121      return shouldHaveEmitted;
2122    }
2123    return false;
2124  }
2125  setErrors(errors, opts = {}) {
2126    this.errors = errors;
2127    this._updateControlsErrors(opts.emitEvent !== false, this, opts.shouldHaveEmitted);
2128  }
2129  /**
2130   * Retrieves a child control given the control's name or path.
2131   *
2132   * @param path A dot-delimited string or array of string/number values that define the path to the
2133   * control. If a string is provided, passing it as a string literal will result in improved type
2134   * information. Likewise, if an array is provided, passing it `as const` will cause improved type
2135   * information to be available.
2136   *
2137   * @usageNotes
2138   * ### Retrieve a nested control
2139   *
2140   * For example, to get a `name` control nested within a `person` sub-group:
2141   *
2142   * * `this.form.get('person.name');`
2143   *
2144   * -OR-
2145   *
2146   * * `this.form.get(['person', 'name'] as const);` // `as const` gives improved typings
2147   *
2148   * ### Retrieve a control in a FormArray
2149   *
2150   * When accessing an element inside a FormArray, you can use an element index.
2151   * For example, to get a `price` control from the first element in an `items` array you can use:
2152   *
2153   * * `this.form.get('items.0.price');`
2154   *
2155   * -OR-
2156   *
2157   * * `this.form.get(['items', 0, 'price']);`
2158   */
2159  get(path) {
2160    let currPath = path;
2161    if (currPath == null) return null;
2162    if (!Array.isArray(currPath)) currPath = currPath.split(".");
2163    if (currPath.length === 0) return null;
2164    return currPath.reduce((control, name) => control && control._find(name), this);
2165  }
2166  /**
2167   * @description
2168   * Reports error data for the control with the given path.
2169   *
2170   * @param errorCode The code of the error to check
2171   * @param path A list of control names that designates how to move from the current control
2172   * to the control that should be queried for errors.
2173   *
2174   * @usageNotes
2175   * For example, for the following `FormGroup`:
2176   *
2177   * ```ts
2178   * form = new FormGroup({
2179   *   address: new FormGroup({ street: new FormControl() })
2180   * });
2181   * ```
2182   *
2183   * The path to the 'street' control from the root form would be 'address' -> 'street'.
2184   *
2185   * It can be provided to this method in one of two formats:
2186   *
2187   * 1. An array of string control names, e.g. `['address', 'street']`
2188   * 1. A period-delimited list of control names in one string, e.g. `'address.street'`
2189   *
2190   * @returns error data for that particular error. If the control or error is not present,
2191   * null is returned.
2192   */
2193  getError(errorCode, path) {
2194    const control = path ? this.get(path) : this;
2195    return control && control.errors ? control.errors[errorCode] : null;
2196  }
2197  /**
2198   * @description
2199   * Reports whether the control with the given path has the error specified.
2200   *
2201   * @param errorCode The code of the error to check
2202   * @param path A list of control names that designates how to move from the current control
2203   * to the control that should be queried for errors.
2204   *
2205   * @usageNotes
2206   * For example, for the following `FormGroup`:
2207   *
2208   * ```ts
2209   * form = new FormGroup({
2210   *   address: new FormGroup({ street: new FormControl() })
2211   * });
2212   * ```
2213   *
2214   * The path to the 'street' control from the root form would be 'address' -> 'street'.
2215   *
2216   * It can be provided to this method in one of two formats:
2217   *
2218   * 1. An array of string control names, e.g. `['address', 'street']`
2219   * 1. A period-delimited list of control names in one string, e.g. `'address.street'`
2220   *
2221   * If no path is given, this method checks for the error on the current control.
2222   *
2223   * @returns whether the given error is present in the control at the given path.
2224   *
2225   * If the control is not present, false is returned.
2226   */
2227  hasError(errorCode, path) {
2228    return !!this.getError(errorCode, path);
2229  }
2230  /**
2231   * Retrieves the top-level ancestor of this control.
2232   */
2233  get root() {
2234    let x = this;
2235    while (x._parent) {
2236      x = x._parent;
2237    }
2238    return x;
2239  }
2240  /** @internal */
2241  _updateControlsErrors(emitEvent, changedControl, shouldHaveEmitted) {
2242    this.status = this._calculateStatus();
2243    if (emitEvent) {
2244      this.statusChanges.emit(this.status);
2245    }
2246    if (emitEvent || shouldHaveEmitted) {
2247      this._events.next(new StatusChangeEvent(this.status, changedControl));
2248    }
2249    if (this._parent) {
2250      this._parent._updateControlsErrors(emitEvent, changedControl, shouldHaveEmitted);
2251    }
2252  }
2253  /** @internal */
2254  _initObservables() {
2255    this.valueChanges = new EventEmitter();
2256    this.statusChanges = new EventEmitter();
2257  }
2258  _calculateStatus() {
2259    if (this._allControlsDisabled()) return DISABLED;
2260    if (this.errors) return INVALID;
2261    if (this._hasOwnPendingAsyncValidator || this._anyControlsHaveStatus(PENDING)) return PENDING;
2262    if (this._anyControlsHaveStatus(INVALID)) return INVALID;
2263    return VALID;
2264  }
2265  /** @internal */
2266  _anyControlsHaveStatus(status) {
2267    return this._anyControls((control) => control.status === status);
2268  }
2269  /** @internal */
2270  _anyControlsDirty() {
2271    return this._anyControls((control) => control.dirty);
2272  }
2273  /** @internal */
2274  _anyControlsTouched() {
2275    return this._anyControls((control) => control.touched);
2276  }
2277  /** @internal */
2278  _updatePristine(opts, changedControl) {
2279    const newPristine = !this._anyControlsDirty();
2280    const changed = this.pristine !== newPristine;
2281    this.pristine = newPristine;
2282    if (this._parent && !opts.onlySelf) {
2283      this._parent._updatePristine(opts, changedControl);
2284    }
2285    if (changed) {
2286      this._events.next(new PristineChangeEvent(this.pristine, changedControl));
2287    }
2288  }
2289  /** @internal */
2290  _updateTouched(opts = {}, changedControl) {
2291    this.touched = this._anyControlsTouched();
2292    this._events.next(new TouchedChangeEvent(this.touched, changedControl));
2293    if (this._parent && !opts.onlySelf) {
2294      this._parent._updateTouched(opts, changedControl);
2295    }
2296  }
2297  /** @internal */
2298  _onDisabledChange = [];
2299  /** @internal */
2300  _registerOnCollectionChange(fn) {
2301    this._onCollectionChange = fn;
2302  }
2303  /** @internal */
2304  _setUpdateStrategy(opts) {
2305    if (isOptionsObj(opts) && opts.updateOn != null) {
2306      this._updateOn = opts.updateOn;
2307    }
2308  }
2309  /**
2310   * Check to see if parent has been marked artificially dirty.
2311   *
2312   * @internal
2313   */
2314  _parentMarkedDirty(onlySelf) {
2315    const parentDirty = this._parent && this._parent.dirty;
2316    return !onlySelf && !!parentDirty && !this._parent._anyControlsDirty();
2317  }
2318  /** @internal */
2319  _find(name) {
2320    return null;
2321  }
2322  /**
2323   * Internal implementation of the `setValidators` method. Needs to be separated out into a
2324   * different method, because it is called in the constructor and it can break cases where
2325   * a control is extended.
2326   */
2327  _assignValidators(validators) {
2328    this._rawValidators = Array.isArray(validators) ? validators.slice() : validators;
2329    this._composedValidatorFn = coerceToValidator(this._rawValidators);
2330  }
2331  /**
2332   * Internal implementation of the `setAsyncValidators` method. Needs to be separated out into a
2333   * different method, because it is called in the constructor and it can break cases where
2334   * a control is extended.
2335   */
2336  _assignAsyncValidators(validators) {
2337    this._rawAsyncValidators = Array.isArray(validators) ? validators.slice() : validators;
2338    this._composedAsyncValidatorFn = coerceToAsyncValidator(this._rawAsyncValidators);
2339  }
2340};
2341var FormGroup = class extends AbstractControl {
2342  /**
2343   * Creates a new `FormGroup` instance.
2344   *
2345   * @param controls A collection of child controls. The key for each child is the name
2346   * under which it is registered.
2347   *
2348   * @param validatorOrOpts A synchronous validator function, or an array of
2349   * such functions, or an `AbstractControlOptions` object that contains validation functions
2350   * and a validation trigger.
2351   *
2352   * @param asyncValidator A single async validator or array of async validator functions
2353   *
2354   */
2355  constructor(controls, validatorOrOpts, asyncValidator) {
2356    super(pickValidators(validatorOrOpts), pickAsyncValidators(asyncValidator, validatorOrOpts));
2357    (typeof ngDevMode === "undefined" || ngDevMode) && validateFormGroupControls(controls);
2358    this.controls = controls;
2359    this._initObservables();
2360    this._setUpdateStrategy(validatorOrOpts);
2361    this._setUpControls();
2362    this.updateValueAndValidity({
2363      onlySelf: true,
2364      // If `asyncValidator` is present, it will trigger control status change from `PENDING` to
2365      // `VALID` or `INVALID`. The status should be broadcasted via the `statusChanges` observable,
2366      // so we set `emitEvent` to `true` to allow that during the control creation process.
2367      emitEvent: !!this.asyncValidator
2368    });
2369  }
2370  controls;
2371  registerControl(name, control) {
2372    if (this.controls[name]) return this.controls[name];
2373    this.controls[name] = control;
2374    control.setParent(this);
2375    control._registerOnCollectionChange(this._onCollectionChange);
2376    return control;
2377  }
2378  addControl(name, control, options = {}) {
2379    this.registerControl(name, control);
2380    this.updateValueAndValidity({
2381      emitEvent: options.emitEvent
2382    });
2383    this._onCollectionChange();
2384  }
2385  /**
2386   * Remove a control from this group. In a strongly-typed group, required controls cannot be
2387   * removed.
2388   *
2389   * This method also updates the value and validity of the control.
2390   *
2391   * @param name The control name to remove from the collection
2392   * @param options Specifies whether this FormGroup instance should emit events after a
2393   *     control is removed.
2394   * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
2395   * `valueChanges` observables emit events with the latest status and value when the control is
2396   * removed. When false, no events are emitted.
2397   */
2398  removeControl(name, options = {}) {
2399    if (this.controls[name]) this.controls[name]._registerOnCollectionChange(() => {
2400    });
2401    delete this.controls[name];
2402    this.updateValueAndValidity({
2403      emitEvent: options.emitEvent
2404    });
2405    this._onCollectionChange();
2406  }
2407  setControl(name, control, options = {}) {
2408    if (this.controls[name]) this.controls[name]._registerOnCollectionChange(() => {
2409    });
2410    delete this.controls[name];
2411    if (control) this.registerControl(name, control);
2412    this.updateValueAndValidity({
2413      emitEvent: options.emitEvent
2414    });
2415    this._onCollectionChange();
2416  }
2417  contains(controlName) {
2418    return this.controls.hasOwnProperty(controlName) && this.controls[controlName].enabled;
2419  }
2420  /**
2421   * Sets the value of the `FormGroup`. It accepts an object that matches
2422   * the structure of the group, with control names as keys.
2423   *
2424   * @usageNotes
2425   * ### Set the complete value for the form group
2426   *
2427   * ```ts
2428   * const form = new FormGroup({
2429   *   first: new FormControl(),
2430   *   last: new FormControl()
2431   * });
2432   *
2433   * console.log(form.value);   // {first: null, last: null}
2434   *
2435   * form.setValue({first: 'Nancy', last: 'Drew'});
2436   * console.log(form.value);   // {first: 'Nancy', last: 'Drew'}
2437   * ```
2438   *
2439   * @throws When strict checks fail, such as setting the value of a control
2440   * that doesn't exist or if you exclude a value of a control that does exist.
2441   *
2442   * @param value The new value for the control that matches the structure of the group.
2443   * @param options Configuration options that determine how the control propagates changes
2444   * and emits events after the value changes.
2445   * The configuration options are passed to the {@link AbstractControl#updateValueAndValidity
2446   * updateValueAndValidity} method.
2447   *
2448   * * `onlySelf`: When true, each change only affects this control, and not its parent. Default is
2449   * false.
2450   * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
2451   * `valueChanges`
2452   * observables emit events with the latest status and value when the control value is updated.
2453   * When false, no events are emitted.
2454   */
2455  setValue(value, options = {}) {
2456    assertAllValuesPresent(this, true, value);
2457    Object.keys(value).forEach((name) => {
2458      assertControlPresent(this, true, name);
2459      this.controls[name].setValue(value[name], {
2460        onlySelf: true,
2461        emitEvent: options.emitEvent
2462      });
2463    });
2464    this.updateValueAndValidity(options);
2465  }
2466  /**
2467   * Patches the value of the `FormGroup`. It accepts an object with control
2468   * names as keys, and does its best to match the values to the correct controls
2469   * in the group.
2470   *
2471   * It accepts both super-sets and sub-sets of the group without throwing an error.
2472   *
2473   * @usageNotes
2474   * ### Patch the value for a form group
2475   *
2476   * ```ts
2477   * const form = new FormGroup({
2478   *    first: new FormControl(),
2479   *    last: new FormControl()
2480   * });
2481   * console.log(form.value);   // {first: null, last: null}
2482   *
2483   * form.patchValue({first: 'Nancy'});
2484   * console.log(form.value);   // {first: 'Nancy', last: null}
2485   * ```
2486   *
2487   * @param value The object that matches the structure of the group.
2488   * @param options Configuration options that determine how the control propagates changes and
2489   * emits events after the value is patched.
2490   * * `onlySelf`: When true, each change only affects this control and not its parent. Default is
2491   * true.
2492   * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
2493   * `valueChanges` observables emit events with the latest status and value when the control value
2494   * is updated. When false, no events are emitted. The configuration options are passed to
2495   * the {@link AbstractControl#updateValueAndValidity updateValueAndValidity} method.
2496   */
2497  patchValue(value, options = {}) {
2498    if (value == null) return;
2499    Object.keys(value).forEach((name) => {
2500      const control = this.controls[name];
2501      if (control) {
2502        control.patchValue(
2503          /* Guaranteed to be present, due to the outer forEach. */
2504          value[name],
2505          {
2506            onlySelf: true,
2507            emitEvent: options.emitEvent
2508          }
2509        );
2510      }
2511    });
2512    this.updateValueAndValidity(options);
2513  }
2514  /**
2515   * Resets the `FormGroup`, marks all descendants `pristine` and `untouched` and sets
2516   * the value of all descendants to their default values, or null if no defaults were provided.
2517   *
2518   * You reset to a specific form state by passing in a map of states
2519   * that matches the structure of your form, with control names as keys. The state
2520   * is a standalone value or a form state object with both a value and a disabled
2521   * status.
2522   *
2523   * @param value Resets the control with an initial value,
2524   * or an object that defines the initial value and disabled state.
2525   *
2526   * @param options Configuration options that determine how the control propagates changes
2527   * and emits events when the group is reset.
2528   * * `onlySelf`: When true, each change only affects this control, and not its parent. Default is
2529   * false.
2530   * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
2531   * `valueChanges`
2532   * observables emit events with the latest status and value when the control is reset.
2533   * When false, no events are emitted.
2534   * The configuration options are passed to the {@link AbstractControl#updateValueAndValidity
2535   * updateValueAndValidity} method.
2536   *
2537   * @usageNotes
2538   *
2539   * ### Reset the form group values
2540   *
2541   * ```ts
2542   * const form = new FormGroup({
2543   *   first: new FormControl('first name'),
2544   *   last: new FormControl('last name')
2545   * });
2546   *
2547   * console.log(form.value);  // {first: 'first name', last: 'last name'}
2548   *
2549   * form.reset({ first: 'name', last: 'last name' });
2550   *
2551   * console.log(form.value);  // {first: 'name', last: 'last name'}
2552   * ```
2553   *
2554   * ### Reset the form group values and disabled status
2555   *
2556   * ```ts
2557   * const form = new FormGroup({
2558   *   first: new FormControl('first name'),
2559   *   last: new FormControl('last name')
2560   * });
2561   *
2562   * form.reset({
2563   *   first: {value: 'name', disabled: true},
2564   *   last: 'last'
2565   * });
2566   *
2567   * console.log(form.value);  // {last: 'last'}
2568   * console.log(form.get('first').status);  // 'DISABLED'
2569   * ```
2570   */
2571  reset(value = {}, options = {}) {
2572    this._forEachChild((control, name) => {
2573      control.reset(value ? value[name] : null, {
2574        onlySelf: true,
2575        emitEvent: options.emitEvent
2576      });
2577    });
2578    this._updatePristine(options, this);
2579    this._updateTouched(options, this);
2580    this.updateValueAndValidity(options);
2581  }
2582  /**
2583   * The aggregate value of the `FormGroup`, including any disabled controls.
2584   *
2585   * Retrieves all values regardless of disabled status.
2586   */
2587  getRawValue() {
2588    return this._reduceChildren({}, (acc, control, name) => {
2589      acc[name] = control.getRawValue();
2590      return acc;
2591    });
2592  }
2593  /** @internal */
2594  _syncPendingControls() {
2595    let subtreeUpdated = this._reduceChildren(false, (updated, child) => {
2596      return child._syncPendingControls() ? true : updated;
2597    });
2598    if (subtreeUpdated) this.updateValueAndValidity({
2599      onlySelf: true
2600    });
2601    return subtreeUpdated;
2602  }
2603  /** @internal */
2604  _forEachChild(cb) {
2605    Object.keys(this.controls).forEach((key) => {
2606      const control = this.controls[key];
2607      control && cb(control, key);
2608    });
2609  }
2610  /** @internal */
2611  _setUpControls() {
2612    this._forEachChild((control) => {
2613      control.setParent(this);
2614      control._registerOnCollectionChange(this._onCollectionChange);
2615    });
2616  }
2617  /** @internal */
2618  _updateValue() {
2619    this.value = this._reduceValue();
2620  }
2621  /** @internal */
2622  _anyControls(condition) {
2623    for (const [controlName, control] of Object.entries(this.controls)) {
2624      if (this.contains(controlName) && condition(control)) {
2625        return true;
2626      }
2627    }
2628    return false;
2629  }
2630  /** @internal */
2631  _reduceValue() {
2632    let acc = {};
2633    return this._reduceChildren(acc, (acc2, control, name) => {
2634      if (control.enabled || this.disabled) {
2635        acc2[name] = control.value;
2636      }
2637      return acc2;
2638    });
2639  }
2640  /** @internal */
2641  _reduceChildren(initValue, fn) {
2642    let res = initValue;
2643    this._forEachChild((control, name) => {
2644      res = fn(res, control, name);
2645    });
2646    return res;
2647  }
2648  /** @internal */
2649  _allControlsDisabled() {
2650    for (const controlName of Object.keys(this.controls)) {
2651      if (this.controls[controlName].enabled) {
2652        return false;
2653      }
2654    }
2655    return Object.keys(this.controls).length > 0 || this.disabled;
2656  }
2657  /** @internal */
2658  _find(name) {
2659    return this.controls.hasOwnProperty(name) ? this.controls[name] : null;
2660  }
2661};
2662function validateFormGroupControls(controls) {
2663  const invalidKeys = Object.keys(controls).filter((key) => key.includes("."));
2664  if (invalidKeys.length > 0) {
2665    console.warn(`FormGroup keys cannot include \`.\`, please replace the keys for: ${invalidKeys.join(",")}.`);
2666  }
2667}
2668var FormRecord = class extends FormGroup {
2669};
2670var CALL_SET_DISABLED_STATE = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "CallSetDisabledState" : "", {
2671  providedIn: "root",
2672  factory: () => setDisabledStateDefault
2673});
2674var setDisabledStateDefault = "always";
2675function controlPath(name, parent) {
2676  return [...parent.path, name];
2677}
2678function setUpControl(control, dir, callSetDisabledState = setDisabledStateDefault) {
2679  if (typeof ngDevMode === "undefined" || ngDevMode) {
2680    if (!control) _throwError(dir, "Cannot find control with");
2681    if (!dir.valueAccessor) _throwMissingValueAccessorError(dir);
2682  }
2683  setUpValidators(control, dir);
2684  dir.valueAccessor.writeValue(control.value);
2685  if (control.disabled || callSetDisabledState === "always") {
2686    dir.valueAccessor.setDisabledState?.(control.disabled);
2687  }
2688  setUpViewChangePipeline(control, dir);
2689  setUpModelChangePipeline(control, dir);
2690  setUpBlurPipeline(control, dir);
2691  setUpDisabledChangeHandler(control, dir);
2692}
2693function cleanUpControl(control, dir, validateControlPresenceOnChange = true) {
2694  const noop = () => {
2695    if (validateControlPresenceOnChange && (typeof ngDevMode === "undefined" || ngDevMode)) {
2696      _noControlError(dir);
2697    }
2698  };
2699  if (dir.valueAccessor) {
2700    dir.valueAccessor.registerOnChange(noop);
2701    dir.valueAccessor.registerOnTouched(noop);
2702  }
2703  cleanUpValidators(control, dir);
2704  if (control) {
2705    dir._invokeOnDestroyCallbacks();
2706    control._registerOnCollectionChange(() => {
2707    });
2708  }
2709}
2710function registerOnValidatorChange(validators, onChange) {
2711  validators.forEach((validator) => {
2712    if (validator.registerOnValidatorChange) validator.registerOnValidatorChange(onChange);
2713  });
2714}
2715function setUpDisabledChangeHandler(control, dir) {
2716  if (dir.valueAccessor.setDisabledState) {
2717    const onDisabledChange = (isDisabled) => {
2718      dir.valueAccessor.setDisabledState(isDisabled);
2719    };
2720    control.registerOnDisabledChange(onDisabledChange);
2721    dir._registerOnDestroy(() => {
2722      control._unregisterOnDisabledChange(onDisabledChange);
2723    });
2724  }
2725}
2726function setUpValidators(control, dir) {
2727  const validators = getControlValidators(control);
2728  if (dir.validator !== null) {
2729    control.setValidators(mergeValidators(validators, dir.validator));
2730  } else if (typeof validators === "function") {
2731    control.setValidators([validators]);
2732  }
2733  const asyncValidators = getControlAsyncValidators(control);
2734  if (dir.asyncValidator !== null) {
2735    control.setAsyncValidators(mergeValidators(asyncValidators, dir.asyncValidator));
2736  } else if (typeof asyncValidators === "function") {
2737    control.setAsyncValidators([asyncValidators]);
2738  }
2739  const onValidatorChange = () => control.updateValueAndValidity();
2740  registerOnValidatorChange(dir._rawValidators, onValidatorChange);
2741  registerOnValidatorChange(dir._rawAsyncValidators, onValidatorChange);
2742}
2743function cleanUpValidators(control, dir) {
2744  let isControlUpdated = false;
2745  if (control !== null) {
2746    if (dir.validator !== null) {
2747      const validators = getControlValidators(control);
2748      if (Array.isArray(validators) && validators.length > 0) {
2749        const updatedValidators = validators.filter((validator) => validator !== dir.validator);
2750        if (updatedValidators.length !== validators.length) {
2751          isControlUpdated = true;
2752          control.setValidators(updatedValidators);
2753        }
2754      }
2755    }
2756    if (dir.asyncValidator !== null) {
2757      const asyncValidators = getControlAsyncValidators(control);
2758      if (Array.isArray(asyncValidators) && asyncValidators.length > 0) {
2759        const updatedAsyncValidators = asyncValidators.filter((asyncValidator) => asyncValidator !== dir.asyncValidator);
2760        if (updatedAsyncValidators.length !== asyncValidators.length) {
2761          isControlUpdated = true;
2762          control.setAsyncValidators(updatedAsyncValidators);
2763        }
2764      }
2765    }
2766  }
2767  const noop = () => {
2768  };
2769  registerOnValidatorChange(dir._rawValidators, noop);
2770  registerOnValidatorChange(dir._rawAsyncValidators, noop);
2771  return isControlUpdated;
2772}
2773function setUpViewChangePipeline(control, dir) {
2774  dir.valueAccessor.registerOnChange((newValue) => {
2775    control._pendingValue = newValue;
2776    control._pendingChange = true;
2777    control._pendingDirty = true;
2778    if (control.updateOn === "change") updateControl(control, dir);
2779  });
2780}
2781function setUpBlurPipeline(control, dir) {
2782  dir.valueAccessor.registerOnTouched(() => {
2783    control._pendingTouched = true;
2784    if (control.updateOn === "blur" && control._pendingChange) updateControl(control, dir);
2785    if (control.updateOn !== "submit") control.markAsTouched();
2786  });
2787}
2788function updateControl(control, dir) {
2789  if (control._pendingDirty) control.markAsDirty();
2790  control.setValue(control._pendingValue, {
2791    emitModelToViewChange: false
2792  });
2793  dir.viewToModelUpdate(control._pendingValue);
2794  control._pendingChange = false;
2795}
2796function setUpModelChangePipeline(control, dir) {
2797  const onChange = (newValue, emitModelEvent) => {
2798    dir.valueAccessor.writeValue(newValue);
2799    if (emitModelEvent) dir.viewToModelUpdate(newValue);
2800  };
2801  control.registerOnChange(onChange);
2802  dir._registerOnDestroy(() => {
2803    control._unregisterOnChange(onChange);
2804  });
2805}
2806function setUpFormContainer(control, dir) {
2807  if (control == null && (typeof ngDevMode === "undefined" || ngDevMode)) _throwError(dir, "Cannot find control with");
2808  setUpValidators(control, dir);
2809}
2810function cleanUpFormContainer(control, dir) {
2811  return cleanUpValidators(control, dir);
2812}
2813function _noControlError(dir) {
2814  return _throwError(dir, "There is no FormControl instance attached to form control element with");
2815}
2816function _throwError(dir, message) {
2817  const messageEnd = _describeControlLocation(dir);
2818  throw new Error(`${message} ${messageEnd}`);
2819}
2820function _describeControlLocation(dir) {
2821  const path = dir.path;
2822  if (path && path.length > 1) return `path: '${path.join(" -> ")}'`;
2823  if (path?.[0]) return `name: '${path}'`;
2824  return "unspecified name attribute";
2825}
2826function _throwMissingValueAccessorError(dir) {
2827  const loc = _describeControlLocation(dir);
2828  throw new RuntimeError(-1203, `No value accessor for form control ${loc}.`);
2829}
2830function _throwInvalidValueAccessorError(dir) {
2831  const loc = _describeControlLocation(dir);
2832  throw new RuntimeError(1200, `Value accessor was not provided as an array for form control with ${loc}. Check that the \`NG_VALUE_ACCESSOR\` token is configured as a \`multi: true\` provider.`);
2833}
2834function isPropertyUpdated(changes, viewModel) {
2835  if (!changes.hasOwnProperty("model")) return false;
2836  const change = changes["model"];
2837  if (change.isFirstChange()) return true;
2838  return !Object.is(viewModel, change.currentValue);
2839}
2840function isBuiltInAccessor(valueAccessor) {
2841  return Object.getPrototypeOf(valueAccessor.constructor) === BuiltInControlValueAccessor;
2842}
2843function syncPendingControls(form, directives) {
2844  form._syncPendingControls();
2845  directives.forEach((dir) => {
2846    const control = dir.control;
2847    if (control.updateOn === "submit" && control._pendingChange) {
2848      dir.viewToModelUpdate(control._pendingValue);
2849      control._pendingChange = false;
2850    }
2851  });
2852}
2853function selectValueAccessor(dir, valueAccessors) {
2854  if (!valueAccessors) return null;
2855  if (!Array.isArray(valueAccessors) && (typeof ngDevMode === "undefined" || ngDevMode)) _throwInvalidValueAccessorError(dir);
2856  let defaultAccessor = void 0;
2857  let builtinAccessor = void 0;
2858  let customAccessor = void 0;
2859  valueAccessors.forEach((v) => {
2860    if (v.constructor === DefaultValueAccessor) {
2861      defaultAccessor = v;
2862    } else if (isBuiltInAccessor(v)) {
2863      if (builtinAccessor && (typeof ngDevMode === "undefined" || ngDevMode)) _throwError(dir, "More than one built-in value accessor matches form control with");
2864      builtinAccessor = v;
2865    } else {
2866      if (customAccessor && (typeof ngDevMode === "undefined" || ngDevMode)) _throwError(dir, "More than one custom value accessor matches form control with");
2867      customAccessor = v;
2868    }
2869  });
2870  if (customAccessor) return customAccessor;
2871  if (builtinAccessor) return builtinAccessor;
2872  if (defaultAccessor) return defaultAccessor;
2873  if (typeof ngDevMode === "undefined" || ngDevMode) {
2874    _throwError(dir, "No valid value accessor for form control with");
2875  }
2876  return null;
2877}
2878function removeListItem$1(list, el) {
2879  const index = list.indexOf(el);
2880  if (index > -1) list.splice(index, 1);
2881}
2882function _ngModelWarning(name, type, instance, warningConfig) {
2883  if (warningConfig === "never") return;
2884  if ((warningConfig === null || warningConfig === "once") && !type._ngModelWarningSentOnce || warningConfig === "always" && !instance._ngModelWarningSent) {
2885    console.warn(ngModelWarning(name));
2886    type._ngModelWarningSentOnce = true;
2887    instance._ngModelWarningSent = true;
2888  }
2889}
2890var formDirectiveProvider$1 = {
2891  provide: ControlContainer,
2892  useExisting: forwardRef(() => NgForm)
2893};
2894var resolvedPromise$1 = (() => Promise.resolve())();
2895var NgForm = class _NgForm extends ControlContainer {
2896  callSetDisabledState;
2897  /**
2898   * @description
2899   * Returns whether the form submission has been triggered.
2900   */
2901  get submitted() {
2902    return untracked(this.submittedReactive);
2903  }
2904  /** @internal */
2905  _submitted = computed(() => this.submittedReactive());
2906  submittedReactive = signal(false);
2907  _directives = /* @__PURE__ */ new Set();
2908  /**
2909   * @description
2910   * The `FormGroup` instance created for this form.
2911   */
2912  form;
2913  /**
2914   * @description
2915   * Event emitter for the "ngSubmit" event
2916   */
2917  ngSubmit = new EventEmitter();
2918  /**
2919   * @description
2920   * Tracks options for the `NgForm` instance.
2921   *
2922   * **updateOn**: Sets the default `updateOn` value for all child `NgModels` below it
2923   * unless explicitly set by a child `NgModel` using `ngModelOptions`). Defaults to 'change'.
2924   * Possible values: `'change'` | `'blur'` | `'submit'`.
2925   *
2926   */
2927