ngx-transforms 0.1.0 → 0.3.0

package/fesm2022/ngx-transforms.mjs

@@ -315,22 +315,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImpor
  * @param {boolean} [isReplace=true] - Whether to perform replacement (true) or only highlight matches (false).
  *
  * @returns {string | SafeHtml} - Returns the transformed string or SafeHtml with highlights.
- *
- * @example
- * {{ 'Hello World' | replace:'World':'Universe' }}
- * // Output: Hello Universe
- *
- * {{ 'test123' | replace:/\d+/g:'X':'highlight' }}
- * // Output: test<span class="highlight">X</span>
- *
- * {{ 'Angular is great' | replace:'great':'awesome':'highlight':true }}
- * // Output: Angular is <span class="highlight">awesome</span>
- *
- * {{ 'Angular is great' | replace:'great':'awesome':'highlight':false }}
- * // Output: Angular is <span class="highlight">great</span>
- *
- * <div [innerHTML]="'Angular is great' | replace:'great':'awesome':'highlight':false"></div>
- * // Renders: Angular is <span class="highlight">great</span>
  */
 class ReplacePipe {
     sanitizer = inject(DomSanitizer);
@@ -1204,6 +1188,179 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImpor
                 }]
         }] });
 
+/**
+ * DiffPipe: Returns elements present in the first array but not in the second.
+ *
+ * Supports primitives and objects by property key with dot notation.
+ *
+ * @param {unknown[]} value - The source array.
+ * @param {unknown[]} compared - The array to compare against.
+ * @param {string} [key] - Optional property path for object comparison (supports dot notation).
+ *
+ * @returns {unknown[]} - Elements in value that are not in compared.
+ *
+ * @example
+ * {{ [1, 2, 3, 4, 5] | diff:[3, 4, 5, 6] }}              // [1, 2]
+ * {{ allUsers | diff:activeUsers:'id' }}                    // inactive users
+ * {{ orders | diff:shipped:'meta.trackingId' }}             // unshipped orders
+ */
+class DiffPipe {
+    transform(value, compared, key) {
+        if (!Array.isArray(value)) {
+            return [];
+        }
+        if (!Array.isArray(compared) || compared.length === 0) {
+            return [...value];
+        }
+        if (!key) {
+            const comparedSet = new Set(compared);
+            return value.filter(item => !comparedSet.has(item));
+        }
+        const comparedSet = new Set(compared.map(item => this.getNestedValue(item, key)));
+        return value.filter(item => {
+            const val = this.getNestedValue(item, key);
+            return !comparedSet.has(val);
+        });
+    }
+    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: DiffPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: DiffPipe, isStandalone: true, name: "diff" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: DiffPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'diff',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * EveryPipe: Checks if all elements in an array satisfy a condition.
+ *
+ * Supports primitives (equality check) and objects by property key with dot notation.
+ *
+ * @param {unknown[]} value - The array to check.
+ * @param {unknown} match - The value to match against.
+ * @param {string} [key] - Optional property path to check (supports dot notation).
+ *
+ * @returns {boolean} - True if all elements match, false otherwise.
+ *
+ * @example
+ * {{ [true, true, true] | every:true }}                     // true
+ * {{ users | every:'active':'status' }}                     // are all users active?
+ * {{ orders | every:'shipped':'meta.state' }}               // are all orders shipped?
+ */
+class EveryPipe {
+    transform(value, match, key) {
+        if (!Array.isArray(value) || value.length === 0) {
+            return false;
+        }
+        if (!key) {
+            return value.every(item => item === match);
+        }
+        return value.every(item => this.getNestedValue(item, key) === match);
+    }
+    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: EveryPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: EveryPipe, isStandalone: true, name: "every" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: EveryPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'every',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * IntersectionPipe: Returns elements common to both arrays.
+ *
+ * Supports primitives and objects by property key with dot notation.
+ *
+ * @param {unknown[]} value - The first array.
+ * @param {unknown[]} compared - The second array.
+ * @param {string} [key] - Optional property path for object comparison (supports dot notation).
+ *
+ * @returns {unknown[]} - Elements present in both arrays.
+ *
+ * @example
+ * {{ [1, 2, 3, 4] | intersection:[3, 4, 5, 6] }}              // [3, 4]
+ * {{ teamA | intersection:teamB:'id' }}                         // shared members
+ * {{ required | intersection:granted:'meta.scope' }}            // matched permissions
+ */
+class IntersectionPipe {
+    transform(value, compared, key) {
+        if (!Array.isArray(value)) {
+            return [];
+        }
+        if (!Array.isArray(compared) || compared.length === 0) {
+            return [];
+        }
+        if (!key) {
+            const comparedSet = new Set(compared);
+            return value.filter(item => comparedSet.has(item));
+        }
+        const comparedSet = new Set(compared.map(item => this.getNestedValue(item, key)));
+        return value.filter(item => {
+            const val = this.getNestedValue(item, key);
+            return comparedSet.has(val);
+        });
+    }
+    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: IntersectionPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: IntersectionPipe, isStandalone: true, name: "intersection" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: IntersectionPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'intersection',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * ChunkPipe: Splits an array into smaller arrays of a specified size.
+ *
+ * @param {unknown[]} value - The array to split.
+ * @param {number} [size=1] - The size of each chunk.
+ *
+ * @returns {unknown[][]} - An array of chunks.
+ *
+ * @example
+ * {{ [1, 2, 3, 4, 5] | chunk:2 }}     // [[1, 2], [3, 4], [5]]
+ * {{ [1, 2, 3, 4, 5, 6] | chunk:3 }}  // [[1, 2, 3], [4, 5, 6]]
+ */
+class ChunkPipe {
+    transform(value, size = 1) {
+        if (!Array.isArray(value) || value.length === 0) {
+            return [];
+        }
+        if (size <= 0) {
+            return [];
+        }
+        const result = [];
+        for (let i = 0; i < value.length; i += size) {
+            result.push(value.slice(i, i + size));
+        }
+        return result;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: ChunkPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: ChunkPipe, isStandalone: true, name: "chunk" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: ChunkPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'chunk',
+                    standalone: true
+                }]
+        }] });
+
 /**
  * FlattenPipe: Flattens nested arrays to a specified depth.
  *
@@ -1235,6 +1392,46 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImpor
                 }]
         }] });
 
+/**
+ * GroupByPipe: Groups array elements by a property value.
+ *
+ * @param {unknown[]} value - The array to group.
+ * @param {string} key - Property path to group by (supports dot notation).
+ *
+ * @returns {Record<string, unknown[]>} - An object where keys are group names and values are arrays.
+ *
+ * @example
+ * {{ users | groupBy:'role' }}              // { admin: [...], editor: [...] }
+ * {{ orders | groupBy:'customer.city' }}    // { 'New York': [...], 'London': [...] }
+ */
+class GroupByPipe {
+    transform(value, key) {
+        if (!Array.isArray(value) || !key) {
+            return {};
+        }
+        return value.reduce((groups, item) => {
+            const groupKey = String(this.getNestedValue(item, key) ?? 'undefined');
+            if (!groups[groupKey]) {
+                groups[groupKey] = [];
+            }
+            groups[groupKey].push(item);
+            return groups;
+        }, {});
+    }
+    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: GroupByPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: GroupByPipe, isStandalone: true, name: "groupBy" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: GroupByPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'groupBy',
+                    standalone: true,
+                }]
+        }] });
+
 /**
  * InitialPipe: Returns all elements except the last n.
  *
@@ -1272,6 +1469,130 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImpor
                 }]
         }] });
 
+/**
+ * OrderByPipe: Sorts an array by a property value.
+ *
+ * @param {unknown[]} value - The array to sort.
+ * @param {string} key - Property path to sort by (supports dot notation).
+ * @param {string} [direction='asc'] - Sort direction: 'asc' or 'desc'.
+ *
+ * @returns {unknown[]} - A new sorted array.
+ *
+ * @example
+ * {{ users | orderBy:'name' }}            // sorted A-Z
+ * {{ users | orderBy:'name':'desc' }}     // sorted Z-A
+ * {{ users | orderBy:'age':'asc' }}       // sorted by age
+ */
+class OrderByPipe {
+    transform(value, key, direction = 'asc') {
+        if (!Array.isArray(value) || value.length <= 1 || !key) {
+            return Array.isArray(value) ? [...value] : [];
+        }
+        const dir = direction === 'desc' ? -1 : 1;
+        return [...value].sort((a, b) => {
+            const valA = this.getNestedValue(a, key);
+            const valB = this.getNestedValue(b, key);
+            if (valA === valB)
+                return 0;
+            if (valA === null || valA === undefined)
+                return 1;
+            if (valB === null || valB === undefined)
+                return -1;
+            if (typeof valA === 'string' && typeof valB === 'string') {
+                return valA.localeCompare(valB) * dir;
+            }
+            if (typeof valA === 'number' && typeof valB === 'number') {
+                return (valA - valB) * dir;
+            }
+            return String(valA).localeCompare(String(valB)) * dir;
+        });
+    }
+    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: OrderByPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: OrderByPipe, isStandalone: true, name: "orderBy" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: OrderByPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'orderBy',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * PluckPipe: Extracts a property value from every object in an array.
+ *
+ * @param {unknown[]} value - The array of objects.
+ * @param {string} key - Property path to extract (supports dot notation).
+ *
+ * @returns {unknown[]} - An array of the extracted values.
+ *
+ * @example
+ * {{ users | pluck:'name' }}                // ['Alice', 'Bob', 'Carol']
+ * {{ orders | pluck:'customer.email' }}     // ['a@test.com', 'b@test.com']
+ */
+class PluckPipe {
+    transform(value, key) {
+        if (!Array.isArray(value) || !key) {
+            return [];
+        }
+        return value.map(item => this.getNestedValue(item, key));
+    }
+    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: PluckPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: PluckPipe, isStandalone: true, name: "pluck" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: PluckPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'pluck',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * RangePipe: Generates a numeric sequence array.
+ *
+ * @param {number} value - The number of items to generate (or the end value when start is provided).
+ * @param {number} [start=0] - The starting number.
+ * @param {number} [step=1] - The increment between each number.
+ *
+ * @returns {number[]} - An array of sequential numbers.
+ *
+ * @example
+ * {{ 5 | range }}            // [0, 1, 2, 3, 4]
+ * {{ 5 | range:1 }}          // [1, 2, 3, 4, 5]
+ * {{ 10 | range:0:2 }}       // [0, 2, 4, 6, 8]
+ */
+class RangePipe {
+    transform(value, start = 0, step = 1) {
+        if (typeof value !== 'number' || isNaN(value) || value <= 0) {
+            return [];
+        }
+        if (step === 0) {
+            return [];
+        }
+        const result = [];
+        for (let i = 0; i < value; i++) {
+            result.push(start + i * step);
+        }
+        return result;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: RangePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: RangePipe, isStandalone: true, name: "range" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: RangePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'range',
+                    standalone: true,
+                }]
+        }] });
+
 /**
  * ReversePipe: Reverses the characters in a string.
  *
@@ -1512,6 +1833,732 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImpor
                 }]
         }] });
 
+/**
+ * WithoutPipe: Excludes specified elements from an array.
+ *
+ * Supports primitives and objects by property key with dot notation.
+ *
+ * @param {unknown[]} value - The array to filter.
+ * @param {unknown[]} excludes - Values to exclude.
+ * @param {string} [key] - Optional property path for object comparison (supports dot notation).
+ *
+ * @returns {unknown[]} - A new array without the excluded elements.
+ *
+ * @example
+ * {{ [1, 2, 3, 4, 5] | without:[2, 4] }}                   // [1, 3, 5]
+ * {{ users | without:['banned']:'status' }}                  // active users
+ * {{ orders | without:['cancelled']:'meta.status' }}         // non-cancelled orders
+ */
+class WithoutPipe {
+    transform(value, excludes, key) {
+        if (!Array.isArray(value)) {
+            return [];
+        }
+        if (!Array.isArray(excludes) || excludes.length === 0) {
+            return [...value];
+        }
+        const excludeSet = new Set(excludes);
+        if (!key) {
+            return value.filter(item => !excludeSet.has(item));
+        }
+        return value.filter(item => {
+            const val = this.getNestedValue(item, key);
+            return !excludeSet.has(val);
+        });
+    }
+    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: WithoutPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: WithoutPipe, isStandalone: true, name: "without" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: WithoutPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'without',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * SomePipe: Checks if at least one element in an array satisfies a condition.
+ *
+ * Supports primitives (equality check) and objects by property key with dot notation.
+ *
+ * @param {unknown[]} value - The array to check.
+ * @param {unknown} match - The value to match against.
+ * @param {string} [key] - Optional property path to check (supports dot notation).
+ *
+ * @returns {boolean} - True if at least one element matches, false otherwise.
+ *
+ * @example
+ * {{ [false, false, true] | some:true }}                    // true
+ * {{ users | some:'admin':'role' }}                          // any admins?
+ * {{ orders | some:'failed':'meta.status' }}                 // any failures?
+ */
+class SomePipe {
+    transform(value, match, key) {
+        if (!Array.isArray(value) || value.length === 0) {
+            return false;
+        }
+        if (!key) {
+            return value.some(item => item === match);
+        }
+        return value.some(item => this.getNestedValue(item, key) === match);
+    }
+    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: SomePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: SomePipe, isStandalone: true, name: "some" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: SomePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'some',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * UnionPipe: Combines two arrays, keeping only unique elements.
+ *
+ * Supports primitives and objects by property key with dot notation.
+ *
+ * @param {unknown[]} value - The first array.
+ * @param {unknown[]} other - The second array.
+ * @param {string} [key] - Optional property path for uniqueness check (supports dot notation).
+ *
+ * @returns {unknown[]} - A merged array with duplicates removed.
+ *
+ * @example
+ * {{ [1, 2, 3] | union:[3, 4, 5] }}                        // [1, 2, 3, 4, 5]
+ * {{ admins | union:editors:'id' }}                          // all unique users
+ * {{ local | union:remote:'meta.uuid' }}                     // merged records
+ */
+class UnionPipe {
+    transform(value, other, key) {
+        if (!Array.isArray(value) && !Array.isArray(other)) {
+            return [];
+        }
+        const first = Array.isArray(value) ? value : [];
+        const second = Array.isArray(other) ? other : [];
+        if (!key) {
+            const seen = new Set();
+            const result = [];
+            for (const item of [...first, ...second]) {
+                if (!seen.has(item)) {
+                    seen.add(item);
+                    result.push(item);
+                }
+            }
+            return result;
+        }
+        const seen = new Set();
+        const result = [];
+        for (const item of [...first, ...second]) {
+            const val = this.getNestedValue(item, key);
+            if (!seen.has(val)) {
+                seen.add(val);
+                result.push(item);
+            }
+        }
+        return result;
+    }
+    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: UnionPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: UnionPipe, isStandalone: true, name: "union" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: UnionPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'union',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * FilterByPipe: Filters an array by matching a search term against object
+ properties.
+ *
+ * @param {unknown[]} value - The array to filter.
+ * @param {string} search - The search term.
+ * @param {string} [key] - Property to search in. If omitted, searches all string
+ properties.
+ *
+ * @returns {unknown[]} - Filtered array with matching items.
+ *
+ * @example
+ * {{ users | filterBy:'alice':'name' }}     // users with 'alice' in name
+ * {{ users | filterBy:'admin':'role' }}     // users with role 'admin'
+ * {{ users | filterBy:'bob' }}              // search all properties for 'bob'
+ */
+class FilterByPipe {
+    transform(value, search, key) {
+        if (!Array.isArray(value) || !search) {
+            return Array.isArray(value) ? [...value] : [];
+        }
+        const term = String(search).toLowerCase();
+        if (key) {
+            return value.filter(item => {
+                const val = this.getNestedValue(item, key);
+                return val !== undefined && val !== null
+                    && String(val).toLowerCase().includes(term);
+            });
+        }
+        return value.filter(item => {
+            if (typeof item === 'object' && item !== null) {
+                return this.searchObject(item, term);
+            }
+            return String(item).toLowerCase().includes(term);
+        });
+    }
+    searchObject(obj, term) {
+        return Object.values(obj).some(val => {
+            if (typeof val === 'string') {
+                return val.toLowerCase().includes(term);
+            }
+            if (typeof val === 'number' || typeof val === 'boolean') {
+                return String(val).toLowerCase().includes(term);
+            }
+            if (typeof val === 'object' && val !== null) {
+                return this.searchObject(val, term);
+            }
+            return false;
+        });
+    }
+    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: FilterByPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: FilterByPipe, isStandalone: true, name: "filterBy" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: FilterByPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'filterBy',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * 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
@@ -1543,14 +2590,40 @@ const ALL_PIPES = [
     TextToSpeechPipe,
     TimeAgoPipePipe,
     // Array
+    ChunkPipe,
+    DiffPipe,
+    EveryPipe,
+    IntersectionPipe,
     Flatten,
+    GroupByPipe,
     InitialPipe,
+    OrderByPipe,
+    PluckPipe,
+    RangePipe,
     ReversePipe,
     SamplePipe,
     ShufflePipe,
     TailPipe,
     TruthifyPipe,
     UniquePipe,
+    WithoutPipe,
+    SomePipe,
+    UnionPipe,
+    FilterByPipe,
+    // Math
+    MinPipe,
+    MaxPipe,
+    SumPipe,
+    AveragePipe,
+    PercentagePipe,
+    CeilPipe,
+    FloorPipe,
+    RoundPipe,
+    SqrtPipe,
+    PowPipe,
+    DegreesPipe,
+    BytesPipe,
+    RadiansPipe,
 ];
 
 // Text
@@ -1559,5 +2632,5 @@ const ALL_PIPES = [
  * Generated bundle index. Do not edit.
  */
 
-export { ALL_PIPES, AsciiArtPipe, BarcodePipe, CamelCasePipe, ColorConvertPipe, CountPipe, CreditCardMaskPipe, DeviceTypePipe, EmailMaskPipe, Flatten, GravatarPipe, HighlightPipe, HtmlEscapePipe, HtmlSanitizePipe, InitialPipe, InitialsPipe, IpAddressMaskPipe, JsonPrettyPipe, KebabCasePipe, MorseCodePipe, QrCodePipe, ReplacePipe, ReversePipe, SamplePipe, ShufflePipe, SnakeCasePipe, TailPipe, TextToSpeechPipe, TimeAgoPipePipe, TitleCasePipe, TruncatePipe, TruthifyPipe, UniquePipe };
+export { ALL_PIPES, AsciiArtPipe, AveragePipe, BarcodePipe, BytesPipe, CamelCasePipe, CeilPipe, ChunkPipe, ColorConvertPipe, CountPipe, CreditCardMaskPipe, DegreesPipe, DeviceTypePipe, DiffPipe, EmailMaskPipe, EveryPipe, FilterByPipe, Flatten, FloorPipe, GravatarPipe, GroupByPipe, HighlightPipe, HtmlEscapePipe, HtmlSanitizePipe, InitialPipe, InitialsPipe, IntersectionPipe, IpAddressMaskPipe, JsonPrettyPipe, KebabCasePipe, MaxPipe, MinPipe, MorseCodePipe, OrderByPipe, PercentagePipe, PluckPipe, PowPipe, QrCodePipe, RadiansPipe, RangePipe, ReplacePipe, ReversePipe, RoundPipe, SamplePipe, ShufflePipe, SnakeCasePipe, SomePipe, SqrtPipe, SumPipe, TailPipe, TextToSpeechPipe, TimeAgoPipePipe, TitleCasePipe, TruncatePipe, TruthifyPipe, UnionPipe, UniquePipe, WithoutPipe };
 //# sourceMappingURL=ngx-transforms.mjs.map