angular-pipes/fesm2015/angular-pipes.js

Angular pipes library

import { __decorate } from 'tslib';
import { Pipe, NgModule } from '@angular/core';

function isUndefined(value) {
    return typeof value === 'undefined';
}
function isNull(value) {
    return value === null;
}
function isNumber(value) {
    return typeof value === 'number';
}
function isNumberFinite(value) {
    return isNumber(value) && isFinite(value);
}
// Not strict positive
function isPositive(value) {
    return value >= 0;
}
function isInteger(value) {
    // No rest, is an integer
    return value % 1 === 0;
}
function isNil(value) {
    return value === null || typeof value === 'undefined';
}
function isString(value) {
    return typeof value === 'string';
}
function isObject(value) {
    return value !== null && typeof value === 'object';
}
function isArray(value) {
    return Array.isArray(value);
}
function isFunction(value) {
    return typeof value === 'function';
}
function toDecimal(value, decimal) {
    return Math.round(value * Math.pow(10, decimal)) / Math.pow(10, decimal);
}
function upperFirst(value) {
    return value.slice(0, 1).toUpperCase() + value.slice(1);
}
function createRound(method) {
    // <any>Math to suppress error
    const func = Math[method];
    return function (value, precision = 0) {
        if (typeof value === 'string') {
            throw new TypeError('Rounding method needs a number');
        }
        if (typeof precision !== 'number' || isNaN(precision)) {
            precision = 0;
        }
        if (precision) {
            let pair = `${value}e`.split('e');
            const val = func(`${pair[0]}e` + (+pair[1] + precision));
            pair = `${val}e`.split('e');
            return +(pair[0] + 'e' + (+pair[1] - precision));
        }
        return func(value);
    };
}
function leftPad(str, len = 0, ch = ' ') {
    str = String(str);
    ch = toString(ch);
    let i = -1;
    const length = len - str.length;
    while (++i < length && str.length + ch.length <= len) {
        str = ch + str;
    }
    return str;
}
function rightPad(str, len = 0, ch = ' ') {
    str = String(str);
    ch = toString(ch);
    let i = -1;
    const length = len - str.length;
    while (++i < length && str.length + ch.length <= len) {
        str += ch;
    }
    return str;
}
function toString(value) {
    return `${value}`;
}
function pad(str, len = 0, ch = ' ') {
    str = String(str);
    ch = toString(ch);
    let i = -1;
    const length = len - str.length;
    let left = true;
    while (++i < length) {
        const l = str.length + ch.length <= len ? str.length + ch.length : str.length + 1;
        if (left) {
            str = leftPad(str, l, ch);
        }
        else {
            str = rightPad(str, l, ch);
        }
        left = !left;
    }
    return str;
}
function flatten(input, index = 0) {
    if (index >= input.length) {
        return input;
    }
    if (isArray(input[index])) {
        return flatten(input.slice(0, index).concat(input[index], input.slice(index + 1)), index);
    }
    return flatten(input, index + 1);
}
function getProperty(value, key) {
    if (isNil(value) || !isObject(value)) {
        return undefined;
    }
    const keys = key.split('.');
    let result = value[keys.shift()];
    for (const key of keys) {
        if (isNil(result) || !isObject(result)) {
            return undefined;
        }
        result = result[key];
    }
    return result;
}
function sum(input, initial = 0) {
    return input.reduce((previous, current) => previous + current, initial);
}
// http://stackoverflow.com/questions/6274339/how-can-i-shuffle-an-array-in-javascript
function shuffle(input) {
    if (!isArray(input)) {
        return input;
    }
    const copy = [...input];
    for (let i = copy.length; i; --i) {
        const j = Math.floor(Math.random() * i);
        const x = copy[i - 1];
        copy[i - 1] = copy[j];
        copy[j] = x;
    }
    return copy;
}
function deepIndexOf(collection, value) {
    let index = -1;
    const length = collection.length;
    while (++index < length) {
        if (deepEqual(value, collection[index])) {
            return index;
        }
    }
    return -1;
}
function deepEqual(a, b) {
    if (a === b) {
        return true;
    }
    if (!(typeof a === 'object' && typeof b === 'object')) {
        return a === b;
    }
    const keysA = Object.keys(a);
    const keysB = Object.keys(b);
    if (keysA.length !== keysB.length) {
        return false;
    }
    // Test for A's keys different from B.
    var hasOwn = Object.prototype.hasOwnProperty;
    for (let i = 0; i < keysA.length; i++) {
        const key = keysA[i];
        if (!hasOwn.call(b, keysA[i]) || !deepEqual(a[key], b[key])) {
            return false;
        }
    }
    return true;
}
function isDeepObject(object) {
    return object.__isDeepObject__;
}
function wrapDeep(object) {
    return new DeepWrapper(object);
}
function unwrapDeep(object) {
    if (isDeepObject(object)) {
        return object.data;
    }
    return object;
}
class DeepWrapper {
    constructor(data) {
        this.data = data;
        this.__isDeepObject__ = true;
    }
}
function count(input) {
    if (!isArray(input) && !isObject(input) && !isString(input)) {
        return input;
    }
    if (isObject(input)) {
        return Object.keys(input).map(value => input[value]).length;
    }
    return input.length;
}
function empty(input) {
    if (!isArray(input)) {
        return input;
    }
    return input.length === 0;
}
function every(input, predicate) {
    if (!isArray(input) || !predicate) {
        return input;
    }
    let result = true;
    let i = -1;
    while (++i < input.length && result) {
        result = predicate(input[i], i, input);
    }
    return result;
}
function takeUntil(input, predicate) {
    let i = -1;
    const result = [];
    while (++i < input.length && !predicate(input[i], i, input)) {
        result[i] = input[i];
    }
    return result;
}
function takeWhile(input, predicate) {
    return takeUntil(input, (item, index, collection) => !predicate(item, index, collection));
}

let GroupByPipe = class GroupByPipe {
    transform(input, prop) {
        if (!isArray(input)) {
            return input;
        }
        const arr = {};
        for (const value of input) {
            const field = getProperty(value, prop);
            if (isUndefined(arr[field])) {
                arr[field] = [];
            }
            arr[field].push(value);
        }
        return Object.keys(arr).map(key => ({ key, value: arr[key] }));
    }
};
GroupByPipe = __decorate([
    Pipe({
        name: 'groupBy',
    })
], GroupByPipe);
let NgGroupByPipeModule = class NgGroupByPipeModule {
};
NgGroupByPipeModule = __decorate([
    NgModule({
        declarations: [GroupByPipe],
        exports: [GroupByPipe],
    })
], NgGroupByPipeModule);

let MaxPipe = class MaxPipe {
    transform(input) {
        if (!isArray(input)) {
            return input;
        }
        if (input.length === 0) {
            return undefined;
        }
        let max = input[0];
        input.forEach((value) => {
            if (max < value) {
                max = value;
            }
        });
        return max;
    }
};
MaxPipe = __decorate([
    Pipe({
        name: 'max',
    })
], MaxPipe);
let NgMaxPipeModule = class NgMaxPipeModule {
};
NgMaxPipeModule = __decorate([
    NgModule({
        declarations: [MaxPipe],
        exports: [MaxPipe],
    })
], NgMaxPipeModule);

let MeanPipe = class MeanPipe {
    transform(input) {
        if (!isArray(input)) {
            return input;
        }
        const count = input.length;
        if (count === 0) {
            return undefined;
        }
        return sum(input) / count;
    }
};
MeanPipe = __decorate([
    Pipe({
        name: 'mean',
    })
], MeanPipe);
let NgMeanPipeModule = class NgMeanPipeModule {
};
NgMeanPipeModule = __decorate([
    NgModule({
        declarations: [MeanPipe],
        exports: [MeanPipe],
    })
], NgMeanPipeModule);

let MinPipe = class MinPipe {
    transform(input) {
        if (!isArray(input)) {
            return input;
        }
        if (input.length === 0) {
            return undefined;
        }
        let min = input[0];
        input.forEach((value) => {
            if (min > value) {
                min = value;
            }
        });
        return min;
    }
};
MinPipe = __decorate([
    Pipe({
        name: 'min',
    })
], MinPipe);
let NgMinPipeModule = class NgMinPipeModule {
};
NgMinPipeModule = __decorate([
    NgModule({
        declarations: [MinPipe],
        exports: [MinPipe],
    })
], NgMinPipeModule);

let SumPipe = class SumPipe {
    transform(input) {
        return !isArray(input) ? input : sum(input);
    }
};
SumPipe = __decorate([
    Pipe({ name: 'sum' })
], SumPipe);
let NgSumPipeModule = class NgSumPipeModule {
};
NgSumPipeModule = __decorate([
    NgModule({
        declarations: [SumPipe],
        exports: [SumPipe],
    })
], NgSumPipeModule);

let NgAggregatePipesModule = class NgAggregatePipesModule {
};
NgAggregatePipesModule = __decorate([
    NgModule({
        imports: [NgGroupByPipeModule, NgMaxPipeModule, NgMeanPipeModule, NgMinPipeModule, NgSumPipeModule],
    })
], NgAggregatePipesModule);

let EmptyPipe = class EmptyPipe {
    transform(input) {
        return empty(input);
    }
};
EmptyPipe = __decorate([
    Pipe({
        name: 'empty',
    })
], EmptyPipe);
let NgEmptyPipeModule = class NgEmptyPipeModule {
};
NgEmptyPipeModule = __decorate([
    NgModule({
        declarations: [EmptyPipe],
        exports: [EmptyPipe],
    })
], NgEmptyPipeModule);

let HeadPipe = class HeadPipe {
    transform(input) {
        if (!isArray(input)) {
            return input;
        }
        // Will return undefined if length is 0
        return input[0];
    }
};
HeadPipe = __decorate([
    Pipe({
        name: 'head',
    })
], HeadPipe);
let NgHeadPipeModule = class NgHeadPipeModule {
};
NgHeadPipeModule = __decorate([
    NgModule({
        declarations: [HeadPipe],
        exports: [HeadPipe],
    })
], NgHeadPipeModule);

let InitialPipe = class InitialPipe {
    transform(input) {
        if (!isArray(input)) {
            return input;
        }
        return input.slice(0, input.length - 1);
    }
};
InitialPipe = __decorate([
    Pipe({
        name: 'initial',
    })
], InitialPipe);
let NgInitialPipeModule = class NgInitialPipeModule {
};
NgInitialPipeModule = __decorate([
    NgModule({
        declarations: [InitialPipe],
        exports: [InitialPipe],
    })
], NgInitialPipeModule);

let LastPipe = class LastPipe {
    transform(input) {
        if (!isArray(input)) {
            return input;
        }
        // Returns undefined if empty
        return input[input.length - 1];
    }
};
LastPipe = __decorate([
    Pipe({
        name: 'last',
    })
], LastPipe);
let NgLastPipeModule = class NgLastPipeModule {
};
NgLastPipeModule = __decorate([
    NgModule({
        declarations: [LastPipe],
        exports: [LastPipe],
    })
], NgLastPipeModule);

let JoinPipe = class JoinPipe {
    transform(input, character = '') {
        if (!isArray(input)) {
            return input;
        }
        return input.join(character);
    }
};
JoinPipe = __decorate([
    Pipe({
        name: 'join',
    })
], JoinPipe);
let NgJoinPipeModule = class NgJoinPipeModule {
};
NgJoinPipeModule = __decorate([
    NgModule({
        declarations: [JoinPipe],
        exports: [JoinPipe],
    })
], NgJoinPipeModule);

let TailPipe = class TailPipe {
    transform(input) {
        if (!isArray(input)) {
            return input;
        }
        return input.slice(1, input.length);
    }
};
TailPipe = __decorate([
    Pipe({
        name: 'tail',
    })
], TailPipe);
let NgTailPipeModule = class NgTailPipeModule {
};
NgTailPipeModule = __decorate([
    NgModule({
        declarations: [TailPipe],
        exports: [TailPipe],
    })
], NgTailPipeModule);

let UniqPipe = class UniqPipe {
    transform(input) {
        if (!isArray(input) && !isDeepObject(input)) {
            return input;
        }
        if (isDeepObject(input)) {
            const unwrappedInput = unwrapDeep(input);
            if (!isArray(unwrappedInput)) {
                return unwrappedInput;
            }
            return unwrappedInput.filter((value, index) => deepIndexOf(unwrappedInput, value) === index);
        }
        return input.filter((value, index) => input.indexOf(value) === index);
    }
};
UniqPipe = __decorate([
    Pipe({
        name: 'uniq',
    })
], UniqPipe);
let NgUniqPipeModule = class NgUniqPipeModule {
};
NgUniqPipeModule = __decorate([
    NgModule({
        declarations: [UniqPipe],
        exports: [UniqPipe],
    })
], NgUniqPipeModule);

let WithoutPipe = class WithoutPipe {
    transform(input, ...args) {
        if (!isArray(input) && !isDeepObject(input)) {
            return input;
        }
        if (isDeepObject(input)) {
            const unwrappedInput = unwrapDeep(input);
            if (!isArray(unwrappedInput)) {
                return unwrappedInput;
            }
            return unwrappedInput.filter((value) => deepIndexOf(args, value) === -1);
        }
        return input.filter((value) => args.indexOf(value) === -1);
    }
};
WithoutPipe = __decorate([
    Pipe({
        name: 'without',
    })
], WithoutPipe);
let NgWithoutPipeModule = class NgWithoutPipeModule {
};
NgWithoutPipeModule = __decorate([
    NgModule({
        declarations: [WithoutPipe],
        exports: [WithoutPipe],
    })
], NgWithoutPipeModule);

let MapPipe = class MapPipe {
    transform(input, fn) {
        if (!isArray(input) || !fn) {
            return input;
        }
        return input.map(fn);
    }
};
MapPipe = __decorate([
    Pipe({
        name: 'map',
    })
], MapPipe);
let NgMapPipeModule = class NgMapPipeModule {
};
NgMapPipeModule = __decorate([
    NgModule({
        declarations: [MapPipe],
        exports: [MapPipe],
    })
], NgMapPipeModule);

let WherePipe = class WherePipe {
    /**
     * Support a function or a value or the shorthand ['key', value] like the lodash shorthand.
     */
    transform(input, fn) {
        if (!isArray(input)) {
            return input;
        }
        if (isFunction(fn)) {
            return input.filter(fn);
        }
        else if (isArray(fn)) {
            const [key, value] = fn;
            return input.filter((item) => getProperty(item, key) === value);
        }
        else if (fn) {
            return input.filter((item) => item === fn);
        }
        else {
            return input;
        }
    }
};
WherePipe = __decorate([
    Pipe({
        name: 'where',
    })
], WherePipe);
let NgWherePipeModule = class NgWherePipeModule {
};
NgWherePipeModule = __decorate([
    NgModule({
        declarations: [WherePipe],
        exports: [WherePipe],
    })
], NgWherePipeModule);

var FirstOrDefaultPipe_1;
let FirstOrDefaultPipe = FirstOrDefaultPipe_1 = class FirstOrDefaultPipe {
    static find(input, predicate, defaultValue) {
        let found = false;
        let result;
        let i = -1;
        while (!found && ++i < input.length) {
            found = predicate(input[i], i, input);
        }
        if (found) {
            result = input[i];
        }
        if (typeof result === 'undefined' && typeof defaultValue !== 'undefined') {
            result = defaultValue;
        }
        return result;
    }
    transform(input, predicate, defaultValue) {
        if (!isArray(input)) {
            return input;
        }
        if (isFunction(predicate)) {
            return FirstOrDefaultPipe_1.find(input, predicate, defaultValue);
        }
        else if (isArray(predicate)) {
            const [key, value] = predicate;
            return FirstOrDefaultPipe_1.find(input, (item) => getProperty(item, key) === value, defaultValue);
        }
        else if (predicate) {
            return FirstOrDefaultPipe_1.find(input, item => item === predicate, defaultValue);
        }
        else {
            return input;
        }
    }
};
FirstOrDefaultPipe = FirstOrDefaultPipe_1 = __decorate([
    Pipe({
        name: 'firstOrDefault',
    })
], FirstOrDefaultPipe);
let NgFirstOrDefaultPipeModule = class NgFirstOrDefaultPipeModule {
};
NgFirstOrDefaultPipeModule = __decorate([
    NgModule({
        declarations: [FirstOrDefaultPipe],
        exports: [FirstOrDefaultPipe],
    })
], NgFirstOrDefaultPipeModule);

let RangePipe = class RangePipe {
    transform(_input, size = 0, start = 1, step = 1) {
        const range = [];
        for (let length = 0; length < size; ++length) {
            range.push(start);
            start += step;
        }
        return range;
    }
};
RangePipe = __decorate([
    Pipe({
        name: 'range',
    })
], RangePipe);
let NgRangePipeModule = class NgRangePipeModule {
};
NgRangePipeModule = __decorate([
    NgModule({
        declarations: [RangePipe],
        exports: [RangePipe],
    })
], NgRangePipeModule);

let PluckPipe = class PluckPipe {
    transform(input, key) {
        if (!isArray(input) || !key) {
            return input;
        }
        return input.map((value) => {
            return getProperty(value, key);
        });
    }
};
PluckPipe = __decorate([
    Pipe({
        name: 'pluck',
    })
], PluckPipe);
let NgPluckPipeModule = class NgPluckPipeModule {
};
NgPluckPipeModule = __decorate([
    NgModule({
        declarations: [PluckPipe],
        exports: [PluckPipe],
    })
], NgPluckPipeModule);

let ReversePipe = class ReversePipe {
    transform(input) {
        if (!isArray(input)) {
            return input;
        }
        return [...input].reverse();
    }
};
ReversePipe = __decorate([
    Pipe({
        name: 'reverse',
    })
], ReversePipe);
let NgReversePipeModule = class NgReversePipeModule {
};
NgReversePipeModule = __decorate([
    NgModule({
        declarations: [ReversePipe],
        exports: [ReversePipe],
    })
], NgReversePipeModule);

var OrderByPipe_1;
let OrderByPipe = OrderByPipe_1 = class OrderByPipe {
    static _orderBy(a, b) {
        if (a instanceof Date && b instanceof Date) {
            return a < b ? -1 : a > b ? 1 : 0;
        }
        const floatA = parseFloat(a);
        const floatB = parseFloat(b);
        if (typeof a === 'string' && typeof b === 'string' && (isNaN(floatA) || isNaN(floatB))) {
            const lowerA = a.toLowerCase();
            const lowerB = b.toLowerCase();
            return lowerA < lowerB ? -1 : lowerA > lowerB ? 1 : 0;
        }
        return floatA < floatB ? -1 : floatA > floatB ? 1 : 0;
    }
    transform(input, config = '+') {
        if (!isArray(input)) {
            return input;
        }
        const configIsArray = isArray(config);
        // If config === 'param' OR ['param']
        if (!configIsArray || (configIsArray && config.length === 1)) {
            const propertyToCheck = configIsArray ? config[0] : config;
            const first = propertyToCheck.substr(0, 1);
            const desc = first === '-'; // First character is '-'
            // Basic array (if only + or - is present)
            if (!propertyToCheck || propertyToCheck === '-' || propertyToCheck === '+') {
                return [...input].sort((a, b) => {
                    const comparator = OrderByPipe_1._orderBy(a, b);
                    return desc ? -comparator : comparator;
                });
            }
            else {
                // If contains + or -, substring the property
                const property = first === '+' || desc ? propertyToCheck.substr(1) : propertyToCheck;
                return [...input].sort((a, b) => {
                    const comparator = OrderByPipe_1._orderBy(a[property], b[property]);
                    return desc ? -comparator : comparator;
                });
            }
        }
        else {
            // Config is an array of property
            return [...input].sort((a, b) => {
                for (let i = 0; i < config.length; ++i) {
                    const first = config[i].substr(0, 1);
                    const desc = first === '-';
                    const property = first === '+' || desc ? config[i].substr(1) : config[i];
                    const comparator = OrderByPipe_1._orderBy(a[property], b[property]);
                    const comparison = desc ? -comparator : comparator;
                    if (comparison !== 0) {
                        return comparison;
                    }
                }
                return 0;
            });
        }
    }
};
OrderByPipe = OrderByPipe_1 = __decorate([
    Pipe({
        name: 'orderBy',
    })
], OrderByPipe);
let NgOrderByPipeModule = class NgOrderByPipeModule {
};
NgOrderByPipeModule = __decorate([
    NgModule({
        declarations: [OrderByPipe],
        exports: [OrderByPipe],
    })
], NgOrderByPipeModule);

let CountPipe = class CountPipe {
    transform(input) {
        return count(input);
    }
};
CountPipe = __decorate([
    Pipe({
        name: 'count',
    })
], CountPipe);
let NgCountPipeModule = class NgCountPipeModule {
};
NgCountPipeModule = __decorate([
    NgModule({
        declarations: [CountPipe],
        exports: [CountPipe],
    })
], NgCountPipeModule);

let SomePipe = class SomePipe {
    transform(input, predicate) {
        if (!isArray(input) || !predicate) {
            return input;
        }
        let result = false;
        let i = -1;
        while (++i < input.length && !result) {
            result = predicate(input[i], i, input);
        }
        return result;
    }
};
SomePipe = __decorate([
    Pipe({
        name: 'some',
    })
], SomePipe);
let NgSomePipeModule = class NgSomePipeModule {
};
NgSomePipeModule = __decorate([
    NgModule({
        declarations: [SomePipe],
        exports: [SomePipe],
    })
], NgSomePipeModule);

let EveryPipe = class EveryPipe {
    transform(input, predicate) {
        return every(input, predicate);
    }
};
EveryPipe = __decorate([
    Pipe({
        name: 'every',
    })
], EveryPipe);
let NgEveryPipeModule = class NgEveryPipeModule {
};
NgEveryPipeModule = __decorate([
    NgModule({
        declarations: [EveryPipe],
        exports: [EveryPipe],
    })
], NgEveryPipeModule);

let ShufflePipe = class ShufflePipe {
    transform(input) {
        return shuffle(input);
    }
};
ShufflePipe = __decorate([
    Pipe({
        name: 'shuffle',
    })
], ShufflePipe);
let NgShufflePipeModule = class NgShufflePipeModule {
};
NgShufflePipeModule = __decorate([
    NgModule({
        declarations: [ShufflePipe],
        exports: [ShufflePipe],
    })
], NgShufflePipeModule);

let TakePipe = class TakePipe {
    transform(input, quantity) {
        if (!isArray(input)) {
            return input;
        }
        return input.slice(0, quantity || 1);
    }
};
TakePipe = __decorate([
    Pipe({
        name: 'take',
    })
], TakePipe);
let NgTakePipeModule = class NgTakePipeModule {
};
NgTakePipeModule = __decorate([
    NgModule({
        declarations: [TakePipe],
        exports: [TakePipe],
    })
], NgTakePipeModule);

let DropPipe = class DropPipe {
    transform(input, quantity) {
        if (!isArray(input)) {
            return input;
        }
        return input.slice(quantity || 1, input.lenth);
    }
};
DropPipe = __decorate([
    Pipe({
        name: 'drop',
    })
], DropPipe);
let NgDropPipeModule = class NgDropPipeModule {
};
NgDropPipeModule = __decorate([
    NgModule({
        declarations: [DropPipe],
        exports: [DropPipe],
    })
], NgDropPipeModule);

let DeepPipe = class DeepPipe {
    transform(value) {
        if (isDeepObject(value)) {
            return value;
        }
        return wrapDeep(value);
    }
};
DeepPipe = __decorate([
    Pipe({
        name: 'deep',
    })
], DeepPipe);
let NgDeepPipeModule = class NgDeepPipeModule {
};
NgDeepPipeModule = __decorate([
    NgModule({
        declarations: [DeepPipe],
        exports: [DeepPipe],
    })
], NgDeepPipeModule);

let ChunkPipe = class ChunkPipe {
    transform(input, size = 1) {
        if (!isArray(input)) {
            return input;
        }
        return [].concat.apply([], input.map((_elem, i) => {
            return i % size ? [] : [input.slice(i, i + size)];
        }));
    }
};
ChunkPipe = __decorate([
    Pipe({
        name: 'chunk',
    })
], ChunkPipe);
let NgChunkPipeModule = class NgChunkPipeModule {
};
NgChunkPipeModule = __decorate([
    NgModule({
        declarations: [ChunkPipe],
        exports: [ChunkPipe],
    })
], NgChunkPipeModule);

let FlattenPipe = class FlattenPipe {
    transform(input) {
        const isDeep = isDeepObject(input);
        if (!isArray(input) && !isDeep) {
            return input;
        }
        if (isDeep) {
            const unwrapped = unwrapDeep(input);
            if (!isArray(unwrapped)) {
                return unwrapped;
            }
            return flatten(unwrapped, 0);
        }
        return [].concat.apply([], input);
    }
};
FlattenPipe = __decorate([
    Pipe({ name: 'flatten' })
], FlattenPipe);
let NgFlattenPipeModule = class NgFlattenPipeModule {
};
NgFlattenPipeModule = __decorate([
    NgModule({
        declarations: [FlattenPipe],
        exports: [FlattenPipe],
    })
], NgFlattenPipeModule);

let IntersectionPipe = class IntersectionPipe {
    transform(a, b) {
        if ((!isArray(a) && !isDeepObject(a)) || !isArray(b)) {
            return [];
        }
        if (isDeepObject(a)) {
            const unwrapped = unwrapDeep(a);
            if (!isArray(unwrapped)) {
                return [];
            }
            return unwrapped.reduce((intersection, value) => intersection.concat(deepIndexOf(b, value) !== -1 && deepIndexOf(intersection, value) === -1 ? value : []), []);
        }
        return a.reduce((intersection, value) => intersection.concat(b.indexOf(value) !== -1 && intersection.indexOf(value) === -1 ? value : []), []);
    }
};
IntersectionPipe = __decorate([
    Pipe({
        name: 'intersection',
    })
], IntersectionPipe);
let NgIntersectionPipeModule = class NgIntersectionPipeModule {
};
NgIntersectionPipeModule = __decorate([
    NgModule({
        declarations: [IntersectionPipe],
        exports: [IntersectionPipe],
    })
], NgIntersectionPipeModule);

let UnionPipe = class UnionPipe {
    transform(a, b) {
        if ((!isArray(a) && !isDeepObject(a)) || !isArray(b)) {
            return [];
        }
        if (isDeepObject(a)) {
            const unwrapped = unwrapDeep(a);
            if (!isArray(unwrapped)) {
                return [];
            }
            return []
                .concat(unwrapped)
                .concat(b)
                .filter((value, index, input) => deepIndexOf(input, value) === index);
        }
        return []
            .concat(a)
            .concat(b)
            .filter((value, index, input) => input.indexOf(value) === index);
    }
};
UnionPipe = __decorate([
    Pipe({
        name: 'union',
    })
], UnionPipe);
let NgUnionPipeModule = class NgUnionPipeModule {
};
NgUnionPipeModule = __decorate([
    NgModule({
        declarations: [UnionPipe],
        exports: [UnionPipe],
    })
], NgUnionPipeModule);

let TakeWhilePipe = class TakeWhilePipe {
    transform(input, predicate) {
        if (!isArray(input) || isNil(predicate)) {
            return input;
        }
        return takeWhile(input, predicate);
    }
};
TakeWhilePipe = __decorate([
    Pipe({
        name: 'takeWhile',
    })
], TakeWhilePipe);
let NgTakeWhilePipeModule = class NgTakeWhilePipeModule {
};
NgTakeWhilePipeModule = __decorate([
    NgModule({
        declarations: [TakeWhilePipe],
        exports: [TakeWhilePipe],
    })
], NgTakeWhilePipeModule);

let TakeUntilPipe = class TakeUntilPipe {
    transform(input, predicate) {
        if (!isArray(input) || isNil(predicate)) {
            return input;
        }
        return takeUntil(input, predicate);
    }
};
TakeUntilPipe = __decorate([
    Pipe({
        name: 'takeUntil',
    })
], TakeUntilPipe);
let NgTakeUntilPipeModule = class NgTakeUntilPipeModule {
};
NgTakeUntilPipeModule = __decorate([
    NgModule({
        declarations: [TakeUntilPipe],
        exports: [TakeUntilPipe],
    })
], NgTakeUntilPipeModule);

let NgArrayPipesModule = class NgArrayPipesModule {
};
NgArrayPipesModule = __decorate([
    NgModule({
        imports: [
            NgChunkPipeModule,
            NgCountPipeModule,
            NgDeepPipeModule,
            NgDropPipeModule,
            NgEmptyPipeModule,
            NgEveryPipeModule,
            NgFirstOrDefaultPipeModule,
            NgFlattenPipeModule,
            NgHeadPipeModule,
            NgInitialPipeModule,
            NgIntersectionPipeModule,
            NgJoinPipeModule,
            NgLastPipeModule,
            NgMapPipeModule,
            NgOrderByPipeModule,
            NgPluckPipeModule,
            NgRangePipeModule,
            NgReversePipeModule,
            NgShufflePipeModule,
            NgSomePipeModule,
            NgTailPipeModule,
            NgTakeUntilPipeModule,
            NgTakeWhilePipeModule,
            NgTakePipeModule,
            NgUnionPipeModule,
            NgUniqPipeModule,
            NgWherePipeModule,
            NgWithoutPipeModule,
        ],
    })
], NgArrayPipesModule);

let IsEqualPipe = class IsEqualPipe {
    transform(first, second) {
        return first == second;
    }
};
IsEqualPipe = __decorate([
    Pipe({
        name: 'equal',
    })
], IsEqualPipe);
let NgIsEqualPipeModule = class NgIsEqualPipeModule {
};
NgIsEqualPipeModule = __decorate([
    NgModule({
        declarations: [IsEqualPipe],
        exports: [IsEqualPipe],
    })
], NgIsEqualPipeModule);

let IsGreaterOrEqualPipe = class IsGreaterOrEqualPipe {
    transform(first, second) {
        return first >= second;
    }
};
IsGreaterOrEqualPipe = __decorate([
    Pipe({
        name: 'greaterOrEqual',
    })
], IsGreaterOrEqualPipe);
let NgIsGreaterOrEqualPipeModule = class NgIsGreaterOrEqualPipeModule {
};
NgIsGreaterOrEqualPipeModule = __decorate([
    NgModule({
        declarations: [IsGreaterOrEqualPipe],
        exports: [IsGreaterOrEqualPipe],
    })
], NgIsGreaterOrEqualPipeModule);

let IsGreaterPipe = class IsGreaterPipe {
    transform(first, second) {
        return first > second;
    }
};
IsGreaterPipe = __decorate([
    Pipe({
        name: 'greater',
    })
], IsGreaterPipe);
let NgIsGreaterPipeModule = class NgIsGreaterPipeModule {
};
NgIsGreaterPipeModule = __decorate([
    NgModule({
        declarations: [IsGreaterPipe],
        exports: [IsGreaterPipe],
    })
], NgIsGreaterPipeModule);

let IsIdenticalPipe = class IsIdenticalPipe {
    transform(first, second) {
        return first === second;
    }
};
IsIdenticalPipe = __decorate([
    Pipe({
        name: 'identical',
    })
], IsIdenticalPipe);
let NgIsIdenticalPipeModule = class NgIsIdenticalPipeModule {
};
NgIsIdenticalPipeModule = __decorate([
    NgModule({
        declarations: [IsIdenticalPipe],
        exports: [IsIdenticalPipe],
    })
], NgIsIdenticalPipeModule);

let IsLessOrEqualPipe = class IsLessOrEqualPipe {
    transform(first, second) {
        return first <= second;
    }
};
IsLessOrEqualPipe = __decorate([
    Pipe({
        name: 'lessOrEqual',
    })
], IsLessOrEqualPipe);
let NgIsLessOrEqualPipeModule = class NgIsLessOrEqualPipeModule {
};
NgIsLessOrEqualPipeModule = __decorate([
    NgModule({
        declarations: [IsLessOrEqualPipe],
        exports: [IsLessOrEqualPipe],
    })
], NgIsLessOrEqualPipeModule);

let IsLessPipe = class IsLessPipe {
    transform(first, second) {
        return first < second;
    }
};
IsLessPipe = __decorate([
    Pipe({
        name: 'less',
    })
], IsLessPipe);
let NgIsLessPipeModule = class NgIsLessPipeModule {
};
NgIsLessPipeModule = __decorate([
    NgModule({
        declarations: [IsLessPipe],
        exports: [IsLessPipe],
    })
], NgIsLessPipeModule);

let IsNotEqualPipe = class IsNotEqualPipe {
    transform(first, second) {
        return first != second;
    }
};
IsNotEqualPipe = __decorate([
    Pipe({
        name: 'notEqual',
    })
], IsNotEqualPipe);
let NgIsNotEqualPipeModule = class NgIsNotEqualPipeModule {
};
NgIsNotEqualPipeModule = __decorate([
    NgModule({
        declarations: [IsNotEqualPipe],
        exports: [IsNotEqualPipe],
    })
], NgIsNotEqualPipeModule);

let IsNotIdenticalPipe = class IsNotIdenticalPipe {
    transform(first, second) {
        return first !== second;
    }
};
IsNotIdenticalPipe = __decorate([
    Pipe({
        name: 'notIdentical',
    })
], IsNotIdenticalPipe);
let NgIsNotIdenticalPipeModule = class NgIsNotIdenticalPipeModule {
};
NgIsNotIdenticalPipeModule = __decorate([
    NgModule({
        declarations: [IsNotIdenticalPipe],
        exports: [IsNotIdenticalPipe],
    })
], NgIsNotIdenticalPipeModule);

let IsNullPipe = class IsNullPipe {
    transform(value) {
        return isNull(value);
    }
};
IsNullPipe = __decorate([
    Pipe({
        name: 'isNull',
    })
], IsNullPipe);
let NgIsNullPipeModule = class NgIsNullPipeModule {
};
NgIsNullPipeModule = __decorate([
    NgModule({
        declarations: [IsNullPipe],
        exports: [IsNullPipe],
    })
], NgIsNullPipeModule);

let IsUndefinedPipe = class IsUndefinedPipe {
    transform(value) {
        return isUndefined(value);
    }
};
IsUndefinedPipe = __decorate([
    Pipe({
        name: 'isUndefined',
    })
], IsUndefinedPipe);
let NgIsUndefinedPipeModule = class NgIsUndefinedPipeModule {
};
NgIsUndefinedPipeModule = __decorate([
    NgModule({
        declarations: [IsUndefinedPipe],
        exports: [IsUndefinedPipe],
    })
], NgIsUndefinedPipeModule);

let IsNilPipe = class IsNilPipe {
    transform(value) {
        return isNil(value);
    }
};
IsNilPipe = __decorate([
    Pipe({
        name: 'isNil',
    })
], IsNilPipe);
let NgIsNilPipeModule = class NgIsNilPipeModule {
};
NgIsNilPipeModule = __decorate([
    NgModule({
        declarations: [IsNilPipe],
        exports: [IsNilPipe],
    })
], NgIsNilPipeModule);

let IsFunctionPipe = class IsFunctionPipe {
    transform(value) {
        return isFunction(value);
    }
};
IsFunctionPipe = __decorate([
    Pipe({
        name: 'isFunction',
    })
], IsFunctionPipe);
let NgIsFunctionPipeModule = class NgIsFunctionPipeModule {
};
NgIsFunctionPipeModule = __decorate([
    NgModule({
        declarations: [IsFunctionPipe],
        exports: [IsFunctionPipe],
    })
], NgIsFunctionPipeModule);

let IsNumberPipe = class IsNumberPipe {
    transform(value) {
        return isNumber(value);
    }
};
IsNumberPipe = __decorate([
    Pipe({
        name: 'isNumber',
    })
], IsNumberPipe);
let NgIsNumberPipeModule = class NgIsNumberPipeModule {
};
NgIsNumberPipeModule = __decorate([
    NgModule({
        declarations: [IsNumberPipe],
        exports: [IsNumberPipe],
    })
], NgIsNumberPipeModule);

let IsStringPipe = class IsStringPipe {
    transform(value) {
        return isString(value);
    }
};
IsStringPipe = __decorate([
    Pipe({
        name: 'isString',
    })
], IsStringPipe);
let NgIsStringPipeModule = class NgIsStringPipeModule {
};
NgIsStringPipeModule = __decorate([
    NgModule({
        declarations: [IsStringPipe],
        exports: [IsStringPipe],
    })
], NgIsStringPipeModule);

let IsArrayPipe = class IsArrayPipe {
    transform(value) {
        return isArray(value);
    }
};
IsArrayPipe = __decorate([
    Pipe({
        name: 'isArray',
    })
], IsArrayPipe);
let NgIsArrayPipeModule = class NgIsArrayPipeModule {
};
NgIsArrayPipeModule = __decorate([
    NgModule({
        declarations: [IsArrayPipe],
        exports: [IsArrayPipe],
    })
], NgIsArrayPipeModule);

let IsObjectPipe = class IsObjectPipe {
    transform(value) {
        return isObject(value);
    }
};
IsObjectPipe = __decorate([
    Pipe({
        name: 'isObject',
    })
], IsObjectPipe);
let NgIsObjectPipeModule = class NgIsObjectPipeModule {
};
NgIsObjectPipeModule = __decorate([
    NgModule({
        declarations: [IsObjectPipe],
        exports: [IsObjectPipe],
    })
], NgIsObjectPipeModule);

let IsDefinedPipe = class IsDefinedPipe {
    transform(value) {
        return !isUndefined(value);
    }
};
IsDefinedPipe = __decorate([
    Pipe({
        name: 'isDefined',
    })
], IsDefinedPipe);
let NgIsDefinedPipeModule = class NgIsDefinedPipeModule {
};
NgIsDefinedPipeModule = __decorate([
    NgModule({
        declarations: [IsDefinedPipe],
        exports: [IsDefinedPipe],
    })
], NgIsDefinedPipeModule);

let NgTypesPipesModule = class NgTypesPipesModule {
};
NgTypesPipesModule = __decorate([
    NgModule({
        imports: [
            NgIsNullPipeModule,
            NgIsUndefinedPipeModule,
            NgIsNilPipeModule,
            NgIsFunctionPipeModule,
            NgIsNumberPipeModule,
            NgIsStringPipeModule,
            NgIsArrayPipeModule,
            NgIsObjectPipeModule,
            NgIsDefinedPipeModule,
        ],
    })
], NgTypesPipesModule);
let NgConditionsPipesModule = class NgConditionsPipesModule {
};
NgConditionsPipesModule = __decorate([
    NgModule({
        imports: [
            NgIsEqualPipeModule,
            NgIsGreaterOrEqualPipeModule,
            NgIsGreaterPipeModule,
            NgIsIdenticalPipeModule,
            NgIsLessOrEqualPipeModule,
            NgIsLessPipeModule,
            NgIsNotEqualPipeModule,
            NgIsNotIdenticalPipeModule,
        ],
    })
], NgConditionsPipesModule);
let NgBooleanPipesModule = class NgBooleanPipesModule {
};
NgBooleanPipesModule = __decorate([
    NgModule({
        imports: [NgConditionsPipesModule, NgTypesPipesModule],
    })
], NgBooleanPipesModule);

var BytesPipe_1;
let BytesPipe = BytesPipe_1 = class BytesPipe {
    transform(input, decimal = 0, from = 'B', to) {
        if (!(isNumberFinite(input) && isNumberFinite(decimal) && isInteger(decimal) && isPositive(decimal))) {
            return input;
        }
        let bytes = input;
        let unit = from;
        while (unit !== 'B') {
            bytes *= 1024;
            unit = BytesPipe_1.formats[unit].prev;
        }
        if (to) {
            const format = BytesPipe_1.formats[to];
            const result = toDecimal(BytesPipe_1.calculateResult(format, bytes), decimal);
            return BytesPipe_1.formatResult(result, to);
        }
        for (const key in BytesPipe_1.formats) {
            if (BytesPipe_1.formats.hasOwnProperty(key)) {
                const format = BytesPipe_1.formats[key];
                if (bytes < format.max) {
                    const result = toDecimal(BytesPipe_1.calculateResult(format, bytes), decimal);
                    return BytesPipe_1.formatResult(result, key);
                }
            }
        }
    }
    static formatResult(result, unit) {
        return `${result} ${unit}`;
    }
    static calculateResult(format, bytes) {
        const prev = format.prev ? BytesPipe_1.formats[format.prev] : undefined;
        return prev ? bytes / prev.max : bytes;
    }
};
BytesPipe.formats = {
    B: { max: 1024 },
    kB: { max: Math.pow(1024, 2), prev: 'B' },
    KB: { max: Math.pow(1024, 2), prev: 'B' },
    MB: { max: Math.pow(1024, 3), prev: 'kB' },
    GB: { max: Math.pow(1024, 4), prev: 'MB' },
    TB: { max: Number.MAX_SAFE_INTEGER, prev: 'GB' },
};
BytesPipe = BytesPipe_1 = __decorate([
    Pipe({
        name: 'bytes',
    })
], BytesPipe);
let NgBytesPipeModule = class NgBytesPipeModule {
};
NgBytesPipeModule = __decorate([
    NgModule({
        declarations: [BytesPipe],
        exports: [BytesPipe],
    })
], NgBytesPipeModule);

let CeilPipe = class CeilPipe {
    transform(value, precision = 0) {
        if (isString(precision)) {
            precision = parseInt(precision);
        }
        return createRound('ceil')(value, precision);
    }
};
CeilPipe = __decorate([
    Pipe({
        name: 'ceil',
    })
], CeilPipe);
let NgCeilPipeModule = class NgCeilPipeModule {
};
NgCeilPipeModule = __decorate([
    NgModule({
        declarations: [CeilPipe],
        exports: [CeilPipe],
    })
], NgCeilPipeModule);

let FloorPipe = class FloorPipe {
    transform(value, precision = 0) {
        if (isString(precision)) {
            precision = parseInt(precision);
        }
        return createRound('floor')(value, precision);
    }
};
FloorPipe = __decorate([
    Pipe({
        name: 'floor',
    })
], FloorPipe);
let NgFloorPipeModule = class NgFloorPipeModule {
};
NgFloorPipeModule = __decorate([
    NgModule({
        declarations: [FloorPipe],
        exports: [FloorPipe],
    })
], NgFloorPipeModule);

let RoundPipe = class RoundPipe {
    transform(value, precision = 0) {
        if (isString(precision)) {
            precision = parseInt(precision);
        }
        return createRound('round')(value, precision);
    }
};
RoundPipe = __decorate([
    Pipe({
        name: 'round',
    })
], RoundPipe);
let NgRoundPipeModule = class NgRoundPipeModule {
};
NgRoundPipeModule = __decorate([
    NgModule({
        declarations: [RoundPipe],
        exports: [RoundPipe],
    })
], NgRoundPipeModule);

let DegreesPipe = class DegreesPipe {
    transform(input) {
        if (!isNumberFinite(input)) {
            return 'NaN';
        }
        return (input * 180) / Math.PI;
    }
};
DegreesPipe = __decorate([
    Pipe({
        name: 'degrees',
    })
], DegreesPipe);
let NgDegreesPipeModule = class NgDegreesPipeModule {
};
NgDegreesPipeModule = __decorate([
    NgModule({
        declarations: [DegreesPipe],
        exports: [DegreesPipe],
    })
], NgDegreesPipeModule);

let RadiansPipe = class RadiansPipe {
    transform(input) {
        if (!isNumberFinite(input)) {
            return 'NaN';
        }
        return (input * Math.PI) / 180;
    }
};
RadiansPipe = __decorate([
    Pipe({
        name: 'radians',
    })
], RadiansPipe);
let NgRadiansPipeModule = class NgRadiansPipeModule {
};
NgRadiansPipeModule = __decorate([
    NgModule({
        declarations: [RadiansPipe],
        exports: [RadiansPipe],
    })
], NgRadiansPipeModule);

let RandomPipe = class RandomPipe {
    transform(input, min = 0, max = 1) {
        if (!isNumberFinite(min) || !isNumberFinite(max)) {
            return input;
        }
        if (min > max) {
            max = min;
            min = 0;
        }
        return Math.random() * (max - min) + min;
    }
};
RandomPipe = __decorate([
    Pipe({
        name: 'random',
    })
], RandomPipe);
let NgRandomPipeModule = class NgRandomPipeModule {
};
NgRandomPipeModule = __decorate([
    NgModule({
        declarations: [RandomPipe],
        exports: [RandomPipe],
    })
], NgRandomPipeModule);

let SqrtPipe = class SqrtPipe {
    transform(input) {
        if (!isNumberFinite(input)) {
            return 'NaN';
        }
        return Math.sqrt(input);
    }
};
SqrtPipe = __decorate([
    Pipe({
        name: 'sqrt',
    })
], SqrtPipe);
let NgSqrtPipeModule = class NgSqrtPipeModule {
};
NgSqrtPipeModule = __decorate([
    NgModule({
        declarations: [SqrtPipe],
        exports: [SqrtPipe],
    })
], NgSqrtPipeModule);

let PowPipe = class PowPipe {
    transform(input, power = 2) {
        if (!isNumberFinite(input)) {
            return 'NaN';
        }
        return Math.pow(input, power);
    }
};
PowPipe = __decorate([
    Pipe({
        name: 'pow',
    })
], PowPipe);
let NgPowPipeModule = class NgPowPipeModule {
};
NgPowPipeModule = __decorate([
    NgModule({
        declarations: [PowPipe],
        exports: [PowPipe],
    })
], NgPowPipeModule);

let AbsPipe = class AbsPipe {
    transform(input) {
        if (!isNumberFinite(input)) {
            return 'NaN';
        }
        return Math.abs(input);
    }
};
AbsPipe = __decorate([
    Pipe({
        name: 'abs',
    })
], AbsPipe);
let NgAbsPipeModule = class NgAbsPipeModule {
};
NgAbsPipeModule = __decorate([
    NgModule({
        declarations: [AbsPipe],
        exports: [AbsPipe],
    })
], NgAbsPipeModule);

let OrdinalPipe = class OrdinalPipe {
    transform(input) {
        if (!isNumberFinite(input)) {
            return 'NaN';
        }
        if (this.endsWithTenth(input)) {
            return input + 'th';
        }
        else {
            const cardinal = input.toString().charAt(input.toString().length - 1);
            switch (cardinal) {
                case '1':
                    return input + 'st';
                case '2':
                    return input + 'nd';
                case '3':
                    return input + 'rd';
                default:
                    return input + 'th';
            }
        }
    }
    endsWithTenth(input) {
        const beforeLastDigit = input.toString().charAt(input.toString().length - 2);
        return beforeLastDigit === '1';
    }
};
OrdinalPipe = __decorate([
    Pipe({
        name: 'ordinal',
    })
], OrdinalPipe);
let NgOrdinalPipeModule = class NgOrdinalPipeModule {
};
NgOrdinalPipeModule = __decorate([
    NgModule({
        declarations: [OrdinalPipe],
        exports: [OrdinalPipe],
    })
], NgOrdinalPipeModule);

let NgMathPipesModule = class NgMathPipesModule {
};
NgMathPipesModule = __decorate([
    NgModule({
        imports: [
            NgAbsPipeModule,
            NgBytesPipeModule,
            NgCeilPipeModule,
            NgDegreesPipeModule,
            NgFloorPipeModule,
            NgOrdinalPipeModule,
            NgPowPipeModule,
            NgRadiansPipeModule,
            NgRandomPipeModule,
            NgRoundPipeModule,
            NgSqrtPipeModule,
        ],
    })
], NgMathPipesModule);

let KeysPipe = class KeysPipe {
    transform(input) {
        if (!isObject(input)) {
            return input;
        }
        return Object.keys(input);
    }
};
KeysPipe = __decorate([
    Pipe({ name: 'keys' })
], KeysPipe);
let NgKeysPipeModule = class NgKeysPipeModule {
};
NgKeysPipeModule = __decorate([
    NgModule({
        declarations: [KeysPipe],
        exports: [KeysPipe],
    })
], NgKeysPipeModule);

let ToArrayPipe = class ToArrayPipe {
    transform(input) {
        if (!isObject(input)) {
            return input;
        }
        return Object.keys(input).map(value => input[value]);
    }
};
ToArrayPipe = __decorate([
    Pipe({ name: 'toArray' })
], ToArrayPipe);
let NgToArrayPipeModule = class NgToArrayPipeModule {
};
NgToArrayPipeModule = __decorate([
    NgModule({
        declarations: [ToArrayPipe],
        exports: [ToArrayPipe],
    })
], NgToArrayPipeModule);

let DefaultsPipe = class DefaultsPipe {
    transform(input, defaults) {
        if (!isObject(defaults)) {
            return input;
        }
        if (isNil(input)) {
            return defaults;
        }
        if (isArray(input)) {
            return input.map((item) => {
                if (isObject(item)) {
                    return Object.assign({}, defaults, item);
                }
                if (isNil(item)) {
                    return defaults;
                }
                return item;
            });
        }
        if (isObject(input)) {
            return Object.assign({}, defaults, input);
        }
        return input;
    }
};
DefaultsPipe = __decorate([
    Pipe({ name: 'defaults' })
], DefaultsPipe);
let NgDefaultsPipeModule = class NgDefaultsPipeModule {
};
NgDefaultsPipeModule = __decorate([
    NgModule({
        declarations: [DefaultsPipe],
        exports: [DefaultsPipe],
    })
], NgDefaultsPipeModule);

let NgObjectPipesModule = class NgObjectPipesModule {
};
NgObjectPipesModule = __decorate([
    NgModule({
        imports: [NgKeysPipeModule, NgToArrayPipeModule, NgDefaultsPipeModule],
    })
], NgObjectPipesModule);

let LeftPadPipe = class LeftPadPipe {
    transform(input, length = 0, character = ' ') {
        if (!isString(input)) {
            return input;
        }
        return leftPad(input, length, character);
    }
};
LeftPadPipe = __decorate([
    Pipe({
        name: 'leftpad',
    })
], LeftPadPipe);
let NgLeftPadPipeModule = class NgLeftPadPipeModule {
};
NgLeftPadPipeModule = __decorate([
    NgModule({