ngx-transforms 0.2.0 → 0.3.1

package/fesm2022/ngx-transforms.mjs

@@ -473,6 +473,1397 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImpor
                 }]
         }] });
 
+/**
+ * TrimPipe: Removes whitespace (or specified characters) from both ends of a string.
+ *
+ * By default, trims whitespace. Pass a string of characters to trim those instead.
+ *
+ * @param {string} value - The string to trim.
+ * @param {string} [chars] - Optional set of characters to trim from both ends.
+ *
+ * @returns {string} - The trimmed string, or an empty string if input is invalid.
+ *
+ * @example
+ * {{ '  hello  ' | trim }}                                   // 'hello'
+ * {{ '--hello--' | trim:'-' }}                               // 'hello'
+ * {{ '***title***' | trim:'*' }}                             // 'title'
+ */
+class TrimPipe {
+    transform(value, chars) {
+        if (typeof value !== 'string')
+            return '';
+        if (!chars)
+            return value.trim();
+        const escaped = chars
+            .split('')
+            .map(c => c.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
+            .join('');
+        const regex = new RegExp(`^[${escaped}]+|[${escaped}]+$`, 'g');
+        return value.replace(regex, '');
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: TrimPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: TrimPipe, isStandalone: true, name: "trim" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: TrimPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'trim',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * CapitalizePipe: Uppercases the first character and lowercases the rest.
+ *
+ * Useful for normalizing headings, labels, and proper nouns.
+ * Differs from `upperFirst` which only uppercases the first character without
+ * altering the remaining characters.
+ *
+ * @param {string} value - The string to capitalize.
+ *
+ * @returns {string} - The capitalized string, or an empty string if input is invalid.
+ *
+ * @example
+ * {{ 'hello world' | capitalize }}                           // 'Hello world'
+ * {{ 'HELLO WORLD' | capitalize }}                           // 'Hello world'
+ * {{ 'hELLo' | capitalize }}                                 // 'Hello'
+ */
+class CapitalizePipe {
+    transform(value) {
+        if (typeof value !== 'string' || value.length === 0)
+            return '';
+        return value.charAt(0).toUpperCase() + value.slice(1).toLowerCase();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: CapitalizePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: CapitalizePipe, isStandalone: true, name: "capitalize" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: CapitalizePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'capitalize',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * UpperFirstPipe: Uppercases the first character of a string without altering the rest.
+ *
+ * Differs from `capitalize` which also lowercases the remaining characters.
+ * Useful when you want to preserve acronyms, camelCase, or existing casing.
+ *
+ * @param {string} value - The string to transform.
+ *
+ * @returns {string} - The transformed string, or an empty string if input is invalid.
+ *
+ * @example
+ * {{ 'hello WORLD' | upperFirst }}                           // 'Hello WORLD'
+ * {{ 'javaScript' | upperFirst }}                            // 'JavaScript'
+ * {{ 'apiKey' | upperFirst }}                                // 'ApiKey'
+ */
+class UpperFirstPipe {
+    transform(value) {
+        if (typeof value !== 'string' || value.length === 0)
+            return '';
+        return value.charAt(0).toUpperCase() + value.slice(1);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: UpperFirstPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: UpperFirstPipe, isStandalone: true, name: "upperFirst" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: UpperFirstPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'upperFirst',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * LeftPadPipe: Pads a string on the left until it reaches the target length.
+ *
+ * Wraps JavaScript's native `padStart`. If the input is already at or above
+ * the target length, returns it unchanged. Defaults to padding with spaces.
+ *
+ * @param {string | number} value - The string or number to pad.
+ * @param {number} length - The target length of the resulting string.
+ * @param {string} [char=' '] - The character (or string) to pad with.
+ *
+ * @returns {string} - The padded string, or empty string if input is invalid.
+ *
+ * @example
+ * {{ '5' | leftPad:3:'0' }}                                  // '005'
+ * {{ 42 | leftPad:5 }}                                       // '   42'
+ * {{ 'hi' | leftPad:6:'-' }}                                 // '----hi'
+ */
+class LeftPadPipe {
+    transform(value, length, char = ' ') {
+        if (value === null || value === undefined)
+            return '';
+        const str = typeof value === 'number' ? String(value) : value;
+        if (typeof str !== 'string')
+            return '';
+        if (typeof length !== 'number' || isNaN(length) || length < 0)
+            return str;
+        const padChar = char === '' ? ' ' : char;
+        return str.padStart(length, padChar);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: LeftPadPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: LeftPadPipe, isStandalone: true, name: "leftPad" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: LeftPadPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'leftPad',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * RightPadPipe: Pads a string on the right until it reaches the target length.
+ *
+ * Wraps JavaScript's native `padEnd`. If the input is already at or above
+ * the target length, returns it unchanged. Defaults to padding with spaces.
+ *
+ * @param {string | number} value - The string or number to pad.
+ * @param {number} length - The target length of the resulting string.
+ * @param {string} [char=' '] - The character (or string) to pad with.
+ *
+ * @returns {string} - The padded string, or empty string if input is invalid.
+ *
+ * @example
+ * {{ 'hi' | rightPad:5:'.' }}                                // 'hi...'
+ * {{ 'name' | rightPad:10 }}                                 // 'name      '
+ * {{ 42 | rightPad:5:'0' }}                                  // '42000'
+ */
+class RightPadPipe {
+    transform(value, length, char = ' ') {
+        if (value === null || value === undefined)
+            return '';
+        const str = typeof value === 'number' ? String(value) : value;
+        if (typeof str !== 'string')
+            return '';
+        if (typeof length !== 'number' || isNaN(length) || length < 0)
+            return str;
+        const padChar = char === '' ? ' ' : char;
+        return str.padEnd(length, padChar);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: RightPadPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: RightPadPipe, isStandalone: true, name: "rightPad" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: RightPadPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'rightPad',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * PadPipe: Pads a string on both sides to reach the target length (centers it).
+ *
+ * When the padding is uneven, the extra character goes to the right.
+ * Defaults to padding with spaces.
+ *
+ * @param {string | number} value - The string or number to pad.
+ * @param {number} length - The target length of the resulting string.
+ * @param {string} [char=' '] - The character (or string) to pad with.
+ *
+ * @returns {string} - The padded string, or empty string if input is invalid.
+ *
+ * @example
+ * {{ 'x' | pad:5:'-' }}                                      // '--x--'
+ * {{ 'hi' | pad:6:'*' }}                                     // '**hi**'
+ * {{ 'hi' | pad:7:'*' }}                                     // '**hi***' (extra right)
+ */
+class PadPipe {
+    transform(value, length, char = ' ') {
+        if (value === null || value === undefined)
+            return '';
+        const str = typeof value === 'number' ? String(value) : value;
+        if (typeof str !== 'string')
+            return '';
+        if (typeof length !== 'number' || isNaN(length) || length < 0)
+            return str;
+        if (str.length >= length)
+            return str;
+        const padChar = char === '' ? ' ' : char;
+        const diff = length - str.length;
+        const leftCount = Math.floor(diff / 2);
+        const leftTarget = str.length + leftCount;
+        return str.padStart(leftTarget, padChar).padEnd(length, padChar);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: PadPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: PadPipe, isStandalone: true, name: "pad" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: PadPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'pad',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * RepeatPipe: Repeats a string a given number of times.
+ *
+ * Wraps `String.prototype.repeat`. Optional separator is inserted between repetitions.
+ *
+ * @param {string} value - The string to repeat.
+ * @param {number} count - Number of times to repeat (must be >= 0).
+ * @param {string} [separator=''] - Optional separator placed between repetitions.
+ *
+ * @returns {string} - The repeated string, or an empty string if input is invalid.
+ *
+ * @example
+ * {{ '-' | repeat:10 }}                                      // '----------'
+ * {{ 'ha' | repeat:3 }}                                      // 'hahaha'
+ * {{ 'item' | repeat:3:', ' }}                               // 'item, item, item'
+ */
+class RepeatPipe {
+    transform(value, count, separator = '') {
+        if (typeof value !== 'string')
+            return '';
+        if (typeof count !== 'number' || isNaN(count) || count < 0 || !isFinite(count)) {
+            return '';
+        }
+        const repetitions = Math.floor(count);
+        if (repetitions === 0)
+            return '';
+        if (!separator)
+            return value.repeat(repetitions);
+        return Array(repetitions).fill(value).join(separator);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: RepeatPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: RepeatPipe, isStandalone: true, name: "repeat" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: RepeatPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'repeat',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * SlugifyPipe: Converts a string into a URL-friendly slug.
+ *
+ * Removes diacritics, lowercases, replaces non-alphanumerics with the separator,
+ * collapses consecutive separators, and trims them from the ends.
+ *
+ * @param {string} value - The string to slugify.
+ * @param {string} [separator='-'] - Character used to join words.
+ *
+ * @returns {string} - The slugified string, or an empty string if input is invalid.
+ *
+ * @example
+ * {{ 'Hello World!' | slugify }}                             // 'hello-world'
+ * {{ 'Café & Tea' | slugify }}                               // 'cafe-tea'
+ * {{ 'My Blog Post' | slugify:'_' }}                         // 'my_blog_post'
+ */
+class SlugifyPipe {
+    transform(value, separator = '-') {
+        if (typeof value !== 'string')
+            return '';
+        const sep = separator || '-';
+        const escaped = sep.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        return value
+            .normalize('NFD')
+            .replace(/[\u0300-\u036f]/g, '')
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, sep)
+            .replace(new RegExp(`${escaped}+`, 'g'), sep)
+            .replace(new RegExp(`^${escaped}|${escaped}$`, 'g'), '');
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: SlugifyPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: SlugifyPipe, isStandalone: true, name: "slugify" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: SlugifyPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'slugify',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * StripTagsPipe: Removes HTML tags from a string.
+ *
+ * By default strips every tag. Pass an array of allowed tag names to keep
+ * those specific tags while stripping the rest. HTML comments and DOCTYPEs
+ * are always removed.
+ *
+ * Note: this pipe returns a plain string — the caller is responsible for
+ * binding the output safely (e.g. via `[textContent]`). For sanitization
+ * that also neutralizes dangerous attributes/scripts, use HtmlSanitizePipe.
+ *
+ * @param {string} value - The HTML string to strip.
+ * @param {string[]} [allowedTags] - Optional list of tag names to preserve.
+ *
+ * @returns {string} - The stripped string, or empty string if input is invalid.
+ *
+ * @example
+ * {{ '<p>Hi <b>there</b></p>' | stripTags }}                  // 'Hi there'
+ * {{ '<p>Hi <b>bold</b></p>' | stripTags:['b'] }}             // 'Hi <b>bold</b>'
+ * {{ '<script>alert(1)</script>Safe' | stripTags }}           // 'Safe'
+ */
+class StripTagsPipe {
+    transform(value, allowedTags) {
+        if (typeof value !== 'string')
+            return '';
+        let result = value
+            .replace(/<!--[\s\S]*?-->/g, '')
+            .replace(/<!DOCTYPE[^>]*>/gi, '')
+            .replace(/<script\b[\s\S]*?<\/script>/gi, '')
+            .replace(/<style\b[\s\S]*?<\/style>/gi, '');
+        if (!Array.isArray(allowedTags) || allowedTags.length === 0) {
+            return result.replace(/<\/?[a-zA-Z][^>]*>/g, '');
+        }
+        const allowed = allowedTags
+            .filter(t => typeof t === 'string' && t.length > 0)
+            .map(t => t.toLowerCase().replace(/[^a-z0-9]/g, ''));
+        if (allowed.length === 0) {
+            return result.replace(/<\/?[a-zA-Z][^>]*>/g, '');
+        }
+        const pattern = new RegExp(`</?(?!(?:${allowed.join('|')})\\b)[a-zA-Z][^>]*>`, 'gi');
+        result = result.replace(pattern, '');
+        return result;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: StripTagsPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: StripTagsPipe, isStandalone: true, name: "stripTags" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: StripTagsPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'stripTags',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * EncodeUriPipe: Encodes a full URI by escaping characters that would be invalid.
+ *
+ * Wraps the native `encodeURI`. Preserves URI structural characters
+ * (`: / ? # [ ] @ ! $ & ' ( ) * + , ; =`) so this is suitable for entire URLs,
+ * not for individual query string values (use `encodeURIComponent` for those).
+ *
+ * @param {string} value - The URI to encode.
+ *
+ * @returns {string} - The encoded URI, or empty string if input is invalid.
+ *
+ * @example
+ * {{ 'https://example.com/?q=hi world' | encodeURI }}        // 'https://example.com/?q=hi%20world'
+ * {{ '/path with space.html' | encodeURI }}                  // '/path%20with%20space.html'
+ */
+class EncodeUriPipe {
+    transform(value) {
+        if (typeof value !== 'string')
+            return '';
+        try {
+            return encodeURI(value);
+        }
+        catch {
+            return value;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: EncodeUriPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: EncodeUriPipe, isStandalone: true, name: "encodeURI" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: EncodeUriPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'encodeURI',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * EncodeUriComponentPipe: Encodes a single URI component, escaping reserved characters.
+ *
+ * Wraps the native `encodeURIComponent`. Encodes everything except
+ * `A-Z a-z 0-9 - _ . ! ~ * ' ( )`. Use this for query parameter values,
+ * path segments, or anywhere a value must not collide with URL syntax.
+ *
+ * @param {string} value - The URI component to encode.
+ *
+ * @returns {string} - The encoded component, or empty string if input is invalid.
+ *
+ * @example
+ * {{ 'hi world&you' | encodeURIComponent }}                  // 'hi%20world%26you'
+ * {{ 'foo/bar?baz=1' | encodeURIComponent }}                 // 'foo%2Fbar%3Fbaz%3D1'
+ */
+class EncodeUriComponentPipe {
+    transform(value) {
+        if (typeof value !== 'string')
+            return '';
+        try {
+            return encodeURIComponent(value);
+        }
+        catch {
+            return value;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: EncodeUriComponentPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: EncodeUriComponentPipe, isStandalone: true, name: "encodeURIComponent" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: EncodeUriComponentPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'encodeURIComponent',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * DecodeUriPipe: Decodes a URI previously encoded with `encodeURI`.
+ *
+ * Wraps the native `decodeURI`. Returns the input unchanged if the string
+ * contains a malformed escape sequence.
+ *
+ * @param {string} value - The encoded URI to decode.
+ *
+ * @returns {string} - The decoded URI, or empty string if input is invalid.
+ *
+ * @example
+ * {{ 'https://example.com/?q=hi%20world' | decodeURI }}      // 'https://example.com/?q=hi world'
+ * {{ '/path%20with%20space.html' | decodeURI }}              // '/path with space.html'
+ */
+class DecodeUriPipe {
+    transform(value) {
+        if (typeof value !== 'string')
+            return '';
+        try {
+            return decodeURI(value);
+        }
+        catch {
+            return value;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: DecodeUriPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: DecodeUriPipe, isStandalone: true, name: "decodeURI" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: DecodeUriPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'decodeURI',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * DecodeUriComponentPipe: Decodes a URI component encoded with `encodeURIComponent`.
+ *
+ * Wraps the native `decodeURIComponent`. Returns the input unchanged if the
+ * string contains a malformed escape sequence.
+ *
+ * @param {string} value - The encoded URI component to decode.
+ *
+ * @returns {string} - The decoded component, or empty string if input is invalid.
+ *
+ * @example
+ * {{ 'hi%20world%26you' | decodeURIComponent }}              // 'hi world&you'
+ * {{ 'foo%2Fbar%3Fbaz%3D1' | decodeURIComponent }}           // 'foo/bar?baz=1'
+ */
+class DecodeUriComponentPipe {
+    transform(value) {
+        if (typeof value !== 'string')
+            return '';
+        try {
+            return decodeURIComponent(value);
+        }
+        catch {
+            return value;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: DecodeUriComponentPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: DecodeUriComponentPipe, isStandalone: true, name: "decodeURIComponent" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: DecodeUriComponentPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'decodeURIComponent',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * SplitPipe: Splits a string into an array using the given separator.
+ *
+ * Wraps `String.prototype.split`. Returns an empty array for invalid inputs.
+ *
+ * @param {string} value - The string to split.
+ * @param {string | RegExp} [separator=''] - Character, string, or regex to split on.
+ *   An empty separator splits the string into individual characters.
+ * @param {number} [limit] - Optional maximum number of elements to return.
+ *
+ * @returns {string[]} - The resulting array, or an empty array for invalid input.
+ *
+ * @example
+ * {{ 'a,b,c' | split:',' }}                                  // ['a', 'b', 'c']
+ * {{ 'abc' | split }}                                        // ['a', 'b', 'c']
+ * {{ 'one two three' | split:' ':2 }}                        // ['one', 'two']
+ */
+class SplitPipe {
+    transform(value, separator = '', limit) {
+        if (typeof value !== 'string')
+            return [];
+        if (typeof limit === 'number' && limit >= 0) {
+            return value.split(separator, limit);
+        }
+        return value.split(separator);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: SplitPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: SplitPipe, isStandalone: true, name: "split" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: SplitPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'split',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * MatchPipe: Returns all regex matches found in a string.
+ *
+ * Wraps `String.prototype.match` with a global default. Returns an empty array
+ * when nothing matches or the regex is invalid.
+ *
+ * @param {string} value - The string to search.
+ * @param {string | RegExp} pattern - Pattern string (or RegExp) to match.
+ * @param {string} [flags='g'] - Regex flags used when `pattern` is a string.
+ *
+ * @returns {string[]} - Array of matches, or empty array if none / invalid input.
+ *
+ * @example
+ * {{ 'abc123def456' | match:'[0-9]+' }}                      // ['123', '456']
+ * {{ 'hello world' | match:'[a-z]+' }}                       // ['hello', 'world']
+ * {{ 'HELLO' | match:'[a-z]+':'gi' }}                        // ['HELLO']
+ */
+class MatchPipe {
+    transform(value, pattern, flags = 'g') {
+        if (typeof value !== 'string' || !pattern)
+            return [];
+        try {
+            const regex = typeof pattern === 'string'
+                ? new RegExp(pattern, flags.includes('g') ? flags : flags + 'g')
+                : (pattern.flags.includes('g') ? pattern : new RegExp(pattern.source, pattern.flags + 'g'));
+            const matches = value.match(regex);
+            return matches ?? [];
+        }
+        catch {
+            return [];
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: MatchPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: MatchPipe, isStandalone: true, name: "match" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: MatchPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'match',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * TestPipe: Returns true when a string matches a regex pattern.
+ *
+ * Wraps `RegExp.prototype.test`. Returns false for invalid input or regex.
+ *
+ * @param {string} value - The string to test.
+ * @param {string | RegExp} pattern - Pattern string (or RegExp) to test against.
+ * @param {string} [flags=''] - Regex flags used when `pattern` is a string.
+ *
+ * @returns {boolean} - `true` if the pattern matches anywhere in the string.
+ *
+ * @example
+ * {{ 'abc@x.com' | test:'@' }}                               // true
+ * {{ 'ABC' | test:'[a-z]':'i' }}                             // true
+ * {{ '123' | test:'^[0-9]+$' }}                              // true
+ */
+class TestPipe {
+    transform(value, pattern, flags = '') {
+        if (typeof value !== 'string' || !pattern)
+            return false;
+        try {
+            const regex = typeof pattern === 'string'
+                ? new RegExp(pattern, flags)
+                : pattern;
+            return regex.test(value);
+        }
+        catch {
+            return false;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: TestPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: TestPipe, isStandalone: true, name: "test" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: TestPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'test',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * NewlinesPipe: Replaces line breaks in a string with a custom replacement.
+ *
+ * Handles all common line-break variants (`\n`, `\r\n`, `\r`). Defaults to
+ * `<br>` for HTML display via `[innerHTML]`. Pass any string to customize.
+ *
+ * @param {string} value - The string containing line breaks.
+ * @param {string} [replacement='<br>'] - String inserted in place of each line break.
+ *
+ * @returns {string} - The transformed string, or empty string if input is invalid.
+ *
+ * @example
+ * {{ text | newlines }}                                      // 'a<br>b<br>c' (use [innerHTML])
+ * {{ text | newlines:' | ' }}                                // 'a | b | c'
+ * {{ text | newlines:' ' }}                                  // 'a b c' (flatten to single line)
+ */
+class NewlinesPipe {
+    transform(value, replacement = '<br>') {
+        if (typeof value !== 'string')
+            return '';
+        return value.replace(/\r\n|\r|\n/g, replacement);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: NewlinesPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: NewlinesPipe, isStandalone: true, name: "newlines" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: NewlinesPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'newlines',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * TemplatePipe: Replaces `{key}` placeholders in a string with values from an object.
+ *
+ * Supports dot notation for nested keys. Missing keys are left as-is.
+ *
+ * @param {string} value - The template string containing placeholders like `{name}`.
+ * @param {Record<string, unknown>} [values={}] - Map of keys to replacement values.
+ *
+ * @returns {string} - The interpolated string, or empty string if input is invalid.
+ *
+ * @example
+ * {{ 'Hello {name}!' | template:{name:'Alice'} }}            // 'Hello Alice!'
+ * {{ '{user.name} is {user.age}' | template:{user:{name:'Bob',age:30}} }}  // 'Bob is 30'
+ * {{ 'Hi {missing}!' | template:{name:'Alice'} }}            // 'Hi {missing}!'
+ */
+class TemplatePipe {
+    transform(value, values = {}) {
+        if (typeof value !== 'string')
+            return '';
+        if (!values || typeof values !== 'object')
+            return value;
+        return value.replace(/\{([\w.]+)\}/g, (match, key) => {
+            const resolved = this.getNestedValue(values, key);
+            return resolved === undefined || resolved === null ? match : String(resolved);
+        });
+    }
+    getNestedValue(obj, path) {
+        return path.split('.').reduce((current, segment) => current?.[segment], obj);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: TemplatePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: TemplatePipe, isStandalone: true, name: "template" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: TemplatePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'template',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * LatinizePipe: Strips diacritics (accents) from a string while preserving
+ * casing, spaces, and punctuation.
+ *
+ * Uses Unicode NFD normalization to split combining marks from base letters,
+ * then removes the combining mark range (U+0300–U+036F). Unlike `slugify`,
+ * this pipe leaves the string structure intact — it only removes accents.
+ *
+ * @param {string} value - The string to latinize.
+ *
+ * @returns {string} - The latinized string, or empty string if input is invalid.
+ *
+ * @example
+ * {{ 'Café' | latinize }}                                    // 'Cafe'
+ * {{ 'naïve résumé' | latinize }}                            // 'naive resume'
+ * {{ 'Crème Brûlée' | latinize }}                            // 'Creme Brulee'
+ */
+class LatinizePipe {
+    transform(value) {
+        if (typeof value !== 'string')
+            return '';
+        return value.normalize('NFD').replace(/[̀-ͯ]/g, '');
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: LatinizePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: LatinizePipe, isStandalone: true, name: "latinize" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: LatinizePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'latinize',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * WrapPipe: Surrounds a string with a prefix and optional suffix.
+ *
+ * When no suffix is provided, the prefix is used on both sides.
+ *
+ * @param {string} value - The string to wrap.
+ * @param {string} [prefix=''] - Text to place before the value.
+ * @param {string} [suffix] - Text to place after the value (defaults to prefix).
+ *
+ * @returns {string} - The wrapped string, or empty string if input is invalid.
+ *
+ * @example
+ * {{ 'value' | wrap:'[':']' }}                               // '[value]'
+ * {{ 'bold' | wrap:'**' }}                                   // '**bold**'
+ * {{ 'tag' | wrap:'<':'>' }}                                 // '<tag>'
+ */
+class WrapPipe {
+    transform(value, prefix = '', suffix) {
+        if (typeof value !== 'string')
+            return '';
+        const pfx = typeof prefix === 'string' ? prefix : '';
+        const sfx = suffix === undefined
+            ? pfx
+            : (typeof suffix === 'string' ? suffix : '');
+        return `${pfx}${value}${sfx}`;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: WrapPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: WrapPipe, isStandalone: true, name: "wrap" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: WrapPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'wrap',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * KeysPipe: Returns the own enumerable property names of an object as an array.
+ *
+ * Wraps `Object.keys`. Works on plain objects and arrays. Returns an empty array
+ * for null, undefined, or primitive inputs.
+ *
+ * @param {unknown} value - The object whose keys to extract.
+ *
+ * @returns {string[]} - Array of property names, or an empty array if invalid input.
+ *
+ * @example
+ * {{ { a: 1, b: 2, c: 3 } | keys }}                          // ['a', 'b', 'c']
+ * {{ user | keys }}                                          // ['name', 'age', 'email']
+ * @for (key of obj | keys; track key) { ... }
+ */
+class KeysPipe {
+    transform(value) {
+        if (value === null || value === undefined)
+            return [];
+        if (typeof value !== 'object')
+            return [];
+        return Object.keys(value);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: KeysPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: KeysPipe, isStandalone: true, name: "keys" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: KeysPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'keys',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * ValuesPipe: Returns the own enumerable property values of an object as an array.
+ *
+ * Wraps `Object.values`. Works on plain objects and arrays. Returns an empty array
+ * for null, undefined, or primitive inputs.
+ *
+ * @param {unknown} value - The object whose values to extract.
+ *
+ * @returns {unknown[]} - Array of property values, or an empty array if invalid input.
+ *
+ * @example
+ * {{ { a: 1, b: 2, c: 3 } | values }}                        // [1, 2, 3]
+ * {{ user | values }}                                        // ['Alice', 30, 'a@b.com']
+ * @for (val of obj | values; track $index) { ... }
+ */
+class ValuesPipe {
+    transform(value) {
+        if (value === null || value === undefined)
+            return [];
+        if (typeof value !== 'object')
+            return [];
+        return Object.values(value);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: ValuesPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: ValuesPipe, isStandalone: true, name: "values" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: ValuesPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'values',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * PairsPipe: Returns the own enumerable properties of an object as an array of
+ * [key, value] tuples.
+ *
+ * Wraps `Object.entries`. Works on plain objects and arrays. Returns an empty
+ * array for null, undefined, or primitive inputs.
+ *
+ * @param {unknown} value - The object to convert into key/value pairs.
+ *
+ * @returns {[string, unknown][]} - Array of [key, value] tuples, or empty array.
+ *
+ * @example
+ * {{ { a: 1, b: 2 } | pairs }}                               // [['a', 1], ['b', 2]]
+ * @for (entry of user | pairs; track entry[0]) {
+ *   <li>{{ entry[0] }}: {{ entry[1] }}</li>
+ * }
+ */
+class PairsPipe {
+    transform(value) {
+        if (value === null || value === undefined)
+            return [];
+        if (typeof value !== 'object')
+            return [];
+        return Object.entries(value);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: PairsPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: PairsPipe, isStandalone: true, name: "pairs" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: PairsPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'pairs',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * PickPipe: Returns a new object containing only the specified keys.
+ *
+ * Non-existent keys are skipped silently. Returns an empty object for null,
+ * undefined, or primitive inputs. Does not mutate the input.
+ *
+ * @param {unknown} value - The source object.
+ * @param {string[] | string} keys - Key (or array of keys) to keep.
+ *
+ * @returns {Record<string, unknown>} - A new object with only the picked keys.
+ *
+ * @example
+ * {{ user | pick:['name', 'email'] }}                        // { name: 'Alice', email: 'a@b.com' }
+ * {{ obj | pick:'id' }}                                      // { id: 42 }
+ */
+class PickPipe {
+    transform(value, keys) {
+        if (value === null || value === undefined)
+            return {};
+        if (typeof value !== 'object')
+            return {};
+        const list = Array.isArray(keys) ? keys : (typeof keys === 'string' ? [keys] : []);
+        if (list.length === 0)
+            return {};
+        const source = value;
+        const result = {};
+        for (const key of list) {
+            if (typeof key !== 'string')
+                continue;
+            if (Object.prototype.hasOwnProperty.call(source, key)) {
+                result[key] = source[key];
+            }
+        }
+        return result;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: PickPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: PickPipe, isStandalone: true, name: "pick" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: PickPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'pick',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * OmitPipe: Returns a new object with the specified keys removed.
+ *
+ * Keys that don't exist on the source are ignored. Returns an empty object
+ * for null, undefined, or primitive inputs. Does not mutate the input.
+ *
+ * @param {unknown} value - The source object.
+ * @param {string[] | string} keys - Key (or array of keys) to remove.
+ *
+ * @returns {Record<string, unknown>} - A new object without the omitted keys.
+ *
+ * @example
+ * {{ user | omit:['password'] }}                             // user without password
+ * {{ obj | omit:['internal', '_id'] }}                       // public-safe view
+ */
+class OmitPipe {
+    transform(value, keys) {
+        if (value === null || value === undefined)
+            return {};
+        if (typeof value !== 'object')
+            return {};
+        const list = Array.isArray(keys) ? keys : (typeof keys === 'string' ? [keys] : []);
+        const exclude = new Set(list.filter((k) => typeof k === 'string'));
+        const source = value;
+        const result = {};
+        for (const key of Object.keys(source)) {
+            if (!exclude.has(key)) {
+                result[key] = source[key];
+            }
+        }
+        return result;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: OmitPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: OmitPipe, isStandalone: true, name: "omit" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: OmitPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'omit',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * InvertPipe: Returns a new object with keys and values swapped.
+ *
+ * Values are coerced to strings to become valid keys. When two source keys
+ * share a value, the **last one wins** (use `invertBy` if you need to keep
+ * every collision as an array). Returns an empty object for null, undefined,
+ * or primitive inputs. Does not mutate the input.
+ *
+ * @param {unknown} value - The source object.
+ *
+ * @returns {Record<string, string>} - A new object with keys/values swapped.
+ *
+ * @example
+ * {{ { a: 1, b: 2 } | invert }}                              // { '1': 'a', '2': 'b' }
+ * {{ { en: 'hello', fr: 'bonjour' } | invert }}              // { hello: 'en', bonjour: 'fr' }
+ * {{ { a: 1, b: 1 } | invert }}                              // { '1': 'b' } (last wins)
+ */
+class InvertPipe {
+    transform(value) {
+        if (value === null || value === undefined)
+            return {};
+        if (typeof value !== 'object')
+            return {};
+        const source = value;
+        const result = {};
+        for (const key of Object.keys(source)) {
+            const v = source[key];
+            if (v === undefined)
+                continue;
+            result[String(v)] = key;
+        }
+        return result;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: InvertPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: InvertPipe, isStandalone: true, name: "invert" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: InvertPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'invert',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * InvertByPipe: Returns a new object with values as keys, grouping the original
+ * keys for each value into an array.
+ *
+ * Unlike `invert`, no data is lost when multiple source keys share a value —
+ * they're collected into an array under the shared key.
+ *
+ * @param {unknown} value - The source object.
+ *
+ * @returns {Record<string, string[]>} - A new object with values-as-keys
+ *   pointing at arrays of the original keys.
+ *
+ * @example
+ * {{ { a: 1, b: 2, c: 1 } | invertBy }}                      // { '1': ['a', 'c'], '2': ['b'] }
+ * {{ { alice: 'admin', bob: 'user', carol: 'admin' } | invertBy }}
+ *   // { admin: ['alice', 'carol'], user: ['bob'] }
+ */
+class InvertByPipe {
+    transform(value) {
+        if (value === null || value === undefined)
+            return {};
+        if (typeof value !== 'object')
+            return {};
+        const source = value;
+        const result = {};
+        for (const key of Object.keys(source)) {
+            const v = source[key];
+            if (v === undefined)
+                continue;
+            const stringKey = String(v);
+            if (!result[stringKey])
+                result[stringKey] = [];
+            result[stringKey].push(key);
+        }
+        return result;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: InvertByPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: InvertByPipe, isStandalone: true, name: "invertBy" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: InvertByPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'invertBy',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * DiffObjPipe: Returns the slice of `value` whose properties differ from `compareTo`.
+ *
+ * For each key in `value`, the entry is included in the result when:
+ * - The key is missing from `compareTo`, or
+ * - `value[key]` is not strictly equal (`!==`) to `compareTo[key]`.
+ *
+ * Comparison is shallow — nested objects/arrays are compared by reference.
+ *
+ * @param {unknown} value - The source object.
+ * @param {unknown} compareTo - The object to compare against.
+ *
+ * @returns {Record<string, unknown>} - A new object containing the differing entries.
+ *
+ * @example
+ * {{ { a: 1, b: 2 } | diffObj:{ a: 1, b: 99 } }}              // { b: 2 }
+ * {{ { a: 1, b: 2, c: 3 } | diffObj:{ a: 1 } }}               // { b: 2, c: 3 }
+ * {{ { a: 1 } | diffObj:{ a: 1 } }}                           // {} (no differences)
+ */
+class DiffObjPipe {
+    transform(value, compareTo) {
+        if (value === null || value === undefined)
+            return {};
+        if (typeof value !== 'object')
+            return {};
+        const source = value;
+        if (compareTo === null || compareTo === undefined || typeof compareTo !== 'object') {
+            return { ...source };
+        }
+        const target = compareTo;
+        const result = {};
+        for (const key of Object.keys(source)) {
+            if (!Object.prototype.hasOwnProperty.call(target, key) || source[key] !== target[key]) {
+                result[key] = source[key];
+            }
+        }
+        return result;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: DiffObjPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: DiffObjPipe, isStandalone: true, name: "diffObj" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: DiffObjPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'diffObj',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * IsDefinedPipe: Returns `true` when the value is neither `null` nor `undefined`.
+ *
+ * Useful for guarding optional bindings in templates without resorting to
+ * verbose `value !== null && value !== undefined` checks. Empty strings,
+ * `0`, and `false` are all considered defined.
+ *
+ * @param {unknown} value - The value to test.
+ *
+ * @returns {boolean} - `true` if defined, `false` if null/undefined.
+ *
+ * @example
+ * {{ user | isDefined }}      // true when user is set
+ * {{ 0 | isDefined }}         // true
+ * {{ '' | isDefined }}        // true
+ * {{ null | isDefined }}      // false
+ * {{ undefined | isDefined }} // false
+ */
+class IsDefinedPipe {
+    transform(value) {
+        return value !== null && value !== undefined;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: IsDefinedPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: IsDefinedPipe, isStandalone: true, name: "isDefined" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: IsDefinedPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'isDefined',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * IsNullPipe: Returns `true` only when the value is exactly `null`.
+ *
+ * Strict check — `undefined` returns `false`. Use `isDefined` (with `!`) if
+ * you want to catch both null and undefined together.
+ *
+ * @param {unknown} value - The value to test.
+ *
+ * @returns {boolean} - `true` if the value is null, `false` otherwise.
+ *
+ * @example
+ * {{ null | isNull }}      // true
+ * {{ undefined | isNull }} // false
+ * {{ 0 | isNull }}         // false
+ * {{ '' | isNull }}        // false
+ */
+class IsNullPipe {
+    transform(value) {
+        return value === null;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: IsNullPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: IsNullPipe, isStandalone: true, name: "isNull" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: IsNullPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'isNull',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * IsStringPipe: Returns `true` when the value is a primitive string.
+ *
+ * Uses `typeof value === 'string'` — boxed `String` objects (rare) are not
+ * matched. Useful for polymorphic templates that render values from JSON,
+ * dynamic forms, or `unknown`-typed data.
+ *
+ * @param {unknown} value - The value to test.
+ *
+ * @returns {boolean} - `true` if the value is a string primitive, `false` otherwise.
+ *
+ * @example
+ * {{ 'hello' | isString }}  // true
+ * {{ '' | isString }}       // true
+ * {{ 42 | isString }}       // false
+ * {{ null | isString }}     // false
+ */
+class IsStringPipe {
+    transform(value) {
+        return typeof value === 'string';
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: IsStringPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: IsStringPipe, isStandalone: true, name: "isString" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: IsStringPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'isString',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * IsNumberPipe: Returns `true` when the value is a primitive number.
+ *
+ * Uses `typeof value === 'number'`. By design `NaN` returns `true` because
+ * its type is `number` — if you need a finite-only check, follow up with
+ * `Number.isFinite`. Numeric strings (e.g. `'42'`) return `false`.
+ *
+ * @param {unknown} value - The value to test.
+ *
+ * @returns {boolean} - `true` if the value is a number primitive, `false` otherwise.
+ *
+ * @example
+ * {{ 42 | isNumber }}      // true
+ * {{ 0 | isNumber }}       // true
+ * {{ NaN | isNumber }}     // true
+ * {{ '42' | isNumber }}    // false
+ * {{ null | isNumber }}    // false
+ */
+class IsNumberPipe {
+    transform(value) {
+        return typeof value === 'number';
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: IsNumberPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: IsNumberPipe, isStandalone: true, name: "isNumber" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: IsNumberPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'isNumber',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * IsArrayPipe: Returns `true` when the value is an Array.
+ *
+ * Backed by `Array.isArray`, so array-likes (NodeList, HTMLCollection,
+ * arguments, typed arrays) all return `false`. Use it to discriminate between
+ * structural and scalar inputs in polymorphic templates.
+ *
+ * @param {unknown} value - The value to test.
+ *
+ * @returns {boolean} - `true` if the value is an array, `false` otherwise.
+ *
+ * @example
+ * {{ [1, 2, 3] | isArray }}     // true
+ * {{ [] | isArray }}            // true
+ * {{ 'abc' | isArray }}         // false
+ * {{ { length: 0 } | isArray }} // false
+ */
+class IsArrayPipe {
+    transform(value) {
+        return Array.isArray(value);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: IsArrayPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: IsArrayPipe, isStandalone: true, name: "isArray" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: IsArrayPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'isArray',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * IsObjectPipe: Returns `true` when the value is a non-null object that is
+ * not an array.
+ *
+ * Lenient — class instances, Date, Map, Set, and RegExp all return `true`
+ * because their JS type is "object". Only `null` and arrays are excluded.
+ * Pair with `isArray` to discriminate between the two structural shapes.
+ *
+ * @param {unknown} value - The value to test.
+ *
+ * @returns {boolean} - `true` if the value is a non-null, non-array object.
+ *
+ * @example
+ * {{ { a: 1 } | isObject }} // true
+ * {{ {} | isObject }}       // true
+ * {{ [1, 2] | isObject }}   // false
+ * {{ null | isObject }}     // false
+ * {{ 'abc' | isObject }}    // false
+ */
+class IsObjectPipe {
+    transform(value) {
+        return value !== null && typeof value === 'object' && !Array.isArray(value);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: IsObjectPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: IsObjectPipe, isStandalone: true, name: "isObject" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: IsObjectPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'isObject',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * IsFunctionPipe: Returns `true` when the value is callable.
+ *
+ * Backed by `typeof value === 'function'`, so arrow functions, regular
+ * functions, async functions, generator functions, and class constructors
+ * all return `true`. Methods and bound functions count too.
+ *
+ * @param {unknown} value - The value to test.
+ *
+ * @returns {boolean} - `true` if the value is a function, `false` otherwise.
+ *
+ * @example
+ * {{ (() => 0) | isFunction }} // true
+ * {{ Math.max | isFunction }}  // true
+ * {{ class {} | isFunction }}  // true
+ * {{ 'fn' | isFunction }}      // false
+ */
+class IsFunctionPipe {
+    transform(value) {
+        return typeof value === 'function';
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: IsFunctionPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: IsFunctionPipe, isStandalone: true, name: "isFunction" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: IsFunctionPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'isFunction',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * IsEmptyPipe: Returns `true` when the value has nothing in it.
+ *
+ * - `null` / `undefined` → `true`
+ * - `''` (empty string) → `true`
+ * - `[]` (empty array) → `true`
+ * - `{}` (no own enumerable keys) → `true`
+ * - empty `Map` / `Set` → `true`
+ * - everything else (numbers, booleans, dates, functions, non-empty containers) → `false`
+ *
+ * Whitespace strings count as non-empty — chain `trim` first if you want a
+ * "blank" check.
+ *
+ * @param {unknown} value - The value to test.
+ *
+ * @returns {boolean} - `true` if the value is considered empty.
+ *
+ * @example
+ * {{ '' | isEmpty }}       // true
+ * {{ [] | isEmpty }}       // true
+ * {{ {} | isEmpty }}       // true
+ * {{ null | isEmpty }}     // true
+ * {{ ' ' | isEmpty }}      // false (use trim first)
+ * {{ 0 | isEmpty }}        // false
+ */
+class IsEmptyPipe {
+    transform(value) {
+        if (value === null || value === undefined)
+            return true;
+        if (typeof value === 'string' || Array.isArray(value))
+            return value.length === 0;
+        if (value instanceof Map || value instanceof Set)
+            return value.size === 0;
+        if (typeof value === 'object') {
+            // Only plain objects are "empty when no keys".
+            // Built-in types (Date, RegExp) and class instances carry meaning.
+            const proto = Object.getPrototypeOf(value);
+            if (proto === Object.prototype || proto === null) {
+                return Object.keys(value).length === 0;
+            }
+            return false;
+        }
+        return false;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: IsEmptyPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: IsEmptyPipe, isStandalone: true, name: "isEmpty" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: IsEmptyPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'isEmpty',
+                    standalone: true,
+                }]
+        }] });
+
 /**
  * CreditCardMaskPipe: Masks all but the last four digits of a string, optionally controlled by a boolean flag.
  * By default, masking is applied.
@@ -2043,6 +3434,522 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImpor
                 }]
         }] });
 
+/**
+ * MinPipe: Returns the minimum value from an array of numbers or objects.
+ *
+ * Supports primitive number arrays and object arrays by property key with dot notation.
+ *
+ * @param {unknown[]} value - The array to evaluate.
+ * @param {string} [key] - Optional property path for object comparison (supports dot notation).
+ *
+ * @returns {number | undefined} - The minimum value, or undefined if the array is empty/invalid.
+ *
+ * @example
+ * {{ [5, 3, 8, 1, 9] | min }}                              // 1
+ * {{ products | min:'price' }}                               // cheapest price
+ * {{ orders | min:'meta.total' }}                            // lowest order total
+ */
+class MinPipe {
+    transform(value, key) {
+        if (!Array.isArray(value) || value.length === 0) {
+            return undefined;
+        }
+        if (!key) {
+            const numbers = value.filter((item) => typeof item === 'number' && !isNaN(item));
+            return numbers.length === 0 ? undefined : Math.min(...numbers);
+        }
+        const numbers = value
+            .map(item => this.getNestedValue(item, key))
+            .filter((val) => typeof val === 'number' && !isNaN(val));
+        return numbers.length === 0 ? undefined : Math.min(...numbers);
+    }
+    getNestedValue(obj, path) {
+        return path.split('.').reduce((current, segment) => current?.[segment], obj);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: MinPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: MinPipe, isStandalone: true, name: "min" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: MinPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'min',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * MaxPipe: Returns the maximum value from an array of numbers or objects.
+ *
+ * Supports primitive number arrays and object arrays by property key with dot notation.
+ *
+ * @param {unknown[]} value - The array to evaluate.
+ * @param {string} [key] - Optional property path for object comparison (supports dot notation).
+ *
+ * @returns {number | undefined} - The maximum value, or undefined if the array is empty/invalid.
+ *
+ * @example
+ * {{ [5, 3, 8, 1, 9] | max }}                              // 9
+ * {{ products | max:'price' }}                               // highest price
+ * {{ orders | max:'meta.total' }}                            // largest order total
+ */
+class MaxPipe {
+    transform(value, key) {
+        if (!Array.isArray(value) || value.length === 0) {
+            return undefined;
+        }
+        if (!key) {
+            const numbers = value.filter((item) => typeof item === 'number' && !isNaN(item));
+            return numbers.length === 0 ? undefined : Math.max(...numbers);
+        }
+        const numbers = value
+            .map(item => this.getNestedValue(item, key))
+            .filter((val) => typeof val === 'number' && !isNaN(val));
+        return numbers.length === 0 ? undefined : Math.max(...numbers);
+    }
+    getNestedValue(obj, path) {
+        return path.split('.').reduce((current, segment) => current?.[segment], obj);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: MaxPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: MaxPipe, isStandalone: true, name: "max" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: MaxPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'max',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * SumPipe: Returns the sum of all numeric values in an array.
+ *
+ * Supports primitive number arrays and object arrays by property key with dot notation.
+ *
+ * @param {unknown[]} value - The array to evaluate.
+ * @param {string} [key] - Optional property path for object summation (supports dot notation).
+ *
+ * @returns {number | undefined} - The total, or undefined if the array is empty/invalid.
+ *
+ * @example
+ * {{ [10, 20, 30] | sum }}                                  // 60
+ * {{ items | sum:'price' }}                                  // total price
+ * {{ orders | sum:'meta.total' }}                            // grand total
+ */
+class SumPipe {
+    transform(value, key) {
+        if (!Array.isArray(value) || value.length === 0) {
+            return undefined;
+        }
+        if (!key) {
+            const numbers = value.filter((item) => typeof item === 'number' && !isNaN(item));
+            return numbers.length === 0 ? undefined : numbers.reduce((acc, n) => acc + n, 0);
+        }
+        const numbers = value
+            .map(item => this.getNestedValue(item, key))
+            .filter((val) => typeof val === 'number' && !isNaN(val));
+        return numbers.length === 0 ? undefined : numbers.reduce((acc, n) => acc + n, 0);
+    }
+    getNestedValue(obj, path) {
+        return path.split('.').reduce((current, segment) => current?.[segment], obj);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: SumPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: SumPipe, isStandalone: true, name: "sum" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: SumPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'sum',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * AveragePipe: Returns the arithmetic mean of all numeric values in an array.
+ *
+ * Supports primitive number arrays and object arrays by property key with dot notation.
+ *
+ * @param {unknown[]} value - The array to evaluate.
+ * @param {string} [key] - Optional property path for object averaging (supports dot notation).
+ *
+ * @returns {number | undefined} - The average, or undefined if the array is empty/invalid.
+ *
+ * @example
+ * {{ [10, 20, 30] | average }}                              // 20
+ * {{ students | average:'grade' }}                           // average grade
+ * {{ reviews | average:'meta.rating' }}                      // average rating
+ */
+class AveragePipe {
+    transform(value, key) {
+        if (!Array.isArray(value) || value.length === 0) {
+            return undefined;
+        }
+        if (!key) {
+            const numbers = value.filter((item) => typeof item === 'number' && !isNaN(item));
+            return numbers.length === 0 ? undefined : numbers.reduce((acc, n) => acc + n, 0) / numbers.length;
+        }
+        const numbers = value
+            .map(item => this.getNestedValue(item, key))
+            .filter((val) => typeof val === 'number' && !isNaN(val));
+        return numbers.length === 0 ? undefined : numbers.reduce((acc, n) => acc + n, 0) / numbers.length;
+    }
+    getNestedValue(obj, path) {
+        return path.split('.').reduce((current, segment) => current?.[segment], obj);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: AveragePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: AveragePipe, isStandalone: true, name: "average" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: AveragePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'average',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * PercentagePipe: Calculates what percentage a value represents of a total.
+ *
+ * Returns `(value / total) * 100`, optionally rounded to a given number of decimal places.
+ *
+ * @param {number} value - The partial value.
+ * @param {number} total - The total/whole value.
+ * @param {number} [decimals] - Optional number of decimal places to round to.
+ *
+ * @returns {number | undefined} - The percentage, or undefined if inputs are invalid.
+ *
+ * @example
+ * {{ 25 | percentage:200 }}                                 // 12.5
+ * {{ 1 | percentage:3:2 }}                                  // 33.33
+ * {{ 750 | percentage:1000 }}                               // 75
+ */
+class PercentagePipe {
+    transform(value, total, decimals) {
+        if (typeof value !== 'number' || isNaN(value)) {
+            return undefined;
+        }
+        if (typeof total !== 'number' || isNaN(total) || total === 0) {
+            return undefined;
+        }
+        const result = (value / total) * 100;
+        if (typeof decimals === 'number' && decimals >= 0) {
+            const factor = Math.pow(10, decimals);
+            return Math.round(result * factor) / factor;
+        }
+        return result;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: PercentagePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: PercentagePipe, isStandalone: true, name: "percentage" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: PercentagePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'percentage',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * CeilPipe: Rounds a number up to the specified number of decimal places.
+ *
+ * Uses `Math.ceil` — always rounds toward positive infinity.
+ *
+ * @param {number} value - The number to round up.
+ * @param {number} [precision=0] - Number of decimal places to preserve (defaults to 0 = integer).
+ *
+ * @returns {number | undefined} - The rounded-up value, or undefined if the input is invalid.
+ *
+ * @example
+ * {{ 4.1 | ceil }}                                           // 5
+ * {{ 4.123 | ceil:2 }}                                       // 4.13
+ * {{ 0.001 | ceil:2 }}                                       // 0.01
+ * {{ -4.9 | ceil }}                                          // -4
+ */
+class CeilPipe {
+    transform(value, precision = 0) {
+        if (typeof value !== 'number' || isNaN(value)) {
+            return undefined;
+        }
+        if (typeof precision !== 'number' || isNaN(precision) || precision < 0) {
+            return undefined;
+        }
+        const factor = Math.pow(10, precision);
+        return Math.ceil(value * factor) / factor;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: CeilPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: CeilPipe, isStandalone: true, name: "ceil" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: CeilPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'ceil',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * FloorPipe: Rounds a number down to the specified number of decimal places.
+ *
+ * Uses `Math.floor` — always rounds toward negative infinity.
+ *
+ * @param {number} value - The number to round down.
+ * @param {number} [precision=0] - Number of decimal places to preserve (defaults to 0 = integer).
+ *
+ * @returns {number | undefined} - The rounded-down value, or undefined if the input is invalid.
+ *
+ * @example
+ * {{ 4.9 | floor }}                                          // 4
+ * {{ 4.567 | floor:2 }}                                      // 4.56
+ * {{ 0.999 | floor:1 }}                                      // 0.9
+ * {{ -4.1 | floor }}                                         // -5
+ */
+class FloorPipe {
+    transform(value, precision = 0) {
+        if (typeof value !== 'number' || isNaN(value)) {
+            return undefined;
+        }
+        if (typeof precision !== 'number' || isNaN(precision) || precision < 0) {
+            return undefined;
+        }
+        const factor = Math.pow(10, precision);
+        return Math.floor(value * factor) / factor;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: FloorPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: FloorPipe, isStandalone: true, name: "floor" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: FloorPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'floor',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * RoundPipe: Rounds a number to the nearest value at the specified number of decimal places.
+ *
+ * Uses `Math.round` — rounds half-up (e.g. 2.5 → 3, -2.5 → -2).
+ *
+ * @param {number} value - The number to round.
+ * @param {number} [precision=0] - Number of decimal places to preserve (defaults to 0 = integer).
+ *
+ * @returns {number | undefined} - The rounded value, or undefined if the input is invalid.
+ *
+ * @example
+ * {{ 4.4 | round }}                                          // 4
+ * {{ 4.5 | round }}                                          // 5
+ * {{ 4.567 | round:2 }}                                      // 4.57
+ * {{ 0.125 | round:2 }}                                      // 0.13
+ */
+class RoundPipe {
+    transform(value, precision = 0) {
+        if (typeof value !== 'number' || isNaN(value)) {
+            return undefined;
+        }
+        if (typeof precision !== 'number' || isNaN(precision) || precision < 0) {
+            return undefined;
+        }
+        const factor = Math.pow(10, precision);
+        return Math.round(value * factor) / factor;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: RoundPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: RoundPipe, isStandalone: true, name: "round" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: RoundPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'round',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * SqrtPipe: Returns the square root of a number.
+ *
+ * Uses `Math.sqrt`. Returns undefined for negative numbers.
+ *
+ * @param {number} value - The number to compute the square root of.
+ *
+ * @returns {number | undefined} - The square root, or undefined if the input is invalid or negative.
+ *
+ * @example
+ * {{ 9 | sqrt }}                                             // 3
+ * {{ 2 | sqrt }}                                             // 1.4142135623730951
+ * {{ 144 | sqrt }}                                           // 12
+ */
+class SqrtPipe {
+    transform(value) {
+        if (typeof value !== 'number' || isNaN(value)) {
+            return undefined;
+        }
+        if (value < 0) {
+            return undefined;
+        }
+        return Math.sqrt(value);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: SqrtPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: SqrtPipe, isStandalone: true, name: "sqrt" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: SqrtPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'sqrt',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * PowPipe: Raises a number to the specified power.
+ *
+ * Uses `Math.pow`. The exponent defaults to 2 (squaring).
+ *
+ * @param {number} value - The base number.
+ * @param {number} [exponent=2] - The power to raise the base to (defaults to 2).
+ *
+ * @returns {number | undefined} - The result, or undefined if the inputs are invalid.
+ *
+ * @example
+ * {{ 3 | pow }}                                              // 9  (3^2)
+ * {{ 2 | pow:3 }}                                            // 8  (2^3)
+ * {{ 5 | pow:0 }}                                            // 1  (anything^0)
+ */
+class PowPipe {
+    transform(value, exponent = 2) {
+        if (typeof value !== 'number' || isNaN(value)) {
+            return undefined;
+        }
+        if (typeof exponent !== 'number' || isNaN(exponent)) {
+            return undefined;
+        }
+        return Math.pow(value, exponent);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: PowPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: PowPipe, isStandalone: true, name: "pow" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: PowPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'pow',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * DegreesPipe: Converts a value in radians to degrees.
+ *
+ * Formula: `degrees = radians * (180 / Math.PI)`
+ *
+ * @param {number} value - The angle in radians.
+ *
+ * @returns {number | undefined} - The angle in degrees, or undefined if the input is invalid.
+ *
+ * @example
+ * {{ 3.14159 | degrees }}                                    // ~180
+ * {{ 1.5708 | degrees }}                                     // ~90
+ * {{ 0 | degrees }}                                          // 0
+ */
+class DegreesPipe {
+    transform(value) {
+        if (typeof value !== 'number' || isNaN(value)) {
+            return undefined;
+        }
+        return value * (180 / Math.PI);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: DegreesPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: DegreesPipe, isStandalone: true, name: "degrees" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: DegreesPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'degrees',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * BytesPipe: Formats a number of bytes into a human-readable string with appropriate units.
+ *
+ * Supports both binary (1024-based: KiB, MiB, GiB) and decimal (1000-based: KB, MB, GB) units.
+ * Defaults to decimal (1000-based) units.
+ *
+ * @param {number} value - The number of bytes.
+ * @param {number} [decimals=1] - Number of decimal places in the output.
+ * @param {string} [base='decimal'] - Unit base: 'decimal' (1000, KB/MB/GB) or 'binary' (1024, KiB/MiB/GiB).
+ *
+ * @returns {string | undefined} - The formatted string, or undefined if the input is invalid.
+ *
+ * @example
+ * {{ 1536 | bytes }}                                         // "1.5 KB"
+ * {{ 1048576 | bytes:2 }}                                    // "1.05 MB"
+ * {{ 1073741824 | bytes:1:'binary' }}                        // "1.0 GiB"
+ */
+class BytesPipe {
+    decimalUnits = ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB'];
+    binaryUnits = ['B', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB'];
+    transform(value, decimals = 1, base = 'decimal') {
+        if (typeof value !== 'number' || isNaN(value)) {
+            return undefined;
+        }
+        if (value < 0) {
+            return undefined;
+        }
+        if (value === 0) {
+            return '0 B';
+        }
+        const isBinary = base === 'binary';
+        const divisor = isBinary ? 1024 : 1000;
+        const units = isBinary ? this.binaryUnits : this.decimalUnits;
+        let unitIndex = 0;
+        let size = value;
+        while (size >= divisor && unitIndex < units.length - 1) {
+            size /= divisor;
+            unitIndex++;
+        }
+        const precision = typeof decimals === 'number' && decimals >= 0 ? decimals : 1;
+        return `${size.toFixed(precision)} ${units[unitIndex]}`;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: BytesPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: BytesPipe, isStandalone: true, name: "bytes" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: BytesPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'bytes',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * RadiansPipe: Converts a value in degrees to radians.
+ *
+ * Formula: `radians = degrees * (Math.PI / 180)`
+ *
+ * @param {number} value - The angle in degrees.
+ *
+ * @returns {number | undefined} - The angle in radians, or undefined if the input is invalid.
+ *
+ * @example
+ * {{ 180 | radians }}                                        // ~3.14159
+ * {{ 90 | radians }}                                         // ~1.5708
+ * {{ 0 | radians }}                                          // 0
+ */
+class RadiansPipe {
+    transform(value) {
+        if (typeof value !== 'number' || isNaN(value)) {
+            return undefined;
+        }
+        return value * (Math.PI / 180);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: RadiansPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: RadiansPipe, isStandalone: true, name: "radians" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: RadiansPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'radians',
+                    standalone: true,
+                }]
+        }] });
+
 // Text
 const ALL_PIPES = [
     // Text
@@ -2056,6 +3963,44 @@ const ALL_PIPES = [
     SnakeCasePipe,
     TitleCasePipe,
     TruncatePipe,
+    TrimPipe,
+    CapitalizePipe,
+    UpperFirstPipe,
+    LeftPadPipe,
+    RightPadPipe,
+    PadPipe,
+    RepeatPipe,
+    SlugifyPipe,
+    StripTagsPipe,
+    EncodeUriPipe,
+    EncodeUriComponentPipe,
+    DecodeUriPipe,
+    DecodeUriComponentPipe,
+    SplitPipe,
+    MatchPipe,
+    TestPipe,
+    NewlinesPipe,
+    TemplatePipe,
+    LatinizePipe,
+    WrapPipe,
+    // Object
+    KeysPipe,
+    ValuesPipe,
+    PairsPipe,
+    PickPipe,
+    OmitPipe,
+    InvertPipe,
+    InvertByPipe,
+    DiffObjPipe,
+    // Boolean
+    IsDefinedPipe,
+    IsNullPipe,
+    IsStringPipe,
+    IsNumberPipe,
+    IsArrayPipe,
+    IsObjectPipe,
+    IsFunctionPipe,
+    IsEmptyPipe,
     // Security & Privacy
     CreditCardMaskPipe,
     EmailMaskPipe,
@@ -2093,7 +4038,21 @@ const ALL_PIPES = [
     WithoutPipe,
     SomePipe,
     UnionPipe,
-    FilterByPipe
+    FilterByPipe,
+    // Math
+    MinPipe,
+    MaxPipe,
+    SumPipe,
+    AveragePipe,
+    PercentagePipe,
+    CeilPipe,
+    FloorPipe,
+    RoundPipe,
+    SqrtPipe,
+    PowPipe,
+    DegreesPipe,
+    BytesPipe,
+    RadiansPipe,
 ];
 
 // Text
@@ -2102,5 +4061,5 @@ const ALL_PIPES = [
  * Generated bundle index. Do not edit.
  */
 
-export { ALL_PIPES, AsciiArtPipe, BarcodePipe, CamelCasePipe, ChunkPipe, ColorConvertPipe, CountPipe, CreditCardMaskPipe, DeviceTypePipe, DiffPipe, EmailMaskPipe, EveryPipe, FilterByPipe, Flatten, GravatarPipe, GroupByPipe, HighlightPipe, HtmlEscapePipe, HtmlSanitizePipe, InitialPipe, InitialsPipe, IntersectionPipe, IpAddressMaskPipe, JsonPrettyPipe, KebabCasePipe, MorseCodePipe, OrderByPipe, PluckPipe, QrCodePipe, RangePipe, ReplacePipe, ReversePipe, SamplePipe, ShufflePipe, SnakeCasePipe, SomePipe, TailPipe, TextToSpeechPipe, TimeAgoPipePipe, TitleCasePipe, TruncatePipe, TruthifyPipe, UnionPipe, UniquePipe, WithoutPipe };
+export { ALL_PIPES, AsciiArtPipe, AveragePipe, BarcodePipe, BytesPipe, CamelCasePipe, CapitalizePipe, CeilPipe, ChunkPipe, ColorConvertPipe, CountPipe, CreditCardMaskPipe, DecodeUriComponentPipe, DecodeUriPipe, DegreesPipe, DeviceTypePipe, DiffObjPipe, DiffPipe, EmailMaskPipe, EncodeUriComponentPipe, EncodeUriPipe, EveryPipe, FilterByPipe, Flatten, FloorPipe, GravatarPipe, GroupByPipe, HighlightPipe, HtmlEscapePipe, HtmlSanitizePipe, InitialPipe, InitialsPipe, IntersectionPipe, InvertByPipe, InvertPipe, IpAddressMaskPipe, IsArrayPipe, IsDefinedPipe, IsEmptyPipe, IsFunctionPipe, IsNullPipe, IsNumberPipe, IsObjectPipe, IsStringPipe, JsonPrettyPipe, KebabCasePipe, KeysPipe, LatinizePipe, LeftPadPipe, MatchPipe, MaxPipe, MinPipe, MorseCodePipe, NewlinesPipe, OmitPipe, OrderByPipe, PadPipe, PairsPipe, PercentagePipe, PickPipe, PluckPipe, PowPipe, QrCodePipe, RadiansPipe, RangePipe, RepeatPipe, ReplacePipe, ReversePipe, RightPadPipe, RoundPipe, SamplePipe, ShufflePipe, SlugifyPipe, SnakeCasePipe, SomePipe, SplitPipe, SqrtPipe, StripTagsPipe, SumPipe, TailPipe, TemplatePipe, TestPipe, TextToSpeechPipe, TimeAgoPipePipe, TitleCasePipe, TrimPipe, TruncatePipe, TruthifyPipe, UnionPipe, UniquePipe, UpperFirstPipe, ValuesPipe, WithoutPipe, WrapPipe };
 //# sourceMappingURL=ngx-transforms.mjs.map