@ngx-formly/core 7.0.1 → 8.0.0

package/fesm2022/ngx-formly-core.mjs

@@ -1,9 +1,9 @@
 import * as i0 from '@angular/core';
-import { Type, TemplateRef, ComponentRef, ChangeDetectorRef, ɵNoopNgZone as _NoopNgZone, VERSION, Input, ViewChildren, Directive, ChangeDetectionStrategy, Component, Injectable, ViewContainerRef, ViewChild, Optional, InjectionToken, inject, Inject, EventEmitter, ContentChildren, Output, NgModule } from '@angular/core';
+import { Type, TemplateRef, ComponentRef, ChangeDetectorRef, ɵNoopNgZone as _NoopNgZone, VERSION, Input, ViewChildren, Directive, ChangeDetectionStrategy, Component, Injectable, Injector, ViewContainerRef, ViewChild, Optional, InjectionToken, inject, Inject, EventEmitter, ContentChildren, Output, NgModule } from '@angular/core';
 import { isObservable, Observable, Subject, of, merge } from 'rxjs';
 import * as i2 from '@angular/forms';
 import { AbstractControl, UntypedFormArray, UntypedFormGroup, FormControl, UntypedFormControl, Validators, NgControl } from '@angular/forms';
-import { tap, map, distinctUntilChanged, startWith, debounceTime, filter, switchMap, take } from 'rxjs/operators';
+import { tap, map, startWith, distinctUntilChanged, skip, debounceTime, filter, switchMap, take } from 'rxjs/operators';
 import * as i1 from '@angular/platform-browser';
 import * as i2$1 from '@angular/common';
 import { DOCUMENT, AsyncPipe, CommonModule } from '@angular/common';
@@ -131,6 +131,7 @@ function isPromise(obj) {
 function clone(value) {
     if (!isObject(value) ||
         isObservable(value) ||
+        isPromise(value) ||
         value instanceof TemplateRef ||
         /* instanceof SafeHtmlImpl */ value.changingThisBreaksApplicationSecurity ||
         ['RegExp', 'FileList', 'File', 'Blob'].indexOf(value.constructor?.name) !== -1) {
@@ -317,7 +318,10 @@ function isSignalRequired() {
     return +VERSION.major > 18 || (+VERSION.major >= 18 && +VERSION.minor >= 1);
 }
 
-function evalStringExpression(expression, argNames) {
+/**
+ * Legacy implementation
+ */
+function evalStringExpressionLegacy(expression, argNames) {
     try {
         return Function(...argNames, `return ${expression};`);
     }
@@ -432,7 +436,7 @@ function clearControl(form) {
     }
 }
 
-class FieldExpressionExtension {
+let FieldExpressionExtension$1 = class FieldExpressionExtension {
     onPopulate(field) {
         if (field._expressions) {
             return;
@@ -515,7 +519,7 @@ class FieldExpressionExtension {
         }
         expr = expr || (() => false);
         if (typeof expr === 'string') {
-            expr = evalStringExpression(expr, ['model', 'formState', 'field']);
+            expr = this._evalStringExpression(expr, ['model', 'formState', 'field']);
         }
         let currentValue;
         return {
@@ -540,6 +544,9 @@ class FieldExpressionExtension {
             },
         };
     }
+    _evalStringExpression(expression, argNames) {
+        return evalStringExpressionLegacy(expression, argNames);
+    }
     checkExpressions(field, ignoreCache = false) {
         if (!field) {
             return false;
@@ -670,6 +677,471 @@ class FieldExpressionExtension {
         }
         return paths;
     }
+};
+
+// CSP-compliant expression parser for Formly expressions
+// Supports: model.path, formState.path, field.path, comparisons, logical operators, and negation
+// Tokenizer
+var TokenType;
+(function (TokenType) {
+    TokenType["IDENTIFIER"] = "IDENTIFIER";
+    TokenType["DOT"] = "DOT";
+    TokenType["BRACKET_OPEN"] = "BRACKET_OPEN";
+    TokenType["BRACKET_CLOSE"] = "BRACKET_CLOSE";
+    TokenType["STRING"] = "STRING";
+    TokenType["NUMBER"] = "NUMBER";
+    TokenType["BOOLEAN"] = "BOOLEAN";
+    TokenType["NULL"] = "NULL";
+    TokenType["UNDEFINED"] = "UNDEFINED";
+    TokenType["OPERATOR"] = "OPERATOR";
+    TokenType["LOGICAL"] = "LOGICAL";
+    TokenType["NOT"] = "NOT";
+    TokenType["ARITHMETIC"] = "ARITHMETIC";
+    TokenType["PAREN_OPEN"] = "PAREN_OPEN";
+    TokenType["PAREN_CLOSE"] = "PAREN_CLOSE";
+    TokenType["TERNARY_QUESTION"] = "TERNARY_QUESTION";
+    TokenType["TERNARY_COLON"] = "TERNARY_COLON";
+    TokenType["EOF"] = "EOF";
+})(TokenType || (TokenType = {}));
+class Tokenizer {
+    constructor(input) {
+        this.pos = 0;
+        this.input = input.trim();
+    }
+    tokenize() {
+        const tokens = [];
+        while (this.pos < this.input.length) {
+            this.skipWhitespace();
+            if (this.pos >= this.input.length)
+                break;
+            const char = this.input[this.pos];
+            // String literals
+            if (char === '"' || char === "'") {
+                tokens.push(this.readString());
+            }
+            // Numbers
+            else if (/\d/.test(char)) {
+                tokens.push(this.readNumber());
+            }
+            // Identifiers and keywords
+            else if (/[a-zA-Z_$]/.test(char)) {
+                tokens.push(this.readIdentifier());
+            }
+            // Operators and symbols
+            else if (char === '.') {
+                tokens.push({ type: TokenType.DOT, value: '.' });
+                this.pos++;
+            }
+            else if (char === '[') {
+                tokens.push({ type: TokenType.BRACKET_OPEN, value: '[' });
+                this.pos++;
+            }
+            else if (char === ']') {
+                tokens.push({ type: TokenType.BRACKET_CLOSE, value: ']' });
+                this.pos++;
+            }
+            else if (char === '(') {
+                tokens.push({ type: TokenType.PAREN_OPEN, value: '(' });
+                this.pos++;
+            }
+            else if (char === ')') {
+                tokens.push({ type: TokenType.PAREN_CLOSE, value: ')' });
+                this.pos++;
+            }
+            else if (char === '?') {
+                tokens.push({ type: TokenType.TERNARY_QUESTION, value: '?' });
+                this.pos++;
+            }
+            else if (char === ':') {
+                tokens.push({ type: TokenType.TERNARY_COLON, value: ':' });
+                this.pos++;
+            }
+            else if (char === '!') {
+                if (this.peek() === '=') {
+                    if (this.input[this.pos + 2] === '=') {
+                        tokens.push({ type: TokenType.OPERATOR, value: '!==' });
+                        this.pos += 3;
+                    }
+                    else {
+                        tokens.push({ type: TokenType.OPERATOR, value: '!=' });
+                        this.pos += 2;
+                    }
+                }
+                else {
+                    tokens.push({ type: TokenType.NOT, value: '!' });
+                    this.pos++;
+                }
+            }
+            else if (char === '=' || char === '<' || char === '>') {
+                tokens.push(this.readOperator());
+            }
+            else if (char === '+' || char === '*' || char === '/' || char === '%') {
+                tokens.push({ type: TokenType.ARITHMETIC, value: char });
+                this.pos++;
+            }
+            else if (char === '-') {
+                // Check if this is a negative number or subtraction
+                // It's a negative number if preceded by an operator, opening paren, or at the start
+                const lastToken = tokens[tokens.length - 1];
+                const isNegativeNumber = tokens.length === 0 ||
+                    lastToken?.type === TokenType.OPERATOR ||
+                    lastToken?.type === TokenType.LOGICAL ||
+                    lastToken?.type === TokenType.ARITHMETIC ||
+                    lastToken?.type === TokenType.PAREN_OPEN ||
+                    lastToken?.type === TokenType.TERNARY_QUESTION ||
+                    lastToken?.type === TokenType.TERNARY_COLON;
+                if (isNegativeNumber && this.peek() && /\d/.test(this.peek())) {
+                    tokens.push(this.readNumber());
+                }
+                else {
+                    tokens.push({ type: TokenType.ARITHMETIC, value: '-' });
+                    this.pos++;
+                }
+            }
+            else if (char === '&' && this.peek() === '&') {
+                tokens.push({ type: TokenType.LOGICAL, value: '&&' });
+                this.pos += 2;
+            }
+            else if (char === '|' && this.peek() === '|') {
+                tokens.push({ type: TokenType.LOGICAL, value: '||' });
+                this.pos += 2;
+            }
+            else {
+                throw new Error(`Unexpected character: ${char} at position ${this.pos}`);
+            }
+        }
+        tokens.push({ type: TokenType.EOF, value: null });
+        return tokens;
+    }
+    skipWhitespace() {
+        while (this.pos < this.input.length && /\s/.test(this.input[this.pos])) {
+            this.pos++;
+        }
+    }
+    peek(offset = 1) {
+        return this.input[this.pos + offset] || '';
+    }
+    readString() {
+        const quote = this.input[this.pos];
+        this.pos++;
+        let value = '';
+        while (this.pos < this.input.length && this.input[this.pos] !== quote) {
+            if (this.input[this.pos] === '\\') {
+                this.pos++;
+                if (this.pos < this.input.length) {
+                    const escaped = this.input[this.pos];
+                    switch (escaped) {
+                        case 'n':
+                            value += '\n';
+                            break;
+                        case 't':
+                            value += '\t';
+                            break;
+                        case 'r':
+                            value += '\r';
+                            break;
+                        default:
+                            value += escaped;
+                    }
+                }
+            }
+            else {
+                value += this.input[this.pos];
+            }
+            this.pos++;
+        }
+        this.pos++; // skip closing quote
+        return { type: TokenType.STRING, value };
+    }
+    readNumber() {
+        let value = '';
+        // Handle negatives
+        if (this.input[this.pos] === '-') {
+            value += '-';
+            this.pos++;
+        }
+        let hasDecimal = false;
+        while (this.pos < this.input.length && /[\d.]/.test(this.input[this.pos])) {
+            if (this.input[this.pos] === '.') {
+                if (hasDecimal) {
+                    throw new Error(`Invalid number format: multiple decimal points at position ${this.pos}`);
+                }
+                hasDecimal = true;
+            }
+            value += this.input[this.pos];
+            this.pos++;
+        }
+        const parsed = parseFloat(value);
+        if (isNaN(parsed)) {
+            throw new Error(`Invalid number format: ${value}`);
+        }
+        return { type: TokenType.NUMBER, value: parsed };
+    }
+    readIdentifier() {
+        let value = '';
+        while (this.pos < this.input.length && /[a-zA-Z0-9_$]/.test(this.input[this.pos])) {
+            value += this.input[this.pos];
+            this.pos++;
+        }
+        // Check for keywords
+        if (value === 'true' || value === 'false') {
+            return { type: TokenType.BOOLEAN, value: value === 'true' };
+        }
+        if (value === 'null') {
+            return { type: TokenType.NULL, value: null };
+        }
+        if (value === 'undefined') {
+            return { type: TokenType.UNDEFINED, value: undefined };
+        }
+        return { type: TokenType.IDENTIFIER, value };
+    }
+    readOperator() {
+        let op = this.input[this.pos];
+        this.pos++;
+        if (this.pos < this.input.length) {
+            const next = this.input[this.pos];
+            if ((op === '=' && next === '=') ||
+                (op === '!' && next === '=') ||
+                (op === '<' && next === '=') ||
+                (op === '>' && next === '=')) {
+                op += next;
+                this.pos++;
+                // Check for === or !==
+                if (this.pos < this.input.length && this.input[this.pos] === '=') {
+                    op += '=';
+                    this.pos++;
+                }
+            }
+        }
+        return { type: TokenType.OPERATOR, value: op };
+    }
+}
+// Parser and Evaluator
+class ExpressionParser {
+    constructor(tokens) {
+        this.pos = 0;
+        this.tokens = tokens;
+    }
+    parse() {
+        const expr = this.parseTernary();
+        return (context) => expr(context);
+    }
+    parseTernary() {
+        const expr = this.parseLogicalOr();
+        if (this.current().type === TokenType.TERNARY_QUESTION) {
+            this.consume(TokenType.TERNARY_QUESTION);
+            const trueExpr = this.parseLogicalOr();
+            this.consume(TokenType.TERNARY_COLON);
+            const falseExpr = this.parseTernary();
+            return (context) => {
+                return expr(context) ? trueExpr(context) : falseExpr(context);
+            };
+        }
+        return expr;
+    }
+    parseLogicalOr() {
+        let left = this.parseLogicalAnd();
+        while (this.current().type === TokenType.LOGICAL && this.current().value === '||') {
+            this.consume(TokenType.LOGICAL);
+            const right = this.parseLogicalAnd();
+            const prevLeft = left;
+            left = (context) => prevLeft(context) || right(context);
+        }
+        return left;
+    }
+    parseLogicalAnd() {
+        let left = this.parseComparison();
+        while (this.current().type === TokenType.LOGICAL && this.current().value === '&&') {
+            this.consume(TokenType.LOGICAL);
+            const right = this.parseComparison();
+            const prevLeft = left;
+            left = (context) => prevLeft(context) && right(context);
+        }
+        return left;
+    }
+    parseComparison() {
+        const left = this.parseAdditive();
+        if (this.current().type === TokenType.OPERATOR) {
+            const op = this.consume(TokenType.OPERATOR).value;
+            const right = this.parseAdditive();
+            return (context) => {
+                const leftVal = left(context);
+                const rightVal = right(context);
+                switch (op) {
+                    case '===':
+                        return leftVal === rightVal;
+                    case '!==':
+                        return leftVal !== rightVal;
+                    case '==':
+                        return leftVal == rightVal;
+                    case '!=':
+                        return leftVal != rightVal;
+                    case '<':
+                        return leftVal < rightVal;
+                    case '<=':
+                        return leftVal <= rightVal;
+                    case '>':
+                        return leftVal > rightVal;
+                    case '>=':
+                        return leftVal >= rightVal;
+                    default:
+                        throw new Error(`Unknown operator: ${op}`);
+                }
+            };
+        }
+        return left;
+    }
+    parseAdditive() {
+        let left = this.parseMultiplicative();
+        while (this.current().type === TokenType.ARITHMETIC &&
+            (this.current().value === '+' || this.current().value === '-')) {
+            const op = this.consume(TokenType.ARITHMETIC).value;
+            const right = this.parseMultiplicative();
+            const prevLeft = left;
+            if (op === '+') {
+                left = (context) => prevLeft(context) + right(context);
+            }
+            else {
+                left = (context) => prevLeft(context) - right(context);
+            }
+        }
+        return left;
+    }
+    parseMultiplicative() {
+        let left = this.parseUnary();
+        while (this.current().type === TokenType.ARITHMETIC &&
+            (this.current().value === '*' || this.current().value === '/' || this.current().value === '%')) {
+            const op = this.consume(TokenType.ARITHMETIC).value;
+            const right = this.parseUnary();
+            const prevLeft = left;
+            if (op === '*') {
+                left = (context) => prevLeft(context) * right(context);
+            }
+            else if (op === '/') {
+                left = (context) => prevLeft(context) / right(context);
+            }
+            else {
+                left = (context) => prevLeft(context) % right(context);
+            }
+        }
+        return left;
+    }
+    parseUnary() {
+        if (this.current().type === TokenType.NOT) {
+            this.consume(TokenType.NOT);
+            const expr = this.parseUnary();
+            return (context) => !expr(context);
+        }
+        return this.parsePrimary();
+    }
+    parsePrimary() {
+        const token = this.current();
+        // Parentheses
+        if (token.type === TokenType.PAREN_OPEN) {
+            this.consume(TokenType.PAREN_OPEN);
+            const expr = this.parseTernary();
+            this.consume(TokenType.PAREN_CLOSE);
+            return expr;
+        }
+        // Literals
+        if (token.type === TokenType.STRING ||
+            token.type === TokenType.NUMBER ||
+            token.type === TokenType.BOOLEAN ||
+            token.type === TokenType.NULL ||
+            token.type === TokenType.UNDEFINED) {
+            const value = token.value;
+            this.pos++;
+            return () => value;
+        }
+        // Property access (model.field, formState.prop, etc)
+        if (token.type === TokenType.IDENTIFIER) {
+            return this.parsePropertyAccess();
+        }
+        throw new Error(`Unexpected token: ${JSON.stringify(token)}`);
+    }
+    parsePropertyAccess() {
+        const path = [];
+        // Read first identifier
+        path.push(this.consume(TokenType.IDENTIFIER).value);
+        // Read rest of path (dots and brackets)
+        while (this.current().type === TokenType.DOT || this.current().type === TokenType.BRACKET_OPEN) {
+            if (this.current().type === TokenType.DOT) {
+                this.consume(TokenType.DOT);
+                path.push(this.consume(TokenType.IDENTIFIER).value);
+            }
+            else {
+                this.consume(TokenType.BRACKET_OPEN);
+                // bracket notation can contain expressions
+                if (this.current().type === TokenType.STRING) {
+                    path.push(this.consume(TokenType.STRING).value);
+                }
+                else if (this.current().type === TokenType.NUMBER) {
+                    path.push(String(this.consume(TokenType.NUMBER).value));
+                }
+                else {
+                    // dynamic property access
+                    const expr = this.parseTernary();
+                    path.push(expr);
+                }
+                this.consume(TokenType.BRACKET_CLOSE);
+            }
+        }
+        return (context) => {
+            let value = context;
+            for (const segment of path) {
+                if (value === null || value === undefined) {
+                    return undefined;
+                }
+                if (typeof segment === 'function') {
+                    value = value[segment(context)];
+                }
+                else {
+                    value = value[segment];
+                }
+            }
+            return value;
+        };
+    }
+    current() {
+        return this.tokens[this.pos];
+    }
+    consume(expectedType) {
+        const token = this.current();
+        if (token.type !== expectedType) {
+            throw new Error(`Expected ${expectedType}, got ${token.type}`);
+        }
+        this.pos++;
+        return token;
+    }
+}
+/**
+ * Uses CSP-safe implementation
+ */
+function parseExpression(expression, argNames) {
+    try {
+        const tokenizer = new Tokenizer(expression);
+        const tokens = tokenizer.tokenize();
+        const parser = new ExpressionParser(tokens);
+        const evaluator = parser.parse();
+        // Return a function that maps the args to the context
+        return (...args) => {
+            const context = {};
+            argNames.forEach((name, i) => {
+                context[name] = args[i];
+            });
+            return evaluator(context);
+        };
+    }
+    catch (error) {
+        console.error('Expression parse error:', error);
+        return undefined;
+    }
+}
+
+class FieldExpressionExtension extends FieldExpressionExtension$1 {
+    _evalStringExpression(expression, argNames) {
+        return parseExpression(expression, argNames);
+    }
 }
 
 class CoreExtension {
@@ -1122,10 +1594,10 @@ class FieldType {
     get formState() {
         return this.options?.formState || {};
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FieldType, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: FieldType, inputs: { field: "field" }, viewQueries: [{ propertyName: "_formlyControls", predicate: NgControl, descendants: true }], ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: FieldType, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.25", type: FieldType, isStandalone: true, inputs: { field: "field" }, viewQueries: [{ propertyName: "_formlyControls", predicate: NgControl, descendants: true }], ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FieldType, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: FieldType, decorators: [{
             type: Directive
         }], propDecorators: { _formlyControls: [{
                 type: ViewChildren,
@@ -1152,15 +1624,16 @@ class FormlyTemplateType extends FieldType {
         this.sanitizer = sanitizer;
         this.innerHtml = {};
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlyTemplateType, deps: [{ token: i1.DomSanitizer }], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: FormlyTemplateType, selector: "formly-template", usesInheritance: true, ngImport: i0, template: `<div [innerHtml]="template"></div>`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: FormlyTemplateType, deps: [{ token: i1.DomSanitizer }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: FormlyTemplateType, isStandalone: false, selector: "formly-template", usesInheritance: true, ngImport: i0, template: `<div [innerHtml]="template"></div>`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlyTemplateType, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: FormlyTemplateType, decorators: [{
             type: Component,
             args: [{
                     selector: 'formly-template',
                     template: `<div [innerHtml]="template"></div>`,
                     changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: false,
                 }]
         }], ctorParameters: () => [{ type: i1.DomSanitizer }] });
 
@@ -1389,10 +1862,10 @@ class FormlyConfig {
             this.types[name].wrappers = extendedType.wrappers;
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlyConfig, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlyConfig, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: FormlyConfig, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: FormlyConfig, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlyConfig, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: FormlyConfig, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
@@ -1404,10 +1877,10 @@ class FormlyTemplate {
     ngOnChanges() {
         this.name = this.name || 'formly-group';
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlyTemplate, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: FormlyTemplate, isStandalone: true, selector: "[formlyTemplate]", inputs: { name: ["formlyTemplate", "name"] }, usesOnChanges: true, ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: FormlyTemplate, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.25", type: FormlyTemplate, isStandalone: true, selector: "[formlyTemplate]", inputs: { name: ["formlyTemplate", "name"] }, usesOnChanges: true, ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlyTemplate, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: FormlyTemplate, decorators: [{
             type: Directive,
             args: [{ selector: '[formlyTemplate]', standalone: true }]
         }], ctorParameters: () => [{ type: i0.TemplateRef }], propDecorators: { name: [{
@@ -1415,19 +1888,19 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImpo
                 args: ['formlyTemplate']
             }] } });
 class LegacyFormlyTemplate extends FormlyTemplate {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LegacyFormlyTemplate, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: LegacyFormlyTemplate, selector: "[formlyTemplate]", usesInheritance: true, ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: LegacyFormlyTemplate, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.25", type: LegacyFormlyTemplate, isStandalone: false, selector: "[formlyTemplate]", usesInheritance: true, ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LegacyFormlyTemplate, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: LegacyFormlyTemplate, decorators: [{
             type: Directive,
             args: [{ selector: '[formlyTemplate]', standalone: false }]
         }] });
 // workarround for https://github.com/angular/angular/issues/43227#issuecomment-904173738
 class FormlyFieldTemplates {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlyFieldTemplates, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlyFieldTemplates }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: FormlyFieldTemplates, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: FormlyFieldTemplates }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlyFieldTemplates, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: FormlyFieldTemplates, decorators: [{
             type: Injectable
         }] });
 
@@ -1447,11 +1920,12 @@ class FormlyField {
         }
         return null;
     }
-    constructor(config, renderer, _elementRef, hostContainerRef, form) {
+    constructor(config, renderer, _elementRef, hostContainerRef, injector, form) {
         this.config = config;
         this.renderer = renderer;
         this._elementRef = _elementRef;
         this.hostContainerRef = hostContainerRef;
+        this.injector = injector;
         this.form = form;
         this.hostObservers = [];
         this.componentRefs = [];
@@ -1514,7 +1988,7 @@ class FormlyField {
             const inlineType = this.form?.templates?.find((ref) => ref.name === f.type);
             let ref;
             if (inlineType) {
-                ref = containerRef.createEmbeddedView(inlineType.ref, { $implicit: f });
+                ref = containerRef.createEmbeddedView(inlineType.ref, { $implicit: f }, { injector: this.createFieldInjector() });
             }
             else {
                 const { component } = this.config.getType(f.type, true);
@@ -1542,6 +2016,28 @@ class FormlyField {
             this.render();
         }
     }
+    attachLocalField(field, previousField) {
+        const currentField = this.field;
+        if (!currentField) {
+            return;
+        }
+        const localFields = (currentField._localFields || []).filter((f) => f !== field && f !== previousField);
+        if (field && field !== currentField) {
+            localFields.push(field);
+        }
+        if (currentField._localFields) {
+            currentField._localFields = localFields;
+        }
+        else if (localFields.length > 0) {
+            defineHiddenProp(currentField, '_localFields', localFields);
+        }
+    }
+    createFieldInjector() {
+        return Injector.create({
+            providers: [{ provide: FormlyField, useValue: this }],
+            parent: this.injector,
+        });
+    }
     attachComponentRef(ref, field) {
         this.componentRefs.push(ref);
         field._componentRefs.push(ref);
@@ -1651,7 +2147,7 @@ class FormlyField {
         }
         if (field.formControl && !field.fieldGroup) {
             const control = field.formControl;
-            let valueChanges = control.valueChanges.pipe(map((value) => {
+            let valueChanges = control.valueChanges.pipe(startWith(control.value), map((value) => {
                 field.parsers?.map((parserFn) => (value = parserFn(value, field)));
                 if (!Object.is(value, field.formControl.value)) {
                     field.formControl.setValue(value);
@@ -1662,7 +2158,7 @@ class FormlyField {
                     return false;
                 }
                 return true;
-            }));
+            }), skip(1));
             if (control.value !== getFieldValue(field)) {
                 valueChanges = valueChanges.pipe(startWith(control.value));
             }
@@ -1692,13 +2188,13 @@ class FormlyField {
             templateFieldsSubs.forEach((unsubscribe) => unsubscribe());
         };
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlyField, deps: [{ token: FormlyConfig }, { token: i0.Renderer2 }, { token: i0.ElementRef }, { token: i0.ViewContainerRef }, { token: FormlyFieldTemplates, optional: true }], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: FormlyField, isStandalone: true, selector: "formly-field", inputs: { field: "field" }, viewQueries: [{ propertyName: "viewContainerRef", first: true, predicate: ["container"], descendants: true, read: ViewContainerRef, static: true }], usesOnChanges: true, ngImport: i0, template: '<ng-template #container></ng-template>', isInline: true, styles: [":host:empty{display:none}\n"] }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: FormlyField, deps: [{ token: FormlyConfig }, { token: i0.Renderer2 }, { token: i0.ElementRef }, { token: i0.ViewContainerRef }, { token: i0.Injector }, { token: FormlyFieldTemplates, optional: true }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: FormlyField, isStandalone: true, selector: "formly-field", inputs: { field: "field" }, viewQueries: [{ propertyName: "viewContainerRef", first: true, predicate: ["container"], descendants: true, read: ViewContainerRef, static: true }], usesOnChanges: true, ngImport: i0, template: '<ng-template #container></ng-template>', isInline: true, styles: [":host:empty{display:none}\n"] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlyField, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: FormlyField, decorators: [{
             type: Component,
             args: [{ selector: 'formly-field', template: '<ng-template #container></ng-template>', standalone: true, styles: [":host:empty{display:none}\n"] }]
-        }], ctorParameters: () => [{ type: FormlyConfig }, { type: i0.Renderer2 }, { type: i0.ElementRef }, { type: i0.ViewContainerRef }, { type: FormlyFieldTemplates, decorators: [{
+        }], ctorParameters: () => [{ type: FormlyConfig }, { type: i0.Renderer2 }, { type: i0.ElementRef }, { type: i0.ViewContainerRef }, { type: i0.Injector }, { type: FormlyFieldTemplates, decorators: [{
                     type: Optional
                 }] }], propDecorators: { field: [{
                 type: Input
@@ -1707,25 +2203,25 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImpo
                 args: ['container', { read: ViewContainerRef, static: true }]
             }] } });
 class LegacyFormlyField extends FormlyField {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LegacyFormlyField, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: LegacyFormlyField, selector: "formly-field", usesInheritance: true, ngImport: i0, template: '<ng-template #container></ng-template>', isInline: true, styles: [":host:empty{display:none}\n"] }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: LegacyFormlyField, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: LegacyFormlyField, isStandalone: false, selector: "formly-field", usesInheritance: true, ngImport: i0, template: '<ng-template #container></ng-template>', isInline: true, styles: [":host:empty{display:none}\n"] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LegacyFormlyField, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: LegacyFormlyField, decorators: [{
             type: Component,
             args: [{ selector: 'formly-field', template: '<ng-template #container></ng-template>', standalone: false, styles: [":host:empty{display:none}\n"] }]
         }] });
 
 /** @ignore */
 class FormlyGroup extends FieldType {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlyGroup, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: FormlyGroup, selector: "formly-group", host: { properties: { "class": "field.fieldGroupClassName || \"\"" } }, usesInheritance: true, ngImport: i0, template: `
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: FormlyGroup, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "19.2.25", type: FormlyGroup, isStandalone: false, selector: "formly-group", host: { properties: { "class": "field.fieldGroupClassName || \"\"" } }, usesInheritance: true, ngImport: i0, template: `
     @for (f of field.fieldGroup; track $index) {
       <formly-field [field]="f"></formly-field>
     }
     <ng-content></ng-content>
   `, isInline: true, dependencies: [{ kind: "component", type: LegacyFormlyField, selector: "formly-field" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlyGroup, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: FormlyGroup, decorators: [{
             type: Component,
             args: [{
                     selector: 'formly-group',
@@ -1739,6 +2235,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImpo
                         '[class]': 'field.fieldGroupClassName || ""',
                     },
                     changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: false,
                 }]
         }] });
 
@@ -1756,12 +2253,28 @@ function withDefaultConfig(config) {
             { name: 'core', extension: new CoreExtension(config), priority: -250 },
             { name: 'field-validation', extension: new FieldValidationExtension(config), priority: -200 },
             { name: 'field-form', extension: new FieldFormExtension(), priority: -150 },
-            { name: 'field-expression', extension: new FieldExpressionExtension(), priority: -100 },
+            {
+                name: 'field-expression',
+                extension: new FieldExpressionExtension$1(),
+                priority: -100,
+            },
+        ],
+    };
+}
+function withFormlyFieldExpression() {
+    return {
+        extensions: [
+            {
+                name: 'field-expression',
+                extension: new FieldExpressionExtension(),
+                priority: -100,
+            },
         ],
     };
 }
 const provideFormlyCore = (configs = []) => {
     return [
+        FormlyConfig,
         { provide: FORMLY_CONFIG, multi: true, useFactory: withDefaultConfig, deps: [FormlyConfig] },
         provideFormlyConfig(configs),
     ];
@@ -1775,8 +2288,9 @@ const provideFormlyConfig = (configs = []) => {
                 skipSelf: true,
                 optional: true,
             });
-            if (currentConfig) {
-                currentConfig.push(configs);
+            if (currentConfig && inject(FormlyConfig) === inject(FormlyConfig, { skipSelf: true, optional: true })) {
+                configs = Array.isArray(configs) ? configs : [configs];
+                currentConfig.push(...configs);
                 return currentConfig;
             }
             return configs;
@@ -1858,10 +2372,10 @@ class FormlyFormBuilder {
             }
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlyFormBuilder, deps: [{ token: FormlyConfig }, { token: i0.Injector }, { token: i0.ViewContainerRef, optional: true }, { token: i2.FormGroupDirective, optional: true }, { token: FORMLY_CONFIG, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlyFormBuilder, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: FormlyFormBuilder, deps: [{ token: FormlyConfig }, { token: i0.Injector }, { token: i0.ViewContainerRef, optional: true }, { token: i2.FormGroupDirective, optional: true }, { token: FORMLY_CONFIG, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: FormlyFormBuilder, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlyFormBuilder, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: FormlyFormBuilder, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [{ type: FormlyConfig }, { type: i0.Injector }, { type: i0.ViewContainerRef, decorators: [{
@@ -1985,18 +2499,18 @@ class FormlyForm {
             Object.keys(field).forEach((p) => (this.field[p] = field[p]));
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlyForm, deps: [{ token: FormlyFormBuilder }, { token: FormlyConfig }, { token: i0.NgZone }, { token: FormlyFieldTemplates }], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: FormlyForm, isStandalone: true, selector: "formly-form", inputs: { form: "form", model: "model", fields: "fields", options: "options" }, outputs: { modelChange: "modelChange" }, providers: [FormlyFormBuilder, FormlyFieldTemplates], queries: [{ propertyName: "templates", predicate: FormlyTemplate }], usesOnChanges: true, ngImport: i0, template: '<formly-field [field]="field"></formly-field>', isInline: true, dependencies: [{ kind: "component", type: FormlyField, selector: "formly-field", inputs: ["field"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: FormlyForm, deps: [{ token: FormlyFormBuilder }, { token: FormlyConfig }, { token: i0.NgZone }, { token: FormlyFieldTemplates }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: FormlyForm, isStandalone: true, selector: "formly-form", inputs: { form: "form", model: "model", fields: "fields", options: "options" }, outputs: { modelChange: "modelChange" }, providers: [FormlyFormBuilder, FormlyFieldTemplates], queries: [{ propertyName: "templates", predicate: FormlyTemplate }], usesOnChanges: true, ngImport: i0, template: '<formly-field [field]="field"></formly-field>', isInline: true, dependencies: [{ kind: "component", type: FormlyField, selector: "formly-field", inputs: ["field"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlyForm, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: FormlyForm, decorators: [{
             type: Component,
             args: [{
                     selector: 'formly-form',
                     template: '<formly-field [field]="field"></formly-field>',
                     providers: [FormlyFormBuilder, FormlyFieldTemplates],
+                    standalone: true,
                     imports: [FormlyField],
                     changeDetection: ChangeDetectionStrategy.OnPush,
-                    standalone: true,
                 }]
         }], ctorParameters: () => [{ type: FormlyFormBuilder }, { type: FormlyConfig }, { type: i0.NgZone }, { type: FormlyFieldTemplates }], propDecorators: { form: [{
                 type: Input
@@ -2016,10 +2530,10 @@ class LegacyFormlyForm extends FormlyForm {
     set templates(templates) {
         this.fieldTemplates.templates = templates;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LegacyFormlyForm, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: LegacyFormlyForm, selector: "formly-form", providers: [FormlyFormBuilder, FormlyFieldTemplates], queries: [{ propertyName: "templates", predicate: LegacyFormlyTemplate }], usesInheritance: true, ngImport: i0, template: '<formly-field [field]="field"></formly-field>', isInline: true, dependencies: [{ kind: "component", type: LegacyFormlyField, selector: "formly-field" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: LegacyFormlyForm, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: LegacyFormlyForm, isStandalone: false, selector: "formly-form", providers: [FormlyFormBuilder, FormlyFieldTemplates], queries: [{ propertyName: "templates", predicate: LegacyFormlyTemplate }], usesInheritance: true, ngImport: i0, template: '<formly-field [field]="field"></formly-field>', isInline: true, dependencies: [{ kind: "component", type: LegacyFormlyField, selector: "formly-field" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LegacyFormlyForm, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: LegacyFormlyForm, decorators: [{
             type: Component,
             args: [{
                     selector: 'formly-form',
@@ -2043,9 +2557,10 @@ class FormlyAttributes {
     get fieldAttrElements() {
         return this.field?.['_elementRefs'] || [];
     }
-    constructor(renderer, elementRef, _document) {
+    constructor(renderer, elementRef, _document, formlyField) {
         this.renderer = renderer;
         this.elementRef = elementRef;
+        this.formlyField = formlyField;
         this.uiAttributesCache = {};
         /**
          * HostBinding doesn't register listeners conditionally which may produce some perf issues.
@@ -2093,8 +2608,10 @@ class FormlyAttributes {
                     }
                 });
             }
-            this.detachElementRef(changes.field.previousValue);
+            const previousField = changes.field.previousValue;
+            this.detachElementRef(previousField);
             this.attachElementRef(changes.field.currentValue);
+            this.formlyField?.attachLocalField(changes.field.currentValue, previousField?._elementRefs?.length ? undefined : previousField);
             if (this.fieldAttrElements.length === 1) {
                 !this.id && this.field.id && this.setAttribute('id', this.field.id);
                 this.focusObserver = observe(this.field, ['focus'], ({ currentValue }) => {
@@ -2126,7 +2643,7 @@ class FormlyAttributes {
                 (!this.props.attributes || !this.props.attributes.hasOwnProperty(attr.toLowerCase()))) {
                 this.uiAttributesCache[attr] = value;
                 if (value || value === 0) {
-                    this.setAttribute(attr, value === true ? attr : `${value}`);
+                    this.setAttribute(attr, this.getSafeAttributeValue(attr, value));
                 }
                 else {
                     this.removeAttribute(attr);
@@ -2137,6 +2654,9 @@ class FormlyAttributes {
     ngOnDestroy() {
         this.uiEvents.listeners.forEach((listener) => listener());
         this.detachElementRef(this.field);
+        if (!this.field?._elementRefs?.length) {
+            this.formlyField?.attachLocalField(undefined, this.field);
+        }
         this.focusObserver?.unsubscribe();
     }
     toggleFocus(value) {
@@ -2184,21 +2704,33 @@ class FormlyAttributes {
         }
     }
     detachElementRef(f) {
-        const index = f?.['_elementRefs'] ? this.fieldAttrElements.indexOf(this.elementRef) : -1;
+        const elements = f?.['_elementRefs'] || [];
+        const index = elements.indexOf(this.elementRef);
         if (index !== -1) {
-            f['_elementRefs'].splice(index, 1);
+            elements.splice(index, 1);
         }
     }
+    getSafeAttributeValue(attr, value) {
+        if (attr === 'pattern') {
+            let pattern = value instanceof RegExp ? value.source : value;
+            // 1. Safely escape unescaped hyphens inside character classes for 'v' flag compatibility
+            pattern = pattern.replace(/(\[[^\]]*?)(?<!\\)-(.*?\])/g, '$1\\-$2');
+            // 2. Cleanly strip leading ^ and trailing $ so HTML5 handles the boundaries natively
+            pattern = pattern.replace(/^^\^/, '').replace(/\$$/, '');
+            return pattern;
+        }
+        return value === true ? attr : `${value}`;
+    }
     setAttribute(attr, value) {
         this.renderer.setAttribute(this.elementRef.nativeElement, attr, value);
     }
     removeAttribute(attr) {
         this.renderer.removeAttribute(this.elementRef.nativeElement, attr);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlyAttributes, deps: [{ token: i0.Renderer2 }, { token: i0.ElementRef }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: FormlyAttributes, isStandalone: true, selector: "[formlyAttributes]", inputs: { field: ["formlyAttributes", "field"], id: "id" }, host: { listeners: { "change": "onHostChange($event)" } }, usesOnChanges: true, ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: FormlyAttributes, deps: [{ token: i0.Renderer2 }, { token: i0.ElementRef }, { token: DOCUMENT }, { token: FormlyField, optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.25", type: FormlyAttributes, isStandalone: true, selector: "[formlyAttributes]", inputs: { field: ["formlyAttributes", "field"], id: "id" }, host: { listeners: { "change": "onHostChange($event)" } }, usesOnChanges: true, ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlyAttributes, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: FormlyAttributes, decorators: [{
             type: Directive,
             args: [{
                     selector: '[formlyAttributes]',
@@ -2210,6 +2742,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImpo
         }], ctorParameters: () => [{ type: i0.Renderer2 }, { type: i0.ElementRef }, { type: undefined, decorators: [{
                     type: Inject,
                     args: [DOCUMENT]
+                }] }, { type: FormlyField, decorators: [{
+                    type: Optional
                 }] }], propDecorators: { field: [{
                 type: Input,
                 args: ['formlyAttributes']
@@ -2217,16 +2751,17 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImpo
                 type: Input
             }] } });
 class LegacyFormlyAttributes extends FormlyAttributes {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LegacyFormlyAttributes, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: LegacyFormlyAttributes, selector: "[formlyAttributes]", host: { listeners: { "change": "onHostChange($event)" } }, usesInheritance: true, ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: LegacyFormlyAttributes, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.25", type: LegacyFormlyAttributes, isStandalone: false, selector: "[formlyAttributes]", host: { listeners: { "change": "onHostChange($event)" } }, usesInheritance: true, ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LegacyFormlyAttributes, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: LegacyFormlyAttributes, decorators: [{
             type: Directive,
             args: [{
                     selector: '[formlyAttributes]',
                     host: {
                         '(change)': 'onHostChange($event)',
                     },
+                    standalone: false,
                 }]
         }] });
 
@@ -2277,10 +2812,10 @@ class FormlyValidationMessage {
         }
         return undefined;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlyValidationMessage, deps: [{ token: FormlyConfig }], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: FormlyValidationMessage, isStandalone: true, selector: "formly-validation-message", inputs: { field: "field" }, usesOnChanges: true, ngImport: i0, template: '{{ errorMessage$ | async }}', isInline: true, dependencies: [{ kind: "pipe", type: AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: FormlyValidationMessage, deps: [{ token: FormlyConfig }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: FormlyValidationMessage, isStandalone: true, selector: "formly-validation-message", inputs: { field: "field" }, usesOnChanges: true, ngImport: i0, template: '{{ errorMessage$ | async }}', isInline: true, dependencies: [{ kind: "pipe", type: AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlyValidationMessage, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: FormlyValidationMessage, decorators: [{
             type: Component,
             args: [{
                     selector: 'formly-validation-message',
@@ -2293,15 +2828,16 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImpo
                 type: Input
             }] } });
 class LegacyFormlyValidationMessage extends FormlyValidationMessage {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LegacyFormlyValidationMessage, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: LegacyFormlyValidationMessage, selector: "formly-validation-message", usesInheritance: true, ngImport: i0, template: '{{ errorMessage$ | async }}', isInline: true, dependencies: [{ kind: "pipe", type: i2$1.AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: LegacyFormlyValidationMessage, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: LegacyFormlyValidationMessage, isStandalone: false, selector: "formly-validation-message", usesInheritance: true, ngImport: i0, template: '{{ errorMessage$ | async }}', isInline: true, dependencies: [{ kind: "pipe", type: i2$1.AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LegacyFormlyValidationMessage, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: LegacyFormlyValidationMessage, decorators: [{
             type: Component,
             args: [{
                     selector: 'formly-validation-message',
                     template: '{{ errorMessage$ | async }}',
                     changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: false,
                 }]
         }] });
 
@@ -2376,10 +2912,10 @@ class FieldArrayType extends FieldType {
             this.options._hiddenFieldsForCheck.push({ field: f });
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FieldArrayType, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: FieldArrayType, usesInheritance: true, ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: FieldArrayType, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.25", type: FieldArrayType, isStandalone: true, usesInheritance: true, ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FieldArrayType, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: FieldArrayType, decorators: [{
             type: Directive
         }] });
 
@@ -2388,10 +2924,10 @@ class FieldWrapper extends FieldType {
     set _staticContent(content) {
         this.fieldComponent = content;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FieldWrapper, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: FieldWrapper, viewQueries: [{ propertyName: "fieldComponent", first: true, predicate: ["fieldComponent"], descendants: true, read: ViewContainerRef }, { propertyName: "_staticContent", first: true, predicate: ["fieldComponent"], descendants: true, read: ViewContainerRef, static: true }], usesInheritance: true, ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: FieldWrapper, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.25", type: FieldWrapper, isStandalone: true, viewQueries: [{ propertyName: "fieldComponent", first: true, predicate: ["fieldComponent"], descendants: true, read: ViewContainerRef }, { propertyName: "_staticContent", first: true, predicate: ["fieldComponent"], descendants: true, read: ViewContainerRef, static: true }], usesInheritance: true, ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FieldWrapper, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: FieldWrapper, decorators: [{
             type: Directive
         }], propDecorators: { fieldComponent: [{
                 type: ViewChild,
@@ -2401,6 +2937,13 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImpo
                 args: ['fieldComponent', { read: ViewContainerRef, static: true }]
             }] } });
 
+/**
+ * Registers Formly components and configuration for NgModule-based applications.
+ *
+ * `forRoot()` provides the shared `FormlyConfig` at the application root, while
+ * `forChild()` adds feature configuration using the inherited service. This follows
+ * Angular's [root/child module registration convention](https://frontendatlas.com/angular/trivia/angular-forroot-forchild).
+ */
 class FormlyModule {
     static forRoot(config = {}) {
         return {
@@ -2423,8 +2966,8 @@ class FormlyModule {
             ],
         };
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlyModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: FormlyModule, declarations: [LegacyFormlyTemplate,
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: FormlyModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.25", ngImport: i0, type: FormlyModule, declarations: [LegacyFormlyTemplate,
             LegacyFormlyForm,
             LegacyFormlyField,
             LegacyFormlyAttributes,
@@ -2436,9 +2979,9 @@ class FormlyModule {
             LegacyFormlyAttributes,
             LegacyFormlyValidationMessage,
             FormlyGroup] }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlyModule, imports: [CommonModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: FormlyModule, imports: [CommonModule] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlyModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: FormlyModule, decorators: [{
             type: NgModule,
             args: [{
                     declarations: [
@@ -2470,5 +3013,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImpo
  * Generated bundle index. Do not edit.
  */
 
-export { FORMLY_CONFIG, FieldArrayType, FieldType, FieldWrapper, FormlyAttributes, FormlyConfig, FormlyField, FormlyForm, FormlyFormBuilder, FormlyModule, FormlyTemplate, FormlyValidationMessage, LegacyFormlyAttributes, LegacyFormlyField, LegacyFormlyForm, LegacyFormlyValidationMessage, provideFormlyConfig, provideFormlyCore, FormlyGroup as ɵFormlyGroup, LegacyFormlyTemplate as ɵFormlyTemplate, clone as ɵclone, defineHiddenProp as ɵdefineHiddenProp, getFieldValue as ɵgetFieldValue, hasKey as ɵhasKey, observe as ɵobserve, reverseDeepMerge as ɵreverseDeepMerge };
+export { FORMLY_CONFIG, FieldArrayType, FieldType, FieldWrapper, FormlyAttributes, FormlyConfig, FormlyField, FormlyForm, FormlyFormBuilder, FormlyModule, FormlyTemplate, FormlyValidationMessage, LegacyFormlyAttributes, LegacyFormlyField, LegacyFormlyForm, LegacyFormlyValidationMessage, provideFormlyConfig, provideFormlyCore, withFormlyFieldExpression, FormlyGroup as ɵFormlyGroup, LegacyFormlyTemplate as ɵFormlyTemplate, clone as ɵclone, defineHiddenProp as ɵdefineHiddenProp, getFieldValue as ɵgetFieldValue, hasKey as ɵhasKey, observe as ɵobserve, reverseDeepMerge as ɵreverseDeepMerge };
 //# sourceMappingURL=ngx-formly-core.mjs.map