UNPKG

ngx-pipes/fesm2015/ngx-pipes.js

Version:
64.1 kBJavaScriptView Raw
1import { __decorate } from 'tslib';
2import { Pipe, NgModule } from '@angular/core';
3
4let DiffPipe = class DiffPipe {
  transform(input, ...args) {
      if (!Array.isArray(input)) {
          return input;
      }
      // tslint:disable-next-line no-bitwise
      return args.reduce((d, c) => d.filter((e) => !~c.indexOf(e)), input);
  }
12};
13DiffPipe = __decorate([
  Pipe({ name: 'diff' })
15], DiffPipe);
16
17let InitialPipe = class InitialPipe {
  transform(input, num = 0) {
      return Array.isArray(input) ? input.slice(0, input.length - num) : input;
  }
21};
22InitialPipe = __decorate([
  Pipe({ name: 'initial' })
24], InitialPipe);
25
26let FlattenPipe = class FlattenPipe {
  transform(input, shallow = false) {
      if (!Array.isArray(input)) {
          return input;
      }
      return shallow ? [].concat.apply([], input) : this.flatten(input);
  }
  flatten(array) {
      return array.reduce((arr, elm) => {
          if (Array.isArray(elm)) {
              return arr.concat(this.flatten(elm));
          }
          return arr.concat(elm);
      }, []);
  }
41};
42FlattenPipe = __decorate([
  Pipe({ name: 'flatten' })
44], FlattenPipe);
45
46let IntersectionPipe = class IntersectionPipe {
  transform(input, ...args) {
      if (!Array.isArray(input)) {
          return input;
      }
      // tslint:disable-next-line no-bitwise
      return args.reduce((n, c) => n.filter((e) => !!~c.indexOf(e)), input);
  }
54};
55IntersectionPipe = __decorate([
  Pipe({ name: 'intersection' })
57], IntersectionPipe);
58
59function isUndefined(value) {
  return typeof value === 'undefined';
61}
62function isFunction(value) {
  return typeof value === 'function';
64}
65function isNumber(value) {
  return typeof value === 'number';
67}
68function isString(value) {
  return typeof value === 'string';
70}
71function isBoolean(value) {
  return typeof value === 'boolean';
73}
74function isObject(value) {
  return value !== null && typeof value === 'object';
76}
77function isNumberFinite(value) {
  return isNumber(value) && isFinite(value);
79}
80function isVowel(letter) {
  const vowels = ['a', 'e', 'i', 'o', 'u'];
  return vowels.indexOf(letter) !== -1;
83}
84function ucFirst(text) {
  const [part, ...split] = text.split(/\s/g);
  const ucd = part
      .toLowerCase()
      .split(/(?=['|-])/g)
      .map((word) => word.indexOf('-') + word.indexOf("'") > -2
      ? word.slice(0, 2).toUpperCase() + word.slice(2)
      : word.slice(0, 1).toUpperCase() + word.slice(1))
      .join('');
  return [ucd, ...split].join(' ');
94}
95function applyPrecision(num, precision) {
  if (precision <= 0) {
      return Math.round(num);
  }
  const tho = Math.pow(10, precision);
  return Math.round(num * tho) / tho;
101}
102function extractDeepPropertyByMapKey(obj, map) {
  const keys = map.split('.');
  const head = keys.shift();
  return keys.reduce((prop, key) => {
      return !isUndefined(prop) && !isUndefined(prop[key]) ? prop[key] : undefined;
  }, obj[head || '']);
108}
109function extractDeepPropertyByParentMapKey(obj, map) {
  const keys = map.split('.');
  const tail = keys.pop();
  const props = extractDeepPropertyByMapKey(obj, keys.join('.'));
  return { props, tail };
114}
115function getKeysTwoObjects(obj, other) {
  return [...Object.keys(obj), ...Object.keys(other)].filter((key, index, array) => array.indexOf(key) === index);
117}
118function isDeepEqual(obj, other) {
  if (!isObject(obj) || !isObject(other)) {
      return obj === other;
  }
  return getKeysTwoObjects(obj, other).every((key) => {
      if (!isObject(obj[key]) && !isObject(other[key])) {
          return obj[key] === other[key];
      }
      if (!isObject(obj[key]) || !isObject(other[key])) {
          return false;
      }
      return isDeepEqual(obj[key], other[key]);
  });
131}
132
133let ReversePipe = class ReversePipe {
  transform(input) {
      if (isString(input)) {
          return input
              .split('')
              .reverse()
              .join('');
      }
      return Array.isArray(input) ? input.slice().reverse() : input;
  }
143};
144ReversePipe = __decorate([
  Pipe({ name: 'reverse' })
146], ReversePipe);
147
148let TailPipe = class TailPipe {
  transform(input, num = 0) {
      return Array.isArray(input) ? input.slice(num) : input;
  }
152};
153TailPipe = __decorate([
  Pipe({ name: 'tail' })
155], TailPipe);
156
157let TrurthifyPipe = class TrurthifyPipe {
  transform(input) {
      return Array.isArray(input) ? input.filter(e => !!e) : input;
  }
161};
162TrurthifyPipe = __decorate([
  Pipe({ name: 'truthify' })
164], TrurthifyPipe);
165
166let UnionPipe = class UnionPipe {
  transform(input, args = []) {
      if (!Array.isArray(input) || !Array.isArray(args)) {
          return input;
      }
      return args.reduce((newArr, currArr) => {
          return newArr.concat(currArr.reduce((noDupArr, curr) => {
              // tslint:disable-next-line:no-bitwise
              return !~noDupArr.indexOf(curr) && !~newArr.indexOf(curr) ? noDupArr.concat([curr]) : noDupArr;
          }, []));
      }, input);
  }
178};
179UnionPipe = __decorate([
  Pipe({ name: 'union' })
181], UnionPipe);
182
183let UniquePipe = class UniquePipe {
  transform(input, propertyName) {
      const uniques = [];
      return Array.isArray(input)
          ? isUndefined(propertyName)
              ? input.filter((e, i) => input.indexOf(e) === i)
              : input.filter((e, i) => {
                  let value = extractDeepPropertyByMapKey(e, propertyName);
                  value = isObject(value) ? JSON.stringify(value) : value;
                  if (isUndefined(value) || uniques[value]) {
                      return false;
                  }
                  uniques[value] = true;
                  return true;
              })
          : input;
  }
200};
201UniquePipe = __decorate([
  Pipe({ name: 'unique' })
203], UniquePipe);
204
205let WithoutPipe = class WithoutPipe {
  transform(input, args = []) {
      return Array.isArray(input)
          ? // tslint:disable-next-line:no-bitwise
              input.filter(e => !~args.indexOf(e))
          : input;
  }
212};
213WithoutPipe = __decorate([
  Pipe({ name: 'without' })
215], WithoutPipe);
216
217let PluckPipe = class PluckPipe {
  transform(input, map) {
      if (Array.isArray(input)) {
          return input.map(e => extractDeepPropertyByMapKey(e, map));
      }
      return isObject(input) ? extractDeepPropertyByMapKey(input, map) : input;
  }
224};
225PluckPipe = __decorate([
  Pipe({ name: 'pluck', pure: false })
227], PluckPipe);
228
229let ShufflePipe = class ShufflePipe {
  // Using a version of the Fisher-Yates shuffle algorithm
  // https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle
  transform(input) {
      if (!Array.isArray(input)) {
          return input;
      }
      const shuffled = [...input];
      const n = input.length - 1;
      for (let i = 0; i < n; ++i) {
          const j = Math.floor(Math.random() * (n - i + 1)) + i;
          [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
      }
      return shuffled;
  }
244};
245ShufflePipe = __decorate([
  Pipe({ name: 'shuffle' })
247], ShufflePipe);
248
249let EveryPipe = class EveryPipe {
  transform(input, predicate) {
      return Array.isArray(input) ? input.every(predicate) : false;
  }
253};
254EveryPipe = __decorate([
  Pipe({ name: 'every' })
256], EveryPipe);
257
258let SomePipe = class SomePipe {
  transform(input, predicate) {
      return Array.isArray(input) ? input.some(predicate) : input;
  }
262};
263SomePipe = __decorate([
  Pipe({ name: 'some' })
265], SomePipe);
266
267let SamplePipe = class SamplePipe {
  transform(input, len = 1) {
      if (!Array.isArray(input)) {
          return input;
      }
      let sample = [];
      const tmp = [...input];
      const l = len < tmp.length ? len : tmp.length;
      for (let i = 0; i < l; ++i) {
          sample = sample.concat(tmp.splice(Math.floor(Math.random() * tmp.length), 1));
      }
      return sample;
  }
280};
281SamplePipe = __decorate([
  Pipe({ name: 'sample' })
283], SamplePipe);
284
285let GroupByPipe = class GroupByPipe {
  transform(input, discriminator = [], delimiter = '|') {
      if (!Array.isArray(input)) {
          return input;
      }
      return this.groupBy(input, discriminator, delimiter);
  }
  groupBy(list, discriminator, delimiter) {
      return list.reduce((acc, payload) => {
          const key = this.extractKeyByDiscriminator(discriminator, payload, delimiter);
          acc[key] = Array.isArray(acc[key]) ? acc[key].concat([payload]) : [payload];
          return acc;
      }, {});
  }
  extractKeyByDiscriminator(discriminator, payload, delimiter) {
      if (isFunction(discriminator)) {
          return discriminator(payload);
      }
      if (Array.isArray(discriminator)) {
          return discriminator.map(k => extractDeepPropertyByMapKey(payload, k)).join(delimiter);
      }
      return extractDeepPropertyByMapKey(payload, discriminator);
  }
308};
309GroupByPipe = __decorate([
  Pipe({ name: 'groupBy' })
311], GroupByPipe);
312
313// tslint:disable no-bitwise
314let FilterByPipe = class FilterByPipe {
  transform(input, props, search = '', strict = false) {
      if (!Array.isArray(input) ||
          (!Array.isArray(search) && !isString(search) && !isNumberFinite(search) && !isBoolean(search))) {
          return input;
      }
      const terms = String(search)
          .toLowerCase()
          .split(',');
      return input.filter(obj => {
          return props.some(prop => {
              return terms.some(term => {
                  const value = extractDeepPropertyByMapKey(obj, prop);
                  /* tslint:disable */
                  const { props, tail } = extractDeepPropertyByParentMapKey(obj, prop);
                  if (isUndefined(value) && !isUndefined(props) && Array.isArray(props)) {
                      return props.some(parent => {
                          const str = String(parent[tail]).toLowerCase();
                          return strict ? str === term : !!~str.indexOf(term);
                      });
                  }
                  if (isUndefined(value)) {
                      return false;
                  }
                  const strValue = String(value).toLowerCase();
                  return strict ? term === strValue : !!~strValue.indexOf(term);
              });
          });
      });
  }
344};
345FilterByPipe = __decorate([
  Pipe({ name: 'filterBy' })
347], FilterByPipe);
348
349var OrderByPipe_1;
350let OrderByPipe = OrderByPipe_1 = class OrderByPipe {
  transform(input, config) {
      if (!Array.isArray(input)) {
          return input;
      }
      const out = [...input];
      // sort by multiple properties
      if (Array.isArray(config)) {
          return out.sort((a, b) => {
              const l = config.length;
              for (let i = 0; i < l; ++i) {
                  const [prop, asc] = OrderByPipe_1.extractFromConfig(config[i]);
                  const pos = OrderByPipe_1.orderCompare(prop, asc, a, b);
                  if (pos !== 0) {
                      return pos;
                  }
              }
              return 0;
          });
      }
      // sort by a single property value
      if (isString(config)) {
          const [prop, asc, sign] = OrderByPipe_1.extractFromConfig(config);
          if (config.length === 1) {
              // tslint:disable-next-line:switch-default
              switch (sign) {
                  case '+':
                      return out.sort(OrderByPipe_1.simpleSort.bind(this));
                  case '-':
                      return out.sort(OrderByPipe_1.simpleSort.bind(this)).reverse();
              }
          }
          return out.sort(OrderByPipe_1.orderCompare.bind(this, prop, asc));
      }
      // default sort by value
      return out.sort(OrderByPipe_1.simpleSort.bind(this));
  }
  static simpleSort(a, b) {
      return isString(a) && isString(b) ? a.toLowerCase().localeCompare(b.toLowerCase()) : a - b;
  }
  static orderCompare(prop, asc, a, b) {
      const first = extractDeepPropertyByMapKey(a, prop);
      const second = extractDeepPropertyByMapKey(b, prop);
      if (first === second) {
          return 0;
      }
      if (isUndefined(first) || first === '') {
          return 1;
      }
      if (isUndefined(second) || second === '') {
          return -1;
      }
      if (isString(first) && isString(second)) {
          const pos = first.toLowerCase().localeCompare(second.toLowerCase());
          return asc ? pos : -pos;
      }
      return asc ? first - second : second - first;
  }
  static extractFromConfig(config) {
      const sign = config.substr(0, 1);
      const prop = config.replace(/^[-+]/, '');
      const asc = sign !== '-';
      return [prop, asc, sign];
  }
414};
415OrderByPipe = OrderByPipe_1 = __decorate([
  Pipe({ name: 'orderBy' })
417], OrderByPipe);
418
419// tslint:disable use-pipe-transform-interface
420let GroupByImpurePipe = class GroupByImpurePipe extends GroupByPipe {
421};
422GroupByImpurePipe = __decorate([
  Pipe({ name: 'groupByImpure', pure: false })
424], GroupByImpurePipe);
425
426// tslint:disable use-pipe-transform-interface
427let FilterByImpurePipe = class FilterByImpurePipe extends FilterByPipe {
428};
429FilterByImpurePipe = __decorate([
  Pipe({ name: 'filterByImpure', pure: false })
431], FilterByImpurePipe);
432
433// tslint:disable use-pipe-transform-interface
434let OrderByImpurePipe = class OrderByImpurePipe extends OrderByPipe {
435};
436OrderByImpurePipe = __decorate([
  Pipe({ name: 'orderByImpure', pure: false })
438], OrderByImpurePipe);
439
440let RangePipe = class RangePipe {
  transform(start = 1, count = 0, step = 1) {
      return Array(count)
          .fill('')
          .map((v, i) => step * i + start);
  }
446};
447RangePipe = __decorate([
  Pipe({ name: 'range' })
449], RangePipe);
450
451let ChunkPipe = class ChunkPipe {
  transform(input, size = 1) {
      if (isString(input)) {
          return this.chunk(input
              .split(''), size);
      }
      return Array.isArray(input) ? this.chunk(input, size) : input;
  }
  chunk(input, size) {
      return Array(Math.ceil(input.length / size))
          .fill([])
          .map((_, index) => index * size)
          .map(begin => input.slice(begin, begin + size));
  }
465};
466ChunkPipe = __decorate([
  Pipe({ name: 'chunk' })
468], ChunkPipe);
469
470let FromPairsPipe = class FromPairsPipe {
  transform(input) {
      if (!Array.isArray(input)) {
          return input;
      }
      return input.reduce((obj, arr) => {
          if (!Array.isArray(arr)) {
              return obj;
          }
          const [prop, val] = arr;
          obj[prop] = val;
          return obj;
      }, {});
  }
484};
485FromPairsPipe = __decorate([
  Pipe({ name: 'fromPairs' })
487], FromPairsPipe);
488
489const ARRAY_PIPES = [
  DiffPipe,
  FlattenPipe,
  InitialPipe,
  IntersectionPipe,
  ReversePipe,
  TailPipe,
  TrurthifyPipe,
  UnionPipe,
  UniquePipe,
  WithoutPipe,
  PluckPipe,
  ShufflePipe,
  EveryPipe,
  SomePipe,
  SamplePipe,
  GroupByPipe,
  GroupByImpurePipe,
  FilterByPipe,
  FilterByImpurePipe,
  OrderByPipe,
  OrderByImpurePipe,
  RangePipe,
  ChunkPipe,
  FromPairsPipe
514];
515let NgArrayPipesModule = class NgArrayPipesModule {
516};
517NgArrayPipesModule = __decorate([
  NgModule({
      declarations: ARRAY_PIPES,
      imports: [],
      exports: ARRAY_PIPES,
  })
523], NgArrayPipesModule);
524
525let KeysPipe = class KeysPipe {
  transform(obj) {
      if (Array.isArray(obj) || !isObject(obj)) {
          return obj;
      }
      return Object.keys(obj);
  }
532};
533KeysPipe = __decorate([
  Pipe({ name: 'keys' })
535], KeysPipe);
536
537let ValuesPipe = class ValuesPipe {
  transform(obj) {
      if (Array.isArray(obj) || !isObject(obj)) {
          return obj;
      }
      return Object.keys(obj).map(k => obj[k]);
  }
544};
545ValuesPipe = __decorate([
  Pipe({ name: 'values' })
547], ValuesPipe);
548
549let PairsPipe = class PairsPipe {
  transform(obj) {
      if (Array.isArray(obj) || !isObject(obj)) {
          return obj;
      }
      return Object.entries(obj);
  }
556};
557PairsPipe = __decorate([
  Pipe({ name: 'pairs' })
559], PairsPipe);
560
561let PickPipe = class PickPipe {
  transform(obj, ...args) {
      if (Array.isArray(obj) || !isObject(obj)) {
          return obj;
      }
      return args.reduce((o, k) => {
          return Object.assign(o, { [k]: obj[k] });
      }, {});
  }
570};
571PickPipe = __decorate([
  Pipe({ name: 'pick' })
573], PickPipe);
574
575let OmitPipe = class OmitPipe {
  transform(obj, ...args) {
      if (Array.isArray(obj) || !isObject(obj)) {
          return obj;
      }
      return (Object.keys(obj)
          // tslint:disable-next-line:no-bitwise
          .filter(k => !~args.indexOf(k))
          .reduce((o, k) => {
          return Object.assign(o, { [k]: obj[k] });
      }, {}));
  }
587};
588OmitPipe = __decorate([
  Pipe({ name: 'omit' })
590], OmitPipe);
591
592let InvertPipe = class InvertPipe {
  transform(obj) {
      if (Array.isArray(obj) || !isObject(obj)) {
          return obj;
      }
      return Object.keys(obj).reduce((o, k) => {
          return Object.assign(o, { [obj[k]]: k });
      }, {});
  }
601};
602InvertPipe = __decorate([
  Pipe({ name: 'invert' })
604], InvertPipe);
605
606let InvertByPipe = class InvertByPipe {
  transform(obj, cb) {
      if (Array.isArray(obj) || !isObject(obj)) {
          return obj;
      }
      return Object.keys(obj).reduce((o, k) => {
          const key = cb ? cb(obj[k]) : obj[k];
          return Array.isArray(o[key]) ? (o[key].push(k), o) : Object.assign(o, { [key]: [k] });
      }, {});
  }
616};
617InvertByPipe = __decorate([
  Pipe({ name: 'invertBy' })
619], InvertByPipe);
620
621let DiffObjPipe = class DiffObjPipe {
  transform(obj, original = {}) {
      if (Array.isArray(obj) || Array.isArray(original) || !isObject(obj) || !isObject(original)) {
          return {};
      }
      return getKeysTwoObjects(obj, original).reduce((diff, key) => {
          if (!isDeepEqual(original[key], obj[key])) {
              diff[key] = obj[key];
          }
          return diff;
      }, {});
  }
633};
634DiffObjPipe = __decorate([
  Pipe({ name: 'diffObj' })
636], DiffObjPipe);
637
638const OBJECT_PIPES = [KeysPipe, ValuesPipe, PairsPipe, PickPipe, InvertPipe, InvertByPipe, OmitPipe, DiffObjPipe];
639let NgObjectPipesModule = class NgObjectPipesModule {
640};
641NgObjectPipesModule = __decorate([
  NgModule({
      declarations: OBJECT_PIPES,
      imports: [],
      exports: OBJECT_PIPES,
  })
647], NgObjectPipesModule);
648
649let AorAnPipe = 
650/**
* Takes a string and returns the string prepended by 'a' or 'an'.
* Uses both naive and holdout-list approaches.
* @constructor
* @param {string} stringEntity - Entity to prepend 'a' or 'an' to.
*/
656class AorAnPipe {
  constructor() {
      this.irregularMap = {
          herb: 'an',
          honor: 'an',
          honorable: 'an',
          hour: 'an',
          mba: 'an',
          msc: 'an',
          'm.sc.': 'an',
          unicorn: 'a',
      };
  }
  transform(stringEntity) {
      if (!stringEntity || stringEntity === '') {
          return '';
      }
      else {
          const firstWord = stringEntity.trim().split(' ')[0];
          if (this.irregularMap[firstWord.toLocaleLowerCase()]) {
              return `${this.irregularMap[firstWord.toLocaleLowerCase()]} ${stringEntity}`;
          }
          else {
              return isVowel(stringEntity[0]) ? `an ${stringEntity}` : `a ${stringEntity}`;
          }
      }
  }
683};
684AorAnPipe = __decorate([
  Pipe({
      name: 'aOrAn',
  })
  /**
   * Takes a string and returns the string prepended by 'a' or 'an'.
   * Uses both naive and holdout-list approaches.
   * @constructor
   * @param {string} stringEntity - Entity to prepend 'a' or 'an' to.
   */
694], AorAnPipe);
695
696let UcWordsPipe = class UcWordsPipe {
  transform(text) {
      if (isString(text)) {
          return text
              .split(' ')
              .map((sub) => ucFirst(sub))
              .join(' ');
      }
      return text;
  }
706};
707UcWordsPipe = __decorate([
  Pipe({ name: 'ucwords' })
709], UcWordsPipe);
710
711let LeftTrimPipe = class LeftTrimPipe {
  transform(text, chars = '\\s') {
      return isString(text) ? text.replace(new RegExp(`^[${chars}]+`), '') : text;
  }
715};
716LeftTrimPipe = __decorate([
  Pipe({ name: 'ltrim' })
718], LeftTrimPipe);
719
720let RepeatPipe = class RepeatPipe {
  transform(str, n = 1, separator = '') {
      if (n <= 0) {
          throw new RangeError();
      }
      return n === 1 ? str : this.repeat(str, n - 1, separator);
  }
  repeat(str, n, separator) {
      return isString(str) ? (n === 0 ? str : str + separator + this.repeat(str, n - 1, separator)) : str;
  }
730};
731RepeatPipe = __decorate([
  Pipe({ name: 'repeat' })
733], RepeatPipe);
734
735let RightTrimPipe = class RightTrimPipe {
  transform(text, chars = '\\s') {
      return isString(text) ? text.replace(new RegExp(`[${chars}]+$`), '') : text;
  }
739};
740RightTrimPipe = __decorate([
  Pipe({ name: 'rtrim' })
742], RightTrimPipe);
743
744let ScanPipe = class ScanPipe {
  transform(text, args = []) {
      return isString(text)
          ? text.replace(/\{(\d+)}/g, (match, index) => (!isUndefined(args[index]) ? args[index] : match))
          : text;
  }
750};
751ScanPipe = __decorate([
  Pipe({ name: 'scan' })
753], ScanPipe);
754
755let ShortenPipe = class ShortenPipe {
  transform(text, length = 0, suffix = '', wordBreak = true) {
      if (!isString(text)) {
          return text;
      }
      if (text.length > length) {
          if (wordBreak) {
              return text.slice(0, length) + suffix;
          }
          // tslint:disable-next-line:no-bitwise
          if (!!~text.indexOf(' ', length)) {
              return text.slice(0, text.indexOf(' ', length)) + suffix;
          }
      }
      return text;
  }
771};
772ShortenPipe = __decorate([
  Pipe({ name: 'shorten' })
774], ShortenPipe);
775
776let StripTagsPipe = class StripTagsPipe {
  transform(text, ...allowedTags) {
      return allowedTags.length > 0
          ? text.replace(new RegExp(`<(?!\/?(${allowedTags.join('|')})\s*\/?)[^>]+>`, 'g'), '')
          : text.replace(/<(?:.|\s)*?>/g, '');
  }
782};
783StripTagsPipe = __decorate([
  Pipe({ name: 'stripTags' })
785], StripTagsPipe);
786
787let TrimPipe = class TrimPipe {
  transform(text, chars = '\\s') {
      return isString(text) ? text.replace(new RegExp(`^[${chars}]+|[${chars}]+$`, 'g'), '') : text;
  }
791};
792TrimPipe = __decorate([
  Pipe({ name: 'trim' })
794], TrimPipe);
795
796let UcFirstPipe = class UcFirstPipe {
  transform(text) {
      return isString(text) ? ucFirst(text) : text;
  }
800};
801UcFirstPipe = __decorate([
  Pipe({ name: 'ucfirst' })
803], UcFirstPipe);
804
805let SlugifyPipe = class SlugifyPipe {
  transform(str) {
      return isString(str)
          ? str
              .toLowerCase()
              .trim()
              .replace(/[^\w\-]+/g, ' ')
              .replace(/\s+/g, '-')
          : str;
  }
815};
816SlugifyPipe = __decorate([
  Pipe({ name: 'slugify' })
818], SlugifyPipe);
819
820let CamelizePipe = class CamelizePipe {
  transform(text, chars = '\\s') {
      if (!isString(text)) {
          return text;
      }
      return text
          .toLowerCase()
          .split(/[-_\s]/g)
          .filter((v) => !!v)
          .map((word, key) => {
          return !key ? word : word.slice(0, 1).toUpperCase() + word.slice(1);
      })
          .join('');
  }
834};
835CamelizePipe = __decorate([
  Pipe({ name: 'camelize' })
837], CamelizePipe);
838
839let LatinisePipe = class LatinisePipe {
  constructor() {
      // Source: http://semplicewebsites.com/removing-accents-javascript
      // tslint:disable-next-line whitespace max-line-length object-literal-key-quotes
      this.latinMap = {
          Á: 'A',
          Ă: 'A',
          Ắ: 'A',
          Ặ: 'A',
          Ằ: 'A',
          Ẳ: 'A',
          Ẵ: 'A',
          Ǎ: 'A',
          Â: 'A',
          Ấ: 'A',
          Ậ: 'A',
          Ầ: 'A',
          Ẩ: 'A',
          Ẫ: 'A',
          Ä: 'A',
          Ǟ: 'A',
          Ȧ: 'A',
          Ǡ: 'A',
          Ạ: 'A',
          Ȁ: 'A',
          À: 'A',
          Ả: 'A',
          Ȃ: 'A',
          Ā: 'A',
          Ą: 'A',
          Å: 'A',
          Ǻ: 'A',
          Ḁ: 'A',
          Ⱥ: 'A',
          Ã: 'A',
          Ꜳ: 'AA',
          Æ: 'AE',
          Ǽ: 'AE',
          Ǣ: 'AE',
          Ꜵ: 'AO',
          Ꜷ: 'AU',
          Ꜹ: 'AV',
          Ꜻ: 'AV',
          Ꜽ: 'AY',
          Ḃ: 'B',
          Ḅ: 'B',
          Ɓ: 'B',
          Ḇ: 'B',
          Ƀ: 'B',
          Ƃ: 'B',
          Ć: 'C',
          Č: 'C',
          Ç: 'C',
          Ḉ: 'C',
          Ĉ: 'C',
          Ċ: 'C',
          Ƈ: 'C',
          Ȼ: 'C',
          Ď: 'D',
          Ḑ: 'D',
          Ḓ: 'D',
          Ḋ: 'D',
          Ḍ: 'D',
          Ɗ: 'D',
          Ḏ: 'D',
          ǲ: 'D',
          ǅ: 'D',
          Đ: 'D',
          Ƌ: 'D',
          Ǳ: 'DZ',
          Ǆ: 'DZ',
          É: 'E',
          Ĕ: 'E',
          Ě: 'E',
          Ȩ: 'E',
          Ḝ: 'E',
          Ê: 'E',
          Ế: 'E',
          Ệ: 'E',
          Ề: 'E',
          Ể: 'E',
          Ễ: 'E',
          Ḙ: 'E',
          Ë: 'E',
          Ė: 'E',
          Ẹ: 'E',
          Ȅ: 'E',
          È: 'E',
          Ẻ: 'E',
          Ȇ: 'E',
          Ē: 'E',
          Ḗ: 'E',
          Ḕ: 'E',
          Ę: 'E',
          Ɇ: 'E',
          Ẽ: 'E',
          Ḛ: 'E',
          Ꝫ: 'ET',
          Ḟ: 'F',
          Ƒ: 'F',
          Ǵ: 'G',
          Ğ: 'G',
          Ǧ: 'G',
          Ģ: 'G',
          Ĝ: 'G',
          Ġ: 'G',
          Ɠ: 'G',
          Ḡ: 'G',
          Ǥ: 'G',
          Ḫ: 'H',
          Ȟ: 'H',
          Ḩ: 'H',
          Ĥ: 'H',
          Ⱨ: 'H',
          Ḧ: 'H',
          Ḣ: 'H',
          Ḥ: 'H',
          Ħ: 'H',
          Í: 'I',
          Ĭ: 'I',
          Ǐ: 'I',
          Î: 'I',
          Ï: 'I',
          Ḯ: 'I',
          İ: 'I',
          Ị: 'I',
          Ȉ: 'I',
          Ì: 'I',
          Ỉ: 'I',
          Ȋ: 'I',
          Ī: 'I',
          Į: 'I',
          Ɨ: 'I',
          Ĩ: 'I',
          Ḭ: 'I',
          Ꝺ: 'D',
          Ꝼ: 'F',
          Ᵹ: 'G',
          Ꞃ: 'R',
          Ꞅ: 'S',
          Ꞇ: 'T',
          Ꝭ: 'IS',
          Ĵ: 'J',
          Ɉ: 'J',
          Ḱ: 'K',
          Ǩ: 'K',
          Ķ: 'K',
          Ⱪ: 'K',
          Ꝃ: 'K',
          Ḳ: 'K',
          Ƙ: 'K',
          Ḵ: 'K',
          Ꝁ: 'K',
          Ꝅ: 'K',
          Ĺ: 'L',
          Ƚ: 'L',
          Ľ: 'L',
          Ļ: 'L',
          Ḽ: 'L',
          Ḷ: 'L',
          Ḹ: 'L',
          Ⱡ: 'L',
          Ꝉ: 'L',
          Ḻ: 'L',
          Ŀ: 'L',
          Ɫ: 'L',
          ǈ: 'L',
          Ł: 'L',
          Ǉ: 'LJ',
          Ḿ: 'M',
          Ṁ: 'M',
          Ṃ: 'M',
          Ɱ: 'M',
          Ń: 'N',
          Ň: 'N',
          Ņ: 'N',
          Ṋ: 'N',
          Ṅ: 'N',
          Ṇ: 'N',
          Ǹ: 'N',
          Ɲ: 'N',
          Ṉ: 'N',
          Ƞ: 'N',
          ǋ: 'N',
          Ñ: 'N',
          Ǌ: 'NJ',
          Ó: 'O',
          Ŏ: 'O',
          Ǒ: 'O',
          Ô: 'O',
          Ố: 'O',
          Ộ: 'O',
          Ồ: 'O',
          Ổ: 'O',
          Ỗ: 'O',
          Ö: 'O',
          Ȫ: 'O',
          Ȯ: 'O',
          Ȱ: 'O',
          Ọ: 'O',
          Ő: 'O',
          Ȍ: 'O',
          Ò: 'O',
          Ỏ: 'O',
          Ơ: 'O',
          Ớ: 'O',
          Ợ: 'O',
          Ờ: 'O',
          Ở: 'O',
          Ỡ: 'O',
          Ȏ: 'O',
          Ꝋ: 'O',
          Ꝍ: 'O',
          Ō: 'O',
          Ṓ: 'O',
          Ṑ: 'O',
          Ɵ: 'O',
          Ǫ: 'O',
          Ǭ: 'O',
          Ø: 'O',
          Ǿ: 'O',
          Õ: 'O',
          Ṍ: 'O',
          Ṏ: 'O',
          Ȭ: 'O',
          Ƣ: 'OI',
          Ꝏ: 'OO',
          Ɛ: 'E',
          Ɔ: 'O',
          Ȣ: 'OU',
          Ṕ: 'P',
          Ṗ: 'P',
          Ꝓ: 'P',
          Ƥ: 'P',
          Ꝕ: 'P',
          Ᵽ: 'P',
          Ꝑ: 'P',
          Ꝙ: 'Q',
          Ꝗ: 'Q',
          Ŕ: 'R',
          Ř: 'R',
          Ŗ: 'R',
          Ṙ: 'R',
          Ṛ: 'R',
          Ṝ: 'R',
          Ȑ: 'R',
          Ȓ: 'R',
          Ṟ: 'R',
          Ɍ: 'R',
          Ɽ: 'R',
          Ꜿ: 'C',
          Ǝ: 'E',
          Ś: 'S',
          Ṥ: 'S',
          Š: 'S',
          Ṧ: 'S',
          Ş: 'S',
          Ŝ: 'S',
          Ș: 'S',
          Ṡ: 'S',
          Ṣ: 'S',
          Ṩ: 'S',
          ẞ: 'SS',
          Ť: 'T',
          Ţ: 'T',
          Ṱ: 'T',
          Ț: 'T',
          Ⱦ: 'T',
          Ṫ: 'T',
          Ṭ: 'T',
          Ƭ: 'T',
          Ṯ: 'T',
          Ʈ: 'T',
          Ŧ: 'T',
          Ɐ: 'A',
          Ꞁ: 'L',
          Ɯ: 'M',
          Ʌ: 'V',
          Ꜩ: 'TZ',
          Ú: 'U',
          Ŭ: 'U',
          Ǔ: 'U',
          Û: 'U',
          Ṷ: 'U',
          Ü: 'U',
          Ǘ: 'U',
          Ǚ: 'U',
          Ǜ: 'U',
          Ǖ: 'U',
          Ṳ: 'U',
          Ụ: 'U',
          Ű: 'U',
          Ȕ: 'U',
          Ù: 'U',
          Ủ: 'U',
          Ư: 'U',
          Ứ: 'U',
          Ự: 'U',
          Ừ: 'U',
          Ử: 'U',
          Ữ: 'U',
          Ȗ: 'U',
          Ū: 'U',
          Ṻ: 'U',
          Ų: 'U',
          Ů: 'U',
          Ũ: 'U',
          Ṹ: 'U',
          Ṵ: 'U',
          Ꝟ: 'V',
          Ṿ: 'V',
          Ʋ: 'V',
          Ṽ: 'V',
          Ꝡ: 'VY',
          Ẃ: 'W',
          Ŵ: 'W',
          Ẅ: 'W',
          Ẇ: 'W',
          Ẉ: 'W',
          Ẁ: 'W',
          Ⱳ: 'W',
          Ẍ: 'X',
          Ẋ: 'X',
          Ý: 'Y',
          Ŷ: 'Y',
          Ÿ: 'Y',
          Ẏ: 'Y',
          Ỵ: 'Y',
          Ỳ: 'Y',
          Ƴ: 'Y',
          Ỷ: 'Y',
          Ỿ: 'Y',
          Ȳ: 'Y',
          Ɏ: 'Y',
          Ỹ: 'Y',
          Ź: 'Z',
          Ž: 'Z',
          Ẑ: 'Z',
          Ⱬ: 'Z',
          Ż: 'Z',
          Ẓ: 'Z',
          Ȥ: 'Z',
          Ẕ: 'Z',
          Ƶ: 'Z',
          Ĳ: 'IJ',
          Œ: 'OE',
          ᴀ: 'A',
          ᴁ: 'AE',
          ʙ: 'B',
          ᴃ: 'B',
          ᴄ: 'C',
          ᴅ: 'D',
          ᴇ: 'E',
          ꜰ: 'F',
          ɢ: 'G',
          ʛ: 'G',
          ʜ: 'H',
          ɪ: 'I',
          ʁ: 'R',
          ᴊ: 'J',
          ᴋ: 'K',
          ʟ: 'L',
          ᴌ: 'L',
          ᴍ: 'M',
          ɴ: 'N',
          ᴏ: 'O',
          ɶ: 'OE',
          ᴐ: 'O',
          ᴕ: 'OU',
          ᴘ: 'P',
          ʀ: 'R',
          ᴎ: 'N',
          ᴙ: 'R',
          ꜱ: 'S',
          ᴛ: 'T',
          ⱻ: 'E',
          ᴚ: 'R',
          ᴜ: 'U',
          ᴠ: 'V',
          ᴡ: 'W',
          ʏ: 'Y',
          ᴢ: 'Z',
          á: 'a',
          ă: 'a',
          ắ: 'a',
          ặ: 'a',
          ằ: 'a',
          ẳ: 'a',
          ẵ: 'a',
          ǎ: 'a',
          â: 'a',
          ấ: 'a',
          ậ: 'a',
          ầ: 'a',
          ẩ: 'a',
          ẫ: 'a',
          ä: 'a',
          ǟ: 'a',
          ȧ: 'a',
          ǡ: 'a',
          ạ: 'a',
          ȁ: 'a',
          à: 'a',
          ả: 'a',
          ȃ: 'a',
          ā: 'a',
          ą: 'a',
          ᶏ: 'a',
          ẚ: 'a',
          å: 'a',
          ǻ: 'a',
          ḁ: 'a',
          ⱥ: 'a',
          ã: 'a',
          ꜳ: 'aa',
          æ: 'ae',
          ǽ: 'ae',
          ǣ: 'ae',
          ꜵ: 'ao',
          ꜷ: 'au',
          ꜹ: 'av',
          ꜻ: 'av',
          ꜽ: 'ay',
          ḃ: 'b',
          ḅ: 'b',
          ɓ: 'b',
          ḇ: 'b',
          ᵬ: 'b',
          ᶀ: 'b',
          ƀ: 'b',
          ƃ: 'b',
          ɵ: 'o',
          ć: 'c',
          č: 'c',
          ç: 'c',
          ḉ: 'c',
          ĉ: 'c',
          ɕ: 'c',
          ċ: 'c',
          ƈ: 'c',
          ȼ: 'c',
          ď: 'd',
          ḑ: 'd',
          ḓ: 'd',
          ȡ: 'd',
          ḋ: 'd',
          ḍ: 'd',
          ɗ: 'd',
          ᶑ: 'd',
          ḏ: 'd',
          ᵭ: 'd',
          ᶁ: 'd',
          đ: 'd',
          ɖ: 'd',
          ƌ: 'd',
          ı: 'i',
          ȷ: 'j',
          ɟ: 'j',
          ʄ: 'j',
          ǳ: 'dz',
          ǆ: 'dz',
          é: 'e',
          ĕ: 'e',
          ě: 'e',
          ȩ: 'e',
          ḝ: 'e',
          ê: 'e',
          ế: 'e',
          ệ: 'e',
          ề: 'e',
          ể: 'e',
          ễ: 'e',
          ḙ: 'e',
          ë: 'e',
          ė: 'e',
          ẹ: 'e',
          ȅ: 'e',
          è: 'e',
          ẻ: 'e',
          ȇ: 'e',
          ē: 'e',
          ḗ: 'e',
          ḕ: 'e',
          ⱸ: 'e',
          ę: 'e',
          ᶒ: 'e',
          ɇ: 'e',
          ẽ: 'e',
          ḛ: 'e',
          ꝫ: 'et',
          ḟ: 'f',
          ƒ: 'f',
          ᵮ: 'f',
          ᶂ: 'f',
          ǵ: 'g',
          ğ: 'g',
          ǧ: 'g',
          ģ: 'g',
          ĝ: 'g',
          ġ: 'g',
          ɠ: 'g',
          ḡ: 'g',
          ᶃ: 'g',
          ǥ: 'g',
          ḫ: 'h',
          ȟ: 'h',
          ḩ: 'h',
          ĥ: 'h',
          ⱨ: 'h',
          ḧ: 'h',
          ḣ: 'h',
          ḥ: 'h',
          ɦ: 'h',
          ẖ: 'h',
          ħ: 'h',
          ƕ: 'hv',
          í: 'i',
          ĭ: 'i',
          ǐ: 'i',
          î: 'i',
          ï: 'i',
          ḯ: 'i',
          ị: 'i',
          ȉ: 'i',
          ì: 'i',
          ỉ: 'i',
          ȋ: 'i',
          ī: 'i',
          į: 'i',
          ᶖ: 'i',
          ɨ: 'i',
          ĩ: 'i',
          ḭ: 'i',
          ꝺ: 'd',
          ꝼ: 'f',
          ᵹ: 'g',
          ꞃ: 'r',
          ꞅ: 's',
          ꞇ: 't',
          ꝭ: 'is',
          ǰ: 'j',
          ĵ: 'j',
          ʝ: 'j',
          ɉ: 'j',
          ḱ: 'k',
          ǩ: 'k',
          ķ: 'k',
          ⱪ: 'k',
          ꝃ: 'k',
          ḳ: 'k',
          ƙ: 'k',
          ḵ: 'k',
          ᶄ: 'k',
          ꝁ: 'k',
          ꝅ: 'k',
          ĺ: 'l',
          ƚ: 'l',
          ɬ: 'l',
          ľ: 'l',
          ļ: 'l',
          ḽ: 'l',
          ȴ: 'l',
          ḷ: 'l',
          ḹ: 'l',
          ⱡ: 'l',
          ꝉ: 'l',
          ḻ: 'l',
          ŀ: 'l',
          ɫ: 'l',
          ᶅ: 'l',
          ɭ: 'l',
          ł: 'l',
          ǉ: 'lj',
          ſ: 's',
          ẜ: 's',
          ẛ: 's',
          ẝ: 's',
          ḿ: 'm',
          ṁ: 'm',
          ṃ: 'm',
          ɱ: 'm',
          ᵯ: 'm',
          ᶆ: 'm',
          ń: 'n',
          ň: 'n',
          ņ: 'n',
          ṋ: 'n',
          ȵ: 'n',
          ṅ: 'n',
          ṇ: 'n',
          ǹ: 'n',
          ɲ: 'n',
          ṉ: 'n',
          ƞ: 'n',
          ᵰ: 'n',
          ᶇ: 'n',
          ɳ: 'n',
          ñ: 'n',
          ǌ: 'nj',
          ó: 'o',
          ŏ: 'o',
          ǒ: 'o',
          ô: 'o',
          ố: 'o',
          ộ: 'o',
          ồ: 'o',
          ổ: 'o',
          ỗ: 'o',
          ö: 'o',
          ȫ: 'o',
          ȯ: 'o',
          ȱ: 'o',
          ọ: 'o',
          ő: 'o',
          ȍ: 'o',
          ò: 'o',
          ỏ: 'o',
          ơ: 'o',
          ớ: 'o',
          ợ: 'o',
          ờ: 'o',
          ở: 'o',
          ỡ: 'o',
          ȏ: 'o',
          ꝋ: 'o',
          ꝍ: 'o',
          ⱺ: 'o',
          ō: 'o',
          ṓ: 'o',
          ṑ: 'o',
          ǫ: 'o',
          ǭ: 'o',
          ø: 'o',
          ǿ: 'o',
          õ: 'o',
          ṍ: 'o',
          ṏ: 'o',
          ȭ: 'o',
          ƣ: 'oi',
          ꝏ: 'oo',
          ɛ: 'e',
          ᶓ: 'e',
          ɔ: 'o',
          ᶗ: 'o',
          ȣ: 'ou',
          ṕ: 'p',
          ṗ: 'p',
          ꝓ: 'p',
          ƥ: 'p',
          ᵱ: 'p',
          ᶈ: 'p',
          ꝕ: 'p',
          ᵽ: 'p',
          ꝑ: 'p',
          ꝙ: 'q',
          ʠ: 'q',
          ɋ: 'q',
          ꝗ: 'q',
          ŕ: 'r',
          ř: 'r',
          ŗ: 'r',
          ṙ: 'r',
          ṛ: 'r',
          ṝ: 'r',
          ȑ: 'r',
          ɾ: 'r',
          ᵳ: 'r',
          ȓ: 'r',
          ṟ: 'r',
          ɼ: 'r',
          ᵲ: 'r',
          ᶉ: 'r',
          ɍ: 'r',
          ɽ: 'r',
          ↄ: 'c',
          ꜿ: 'c',
          ɘ: 'e',
          ɿ: 'r',
          ś: 's',
          ṥ: 's',
          š: 's',
          ṧ: 's',
          ş: 's',
          ŝ: 's',
          ș: 's',
          ṡ: 's',
          ṣ: 's',
          ṩ: 's',
          ʂ: 's',
          ᵴ: 's',
          ᶊ: 's',
          ȿ: 's',
          ɡ: 'g',
          ß: 'ss',
          ᴑ: 'o',
          ᴓ: 'o',
          ᴝ: 'u',
          ť: 't',
          ţ: 't',
          ṱ: 't',
          ț: 't',
          ȶ: 't',
          ẗ: 't',
          ⱦ: 't',
          ṫ: 't',
          ṭ: 't',
          ƭ: 't',
          ṯ: 't',
          ᵵ: 't',
          ƫ: 't',
          ʈ: 't',
          ŧ: 't',
          ᵺ: 'th',
          ɐ: 'a',
          ᴂ: 'ae',
          ǝ: 'e',
          ᵷ: 'g',
          ɥ: 'h',
          ʮ: 'h',
          ʯ: 'h',
          ᴉ: 'i',
          ʞ: 'k',
          ꞁ: 'l',
          ɯ: 'm',
          ɰ: 'm',
          ᴔ: 'oe',
          ɹ: 'r',
          ɻ: 'r',
          ɺ: 'r',
          ⱹ: 'r',
          ʇ: 't',
          ʌ: 'v',
          ʍ: 'w',
          ʎ: 'y',
          ꜩ: 'tz',
          ú: 'u',
          ŭ: 'u',
          ǔ: 'u',
          û: 'u',
          ṷ: 'u',
          ü: 'u',
          ǘ: 'u',
          ǚ: 'u',
          ǜ: 'u',
          ǖ: 'u',
          ṳ: 'u',
          ụ: 'u',
          ű: 'u',
          ȕ: 'u',
          ù: 'u',
          ủ: 'u',
          ư: 'u',
          ứ: 'u',
          ự: 'u',
          ừ: 'u',
          ử: 'u',
          ữ: 'u',
          ȗ: 'u',
          ū: 'u',
          ṻ: 'u',
          ų: 'u',
          ᶙ: 'u',
          ů: 'u',
          ũ: 'u',
          ṹ: 'u',
          ṵ: 'u',
          ᵫ: 'ue',
          ꝸ: 'um',
          ⱴ: 'v',
          ꝟ: 'v',
          ṿ: 'v',
          ʋ: 'v',
          ᶌ: 'v',
          ⱱ: 'v',
          ṽ: 'v',
          ꝡ: 'vy',
          ẃ: 'w',
          ŵ: 'w',
          ẅ: 'w',
          ẇ: 'w',
          ẉ: 'w',
          ẁ: 'w',
          ⱳ: 'w',
          ẘ: 'w',
          ẍ: 'x',
          ẋ: 'x',
          ᶍ: 'x',
          ý: 'y',
          ŷ: 'y',
          ÿ: 'y',
          ẏ: 'y',
          ỵ: 'y',
          ỳ: 'y',
          ƴ: 'y',
          ỷ: 'y',
          ỿ: 'y',
          ȳ: 'y',
          ẙ: 'y',
          ɏ: 'y',
          ỹ: 'y',
          ź: 'z',
          ž: 'z',
          ẑ: 'z',
          ʑ: 'z',
          ⱬ: 'z',
          ż: 'z',
          ẓ: 'z',
          ȥ: 'z',
          ẕ: 'z',
          ᵶ: 'z',
          ᶎ: 'z',
          ʐ: 'z',
          ƶ: 'z',
          ɀ: 'z',
          ﬀ: 'ff',
          ﬃ: 'ffi',
          ﬄ: 'ffl',
          ﬁ: 'fi',
          ﬂ: 'fl',
          ĳ: 'ij',
          œ: 'oe',
          ﬆ: 'st',
          ₐ: 'a',
          ₑ: 'e',
          ᵢ: 'i',
          ⱼ: 'j',
          ₒ: 'o',
          ᵣ: 'r',
          ᵤ: 'u',
          ᵥ: 'v',
          ₓ: 'x',
      };
  }
  transform(text, chars = '\\s') {
      return isString(text)
          ? text.replace(/[^A-Za-z0-9]/g, (key) => {
              return this.latinMap[key] || key;
          })
          : text;
  }
1679};
1680LatinisePipe = __decorate([
  Pipe({ name: 'latinise' })
1682], LatinisePipe);
1683
1684let LinesPipe = class LinesPipe {
  transform(text, chars = '\\s') {
      return isString(text) ? text.replace(/\r\n/g, '\n').split('\n') : text;
  }
1688};
1689LinesPipe = __decorate([
  Pipe({ name: 'lines' })
1691], LinesPipe);
1692
1693let UnderscorePipe = class UnderscorePipe {
  transform(text, chars = '\\s') {
      return isString(text)
          ? text
              .trim()
              .replace(/\s+/g, '')
              .replace(/[A-Z]/g, (c, k) => {
              return k ? `_${c.toLowerCase()}` : c.toLowerCase();
          })
          : text;
  }
1704};
1705UnderscorePipe = __decorate([
  Pipe({ name: 'underscore' })
1707], UnderscorePipe);
1708
1709let MatchPipe = class MatchPipe {
  transform(text, pattern, flags) {
      if (!isString(text)) {
          return text;
      }
      return text.match(new RegExp(pattern, flags));
  }
1716};
1717MatchPipe = __decorate([
  Pipe({ name: 'match' })
1719], MatchPipe);
1720
1721let TestPipe = class TestPipe {
  transform(text, pattern, flags) {
      if (!isString(text)) {
          return text;
      }
      return new RegExp(pattern, flags).test(text);
  }
1728};
1729TestPipe = __decorate([
  Pipe({ name: 'test' })
1731], TestPipe);
1732
1733let LeftPadPipe = class LeftPadPipe {
  transform(str, length, padCharacter = ' ') {
      if (!isString(str) || str.length >= length) {
          return str;
      }
      while (str.length < length) {
          str = padCharacter + str;
      }
      return str;
  }
1743};
1744LeftPadPipe = __decorate([
  Pipe({ name: 'lpad' })
1746], LeftPadPipe);
1747
1748let RightPadPipe = class RightPadPipe {
  transform(str, length = 1, padCharacter = ' ') {
      if (!isString(str) || str.length >= length) {
          return str;
      }
      while (str.length < length) {
          str = str + padCharacter;
      }
      return str;
  }
1758};
1759RightPadPipe = __decorate([
  Pipe({ name: 'rpad' })
1761], RightPadPipe);
1762
1763let MakePluralStringPipe = 
1764/**
* Takes a singular entity string and pluralizes it.
* Uses both naive and holdout-list approaches.
* If several words appear in the string, only the last word is pluralized -- this
* means that if "your story" was passed in, "your stories" would be passed out.
*
* @param {string} singularEntity - Entity to pluralize. Pass as a singular ('story' or 'house').
*          NOTE: The last word is examined. So you can pass in e.g. 'my story'.
* @param {number} [quantity=0] quantity - How many of the entity are there? If left blank, this will
*          pluralize the string (e.g. 'story' -> 'stories', 'house' -> 'houses'). If given a value,
*          this will pluralize appropriately (e.g. ('story', 1) -> 'story', ('story', 2) -> 'stories').
*/
1776class MakePluralStringPipe {
  constructor() {
      this.irregularMap = {
          addendum: 'addenda',
          alga: 'algae',
          alumna: 'alumnae',
          alumnus: 'alumni',
          analysis: 'analyses',
          antenna: 'antennae',
          appendix: 'appendices',
          aquarium: 'aquaria',
          arch: 'arches',
          axe: 'axes',
          axis: 'axes',
          bacillus: 'bacilli',
          bacterium: 'bacteria',
          basis: 'bases',
          batch: 'batches',
          beach: 'beaches',
          beau: 'beaux',
          bison: 'bison',
          brush: 'brushes',
          buffalo: 'buffaloes',
          bureau: 'bureaus',
          bus: 'busses',
          cactus: 'cacti',
          calf: 'calves',
          chateau: 'chateaux',
          cherry: 'cherries',
          child: 'children',
          church: 'churches',
          circus: 'circuses',
          cod: 'cod',
          corps: 'corps',
          corpus: 'corpora',
          crisis: 'crises',
          criterion: 'criteria',
          curriculum: 'curricula',
          datum: 'data',
          deer: 'deer',
          diagnosis: 'diagnoses',
          die: 'dice',
          domino: 'dominoes',
          dwarf: 'dwarves',
          echo: 'echoes',
          elf: 'elves',
          ellipsis: 'ellipses',
          embargo: 'embargoes',
          emphasis: 'emphases',
          erratum: 'errata',
          fax: 'faxes',
          fireman: 'firemen',
          fish: 'fish',
          flush: 'flushes',
          focus: 'foci',
          foot: 'feet',
          formula: 'formulas',
          fungus: 'fungi',
          genus: 'genera',
          goose: 'geese',
          grafito: 'grafiti',
          half: 'halves',
          hero: 'heroes',
          hoax: 'hoaxes',
          hoof: 'hooves',
          hypothesis: 'hypotheses',
          index: 'indices',
          kiss: 'kisses',
          knife: 'knives',
          leaf: 'leaves',
          life: 'lives',
          loaf: 'loaves',
          louse: 'lice',
          man: 'men',
          mango: 'mangoes',
          matrix: 'matrices',
          means: 'means',
          medium: 'media',
          memorandum: 'memoranda',
          millennium: 'milennia',
          moose: 'moose',
          mosquito: 'mosquitoes',
          motto: 'mottoes',
          mouse: 'mice',
          nebula: 'nebulae',
          neurosis: 'neuroses',
          nucleus: 'nuclei',
          oasis: 'oases',
          octopus: 'octopodes',
          ovum: 'ova',
          ox: 'oxen',
          paralysis: 'paralyses',
          parenthesis: 'parentheses',
          person: 'people',
          phenomenon: 'phenomena',
          plateau: 'plateaux',
          potato: 'potatoes',
          quiz: 'quizzes',
          radius: 'radii',
          reflex: 'reflexes',
          'runner-up': 'runners-up',
          scampo: 'scampi',
          scarf: 'scarves',
          scissors: 'scissors',
          scratch: 'scratches',
          self: 'selves',
          series: 'series',
          sheaf: 'sheaves',
          sheep: 'sheep',
          shelf: 'shelves',
          'son-in-law': 'sons-in-law',
          species: 'species',
          splash: 'splashes',
          stimulus: 'stimuli',
          stitch: 'stitches',
          stratum: 'strata',
          syllabus: 'syllabi',
          symposium: 'symposia',
          synopsis: 'synopses',
          synthesis: 'syntheses',
          tableau: 'tableaux',
          tax: 'taxes',
          that: 'those',
          thesis: 'theses',
          thief: 'thieves',
          this: 'these',
          tomato: 'tomatoes',
          tooth: 'teeth',
          tornado: 'tornadoes',
          torpedo: 'torpedoes',
          vertebra: 'vertebrae',
          veto: 'vetoes',
          vita: 'vitae',
          volcano: 'volcanoes',
          waltz: 'waltzes',
          wash: 'washes',
          watch: 'watches',
          wharf: 'wharves',
          wife: 'wives',
          wolf: 'wolves',
          woman: 'women',
          zero: 'zeroes',
      };
  }
  transform(singularEntity, quantity = 0) {
      if (!singularEntity || singularEntity === '') {
          return '';
      }
      if (quantity === 1) {
          return singularEntity;
      }
      else {
          const lastWord = singularEntity.trim().split(' ')[singularEntity.trim().split(' ').length - 1];
          if (this.irregularMap[lastWord.toLocaleLowerCase()]) {
              if (lastWord[0] === lastWord[0].toLocaleUpperCase()) {
                  return singularEntity.replace(lastWord, this.irregularMap[lastWord.toLocaleLowerCase()].replace(this.irregularMap[lastWord.toLocaleLowerCase()][0], this.irregularMap[lastWord.toLocaleLowerCase()][0].toLocaleUpperCase()));
              }
              return singularEntity.replace(lastWord, this.irregularMap[lastWord.toLocaleLowerCase()]);
          }
          else if (lastWord[lastWord.length - 1] === 'y') {
              // Naive approach:
              // consonant+y = word - 'y' +'ies'
              // vowel+y = word + 's'
              return isVowel(lastWord[lastWord.length - 2])
                  ? singularEntity + 's'
                  : singularEntity.replace(lastWord, lastWord.slice(0, -1) + 'ies');
          }
          else if (lastWord[lastWord.length - 1] === 's') {
              return singularEntity + 'es';
          }
          else {
              return singularEntity + 's';
          }
      }
  }
1951};
1952MakePluralStringPipe = __decorate([
  Pipe({
      name: 'makePluralString',
  })
  /**
   * Takes a singular entity string and pluralizes it.
   * Uses both naive and holdout-list approaches.
   * If several words appear in the string, only the last word is pluralized -- this
   * means that if "your story" was passed in, "your stories" would be passed out.
   *
   * @param {string} singularEntity - Entity to pluralize. Pass as a singular ('story' or 'house').
   *          NOTE: The last word is examined. So you can pass in e.g. 'my story'.
   * @param {number} [quantity=0] quantity - How many of the entity are there? If left blank, this will
   *          pluralize the string (e.g. 'story' -> 'stories', 'house' -> 'houses'). If given a value,
   *          this will pluralize appropriately (e.g. ('story', 1) -> 'story', ('story', 2) -> 'stories').
   */
1968], MakePluralStringPipe);
1969
1970let WrapPipe = class WrapPipe {
  transform(str, prefix = '', suffix = '') {
      if (!isString(str)) {
          return str;
      }
      return (!!prefix && isString(prefix) ? prefix : '') + str + (!!suffix && isString(suffix) ? suffix : '');
  }
1977};
1978WrapPipe = __decorate([
  Pipe({ name: 'wrap' })
1980], WrapPipe);
1981
1982const STRING_PIPES = [
  AorAnPipe,
  LeftTrimPipe,
  RepeatPipe,
  RightTrimPipe,
  ScanPipe,
  ShortenPipe,
  StripTagsPipe,
  TrimPipe,
  UcFirstPipe,
  UcWordsPipe,
  SlugifyPipe,
  CamelizePipe,
  LatinisePipe,
  LinesPipe,
  UnderscorePipe,
  MatchPipe,
  TestPipe,
  LeftPadPipe,
  RightPadPipe,
  MakePluralStringPipe,
  WrapPipe,
2004];
2005let NgStringPipesModule = class NgStringPipesModule {
2006};
2007NgStringPipesModule = __decorate([
  NgModule({
      declarations: STRING_PIPES,
      imports: [],
      exports: STRING_PIPES,
  })
2013], NgStringPipesModule);
2014
2015let MaxPipe = class MaxPipe {
  transform(arr) {
      return Array.isArray(arr) ? Math.max(...arr) : arr;
  }
2019};
2020MaxPipe = __decorate([
  Pipe({ name: 'max' })
2022], MaxPipe);
2023
2024let MinPipe = class MinPipe {
  transform(arr) {
      return Array.isArray(arr) ? Math.min(...arr) : arr;
  }
2028};
2029MinPipe = __decorate([
  Pipe({ name: 'min' })
2031], MinPipe);
2032
2033let PercentagePipe = class PercentagePipe {
  transform(num, total = 100, floor = false) {
      if (isNaN(num)) {
          return num;
      }
      const percent = (num * 100) / total;
      return floor ? Math.floor(percent) : percent;
  }
2041};
2042PercentagePipe = __decorate([
  Pipe({ name: 'percentage' })
2044], PercentagePipe);
2045
2046let SumPipe = class SumPipe {
  transform(arr) {
      return Array.isArray(arr) ? arr.reduce((sum, curr) => sum + curr, 0) : arr;
  }
2050};
2051SumPipe = __decorate([
  Pipe({ name: 'sum' })
2053], SumPipe);
2054
2055let FloorPipe = class FloorPipe {
  transform(num, precision = 0) {
      if (precision <= 0) {
          return Math.floor(num);
      }
      const tho = Math.pow(10, precision);
      return Math.floor(num * tho) / tho;
  }
2063};
2064FloorPipe = __decorate([
  Pipe({ name: 'floor' })
2066], FloorPipe);
2067
2068let RoundPipe = class RoundPipe {
  transform(num, precision = 0) {
      return applyPrecision(num, precision);
  }
2072};
2073RoundPipe = __decorate([
  Pipe({ name: 'round' })
2075], RoundPipe);
2076
2077let SqrtPipe = class SqrtPipe {
  transform(num) {
      return !isNaN(num) ? Math.sqrt(num) : num;
  }
2081};
2082SqrtPipe = __decorate([
  Pipe({ name: 'sqrt' })
2084], SqrtPipe);
2085
2086let PowerPipe = class PowerPipe {
  transform(num, power = 2) {
      return !isNaN(num) ? Math.pow(num, power) : num;
  }
2090};
2091PowerPipe = __decorate([
  Pipe({ name: 'pow' })
2093], PowerPipe);
2094
2095let CeilPipe = class CeilPipe {
  transform(num, precision = 0) {
      if (precision <= 0) {
          return Math.ceil(num);
      }
      const tho = Math.pow(10, precision);
      return Math.ceil(num * tho) / tho;
  }
2103};
2104CeilPipe = __decorate([
  Pipe({ name: 'ceil' })
2106], CeilPipe);
2107
2108let DegreesPipe = class DegreesPipe {
  transform(radians) {
      if (!isNumberFinite(radians)) {
          return NaN;
      }
      return (radians * 180) / Math.PI;
  }
2115};
2116DegreesPipe = __decorate([
  Pipe({ name: 'degrees' })
2118], DegreesPipe);
2119
2120let BytesPipe = class BytesPipe {
  constructor() {
      this.dictionary = [
          { max: 1024, type: 'B' },
          { max: 1048576, type: 'KB' },
          { max: 1073741824, type: 'MB' },
          { max: 1.0995116e12, type: 'GB' },
      ];
  }
  transform(value, precision) {
      if (!isNumberFinite(value)) {
          return NaN;
      }
      const format = this.dictionary.find(d => value < d.max) || this.dictionary[this.dictionary.length - 1];
      const calc = value / (format.max / 1024);
      const num = isUndefined(precision) ? calc : applyPrecision(calc, precision);
      return `${num} ${format.type}`;
  }
2138};
2139BytesPipe = __decorate([
  Pipe({ name: 'bytes' })
2141], BytesPipe);
2142
2143let RadiansPipe = class RadiansPipe {
  transform(degrees) {
      if (!isNumberFinite(degrees)) {
          return NaN;
      }
      return (degrees * Math.PI) / 180;
  }
2150};
2151RadiansPipe = __decorate([
  Pipe({ name: 'radians' })
2153], RadiansPipe);
2154
2155const MATH_PIPES = [
  MaxPipe,
  MinPipe,
  PercentagePipe,
  SumPipe,
  FloorPipe,
  RoundPipe,
  SqrtPipe,
  PowerPipe,
  CeilPipe,
  DegreesPipe,
  BytesPipe,
  RadiansPipe,
2168];
2169let NgMathPipesModule = class NgMathPipesModule {
2170};
2171NgMathPipesModule = __decorate([
  NgModule({
      declarations: MATH_PIPES,
      imports: [],
      exports: MATH_PIPES,
  })
2177], NgMathPipesModule);
2178
2179let IsDefinedPipe = class IsDefinedPipe {
  transform(input) {
      return !isUndefined(input);
  }
2183};
2184IsDefinedPipe = __decorate([
  Pipe({ name: 'isDefined' })
2186], IsDefinedPipe);
2187
2188let IsNullPipe = class IsNullPipe {
  transform(input) {
      return input === null;
  }
2192};
2193IsNullPipe = __decorate([
  Pipe({ name: 'isNull' })
2195], IsNullPipe);
2196
2197let IsUndefinedPipe = class IsUndefinedPipe {
  transform(input) {
      return isUndefined(input);
  }
2201};
2202IsUndefinedPipe = __decorate([
  Pipe({ name: 'isUndefined' })
2204], IsUndefinedPipe);
2205
2206let IsStringPipe = class IsStringPipe {
  transform(input) {
      return isString(input);
  }
2210};
2211IsStringPipe = __decorate([
  Pipe({ name: 'isString' })
2213], IsStringPipe);
2214
2215let IsFunctionPipe = class IsFunctionPipe {
  transform(input) {
      return isFunction(input);
  }
2219};
2220IsFunctionPipe = __decorate([
  Pipe({ name: 'isFunction' })
2222], IsFunctionPipe);
2223
2224let IsNumberPipe = class IsNumberPipe {
  transform(input) {
      return isNumber(input);
  }
2228};
2229IsNumberPipe = __decorate([
  Pipe({ name: 'isNumber' })
2231], IsNumberPipe);
2232
2233let IsArrayPipe = class IsArrayPipe {
  transform(input) {
      return Array.isArray(input);
  }
2237};
2238IsArrayPipe = __decorate([
  Pipe({ name: 'isArray' })
2240], IsArrayPipe);
2241
2242let IsObjectPipe = class IsObjectPipe {
  transform(input) {
      return isObject(input);
  }
2246};
2247IsObjectPipe = __decorate([
  Pipe({ name: 'isObject' })
2249], IsObjectPipe);
2250
2251let IsGreaterEqualThanPipe = class IsGreaterEqualThanPipe {
  transform(input, other) {
      return input >= other;
  }
2255};
2256IsGreaterEqualThanPipe = __decorate([
  Pipe({ name: 'isGreaterEqualThan' })
2258], IsGreaterEqualThanPipe);
2259
2260let IsGreaterThanPipe = class IsGreaterThanPipe {
  transform(input, other) {
      return input > other;
  }
2264};
2265IsGreaterThanPipe = __decorate([
  Pipe({ name: 'isGreaterThan' })
2267], IsGreaterThanPipe);
2268
2269let IsLessEqualThanPipe = class IsLessEqualThanPipe {
  transform(input, other) {
      return input <= other;
  }
2273};
2274IsLessEqualThanPipe = __decorate([
  Pipe({ name: 'isLessEqualThan' })
2276], IsLessEqualThanPipe);
2277
2278let IsEqualToPipe = class IsEqualToPipe {
  transform(input, other) {
      // tslint:disable-next-line:triple-equals
      return input == other;
  }
2283};
2284IsEqualToPipe = __decorate([
  Pipe({ name: 'isEqualTo' })
2286], IsEqualToPipe);
2287
2288let IsNotEqualToPipe = class IsNotEqualToPipe {
  transform(input, other) {
      // tslint:disable-next-line:triple-equals
      return input != other;
  }
2293};
2294IsNotEqualToPipe = __decorate([
  Pipe({ name: 'isNotEqualTo' })
2296], IsNotEqualToPipe);
2297
2298let IsIdenticalToPipe = class IsIdenticalToPipe {
  transform(input, other) {
      return input === other;
  }
2302};
2303IsIdenticalToPipe = __decorate([
  Pipe({ name: 'isIdenticalTo' })
2305], IsIdenticalToPipe);
2306
2307let IsNotIdenticalToPipe = class IsNotIdenticalToPipe {
  transform(input, other) {
      return input !== other;
  }
2311};
2312IsNotIdenticalToPipe = __decorate([
  Pipe({ name: 'isNotIdenticalTo' })
2314], IsNotIdenticalToPipe);
2315
2316let IsLessThanPipe = class IsLessThanPipe {
  transform(input, other) {
      return input < other;
  }
2320};
2321IsLessThanPipe = __decorate([
  Pipe({ name: 'isLessThan' })
2323], IsLessThanPipe);
2324
2325const BOOLEAN_PIPES = [
  IsDefinedPipe,
  IsNullPipe,
  IsUndefinedPipe,
  IsStringPipe,
  IsFunctionPipe,
  IsNumberPipe,
  IsArrayPipe,
  IsObjectPipe,
  IsGreaterEqualThanPipe,
  IsGreaterThanPipe,
  IsLessEqualThanPipe,
  IsLessEqualThanPipe,
  IsEqualToPipe,
  IsNotEqualToPipe,
  IsIdenticalToPipe,
  IsNotIdenticalToPipe,
  IsLessThanPipe,
2343];
2344let NgBooleanPipesModule = class NgBooleanPipesModule {
2345};
2346NgBooleanPipesModule = __decorate([
  NgModule({
      declarations: BOOLEAN_PIPES,
      imports: [],
      exports: BOOLEAN_PIPES,
  })
2352], NgBooleanPipesModule);
2353
2354var TimeAgoPipe_1;
2355let TimeAgoPipe = TimeAgoPipe_1 = class TimeAgoPipe {
  /**
   * @param inputDate: Date | Moment - not included as TypeScript interface,
   * in order to keep `ngx-pipes` "pure" from dependencies!
   */
  transform(inputDate) {
      if (!inputDate || (!inputDate.getTime && !inputDate.toDate)) {
          return 'Invalid date';
      }
      const past = inputDate.toDate ? inputDate.toDate() : inputDate.getTime();
      const now = +new Date();
      if (past > now) {
          return 'in the future';
      }
      for (let i = 0, l = TimeAgoPipe_1.MAPPER.length, ms = now - past, div = TimeAgoPipe_1.YEAR_MS; i < l; ++i) {
          const elm = TimeAgoPipe_1.MAPPER[i];
          const unit = Math.floor(ms / (div /= elm.div));
          if (unit >= 1) {
              return unit === 1 ? elm.single : `${unit} ${elm.many} ago`;
          }
      }
      return 'just now';
  }
2378};
2379TimeAgoPipe.YEAR_MS = 1000 * 60 * 60 * 24 * 7 * 4 * 12;
2380TimeAgoPipe.MAPPER = [
  { single: 'last year', many: 'years', div: 1 },
  { single: 'last month', many: 'months', div: 12 },
  { single: 'last week', many: 'weeks', div: 4 },
  { single: 'yesterday', many: 'days', div: 7 },
  { single: 'an hour ago', many: 'hours', div: 24 },
  { single: 'just now', many: 'minutes', div: 60 },
2387];
2388TimeAgoPipe = TimeAgoPipe_1 = __decorate([
  Pipe({ name: 'timeAgo' })
2390], TimeAgoPipe);
2391
2392const DATE_PIPES = [TimeAgoPipe];
2393let NgDatePipesModule = class NgDatePipesModule {
2394};
2395NgDatePipesModule = __decorate([
  NgModule({
      declarations: DATE_PIPES,
      imports: [],
      exports: DATE_PIPES,
  })
2401], NgDatePipesModule);
2402
2403let NgPipesModule = class NgPipesModule {
2404};
2405NgPipesModule = __decorate([
  NgModule({
      exports: [
          NgArrayPipesModule,
          NgStringPipesModule,
          NgMathPipesModule,
          NgBooleanPipesModule,
          NgObjectPipesModule,
          NgDatePipesModule,
      ],
  })
2416], NgPipesModule);
2417
2418export { AorAnPipe, BOOLEAN_PIPES, BytesPipe, CamelizePipe, CeilPipe, ChunkPipe, DATE_PIPES, DegreesPipe, DiffObjPipe, DiffPipe, EveryPipe, FilterByImpurePipe, FilterByPipe, FlattenPipe, FloorPipe, GroupByImpurePipe, GroupByPipe, InitialPipe, IntersectionPipe, InvertByPipe, InvertPipe, IsArrayPipe, IsDefinedPipe, IsEqualToPipe, IsFunctionPipe, IsGreaterEqualThanPipe, IsGreaterThanPipe, IsIdenticalToPipe, IsLessEqualThanPipe, IsLessThanPipe, IsNotEqualToPipe, IsNotIdenticalToPipe, IsNullPipe, IsNumberPipe, IsObjectPipe, IsStringPipe, IsUndefinedPipe, KeysPipe, LatinisePipe, LeftPadPipe, LeftTrimPipe, LinesPipe, MATH_PIPES, MakePluralStringPipe, MatchPipe, MaxPipe, MinPipe, NgArrayPipesModule, NgBooleanPipesModule, NgDatePipesModule, NgMathPipesModule, NgObjectPipesModule, NgPipesModule, NgStringPipesModule, OmitPipe, OrderByImpurePipe, OrderByPipe, PairsPipe, PercentagePipe, PickPipe, PluckPipe, PowerPipe, RangePipe, RepeatPipe, ReversePipe, RightPadPipe, RightTrimPipe, RoundPipe, STRING_PIPES, SamplePipe, ScanPipe, ShortenPipe, ShufflePipe, SlugifyPipe, SomePipe, SqrtPipe, StripTagsPipe, SumPipe, TailPipe, TestPipe, TimeAgoPipe, TrimPipe, TrurthifyPipe, UcFirstPipe, UcWordsPipe, UnderscorePipe, UnionPipe, UniquePipe, ValuesPipe, WithoutPipe, WrapPipe, isString as ɵa, FromPairsPipe as ɵb, RadiansPipe as ɵc };
2419//# sourceMappingURL=ngx-pipes.js.map
1	`import { __decorate } from 'tslib';`
2	`import { Pipe, NgModule } from '@angular/core';`
3
4	`let DiffPipe = class DiffPipe {`
5	`transform(input, ...args) {`
6	`if (!Array.isArray(input)) {`
7	`return input;`
8	`}`
9	`// tslint:disable-next-line no-bitwise`
10	`return args.reduce((d, c) => d.filter((e) => !~c.indexOf(e)), input);`
11	`}`
12	`};`
13	`DiffPipe = __decorate([`
14	`Pipe({ name: 'diff' })`
15	`], DiffPipe);`
16
17	`let InitialPipe = class InitialPipe {`
18	`transform(input, num = 0) {`
19	`return Array.isArray(input) ? input.slice(0, input.length - num) : input;`
20	`}`
21	`};`
22	`InitialPipe = __decorate([`
23	`Pipe({ name: 'initial' })`
24	`], InitialPipe);`
25
26	`let FlattenPipe = class FlattenPipe {`
27	`transform(input, shallow = false) {`
28	`if (!Array.isArray(input)) {`
29	`return input;`
30	`}`
31	`return shallow ? [].concat.apply([], input) : this.flatten(input);`
32	`}`
33	`flatten(array) {`
34	`return array.reduce((arr, elm) => {`
35	`if (Array.isArray(elm)) {`
36	`return arr.concat(this.flatten(elm));`
37	`}`
38	`return arr.concat(elm);`
39	`}, []);`
40	`}`