@covalent/core 6.4.0 → 6.4.1

package/esm2020/common/behaviors/disable-ripple.mixin.mjs

@@ -0,0 +1,24 @@
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+/** Mixin to augment a component or directive with a `disabled` property. */
+export function mixinDisableRipple(base) {
+    return class extends base {
+        constructor(...args) {
+            super(...args);
+            this._disableRipple = false;
+        }
+        get disableRipple() {
+            return this._disableRipple;
+        }
+        set disableRipple(value) {
+            const newValue = coerceBooleanProperty(value);
+            if (this._disableRipple !== newValue) {
+                this._disableRipple = newValue;
+                this.onDisableRippleChange(this._disableRipple);
+            }
+        }
+        onDisableRippleChange(v) {
+            /** NOT IMPLEMENTED, this needs to be overriden by subclasses if needed */
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2022 → esm2020}/common/behaviors/disabled.mixin.mjs

@@ -2,9 +2,9 @@ import { coerceBooleanProperty } from '@angular/cdk/coercion';
 /** Mixin to augment a component or directive with a `disabled` property. */
 export function mixinDisabled(base) {
     return class extends base {
-        _disabled = false;
         constructor(...args) {
             super(...args);
+            this._disabled = false;
         }
         get disabled() {
             return this._disabled;
@@ -21,4 +21,4 @@ export function mixinDisabled(base) {
         }
     };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2022 → esm2020}/common/common.module.mjs

@@ -35,23 +35,23 @@ const TD_PIPES = [
     TdTruncatePipe,
 ];
 export class CovalentCommonModule {
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: CovalentCommonModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.1.7", ngImport: i0, type: CovalentCommonModule, declarations: [TdAutoTrimDirective, TdFullscreenDirective, TdTimeAgoPipe,
-            TdTimeDifferencePipe,
-            TdTimeUntilPipe,
-            TdBytesPipe,
-            TdDecimalBytesPipe,
-            TdDigitsPipe,
-            TdTruncatePipe], imports: [FormsModule, CommonModule], exports: [FormsModule, CommonModule, TdAutoTrimDirective, TdFullscreenDirective, TdTimeAgoPipe,
-            TdTimeDifferencePipe,
-            TdTimeUntilPipe,
-            TdBytesPipe,
-            TdDecimalBytesPipe,
-            TdDigitsPipe,
-            TdTruncatePipe] });
-    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: CovalentCommonModule, providers: [RouterPathService, IconService], imports: [FormsModule, CommonModule, FormsModule, CommonModule] });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: CovalentCommonModule, decorators: [{
+CovalentCommonModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: CovalentCommonModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+CovalentCommonModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.10", ngImport: i0, type: CovalentCommonModule, declarations: [TdAutoTrimDirective, TdFullscreenDirective, TdTimeAgoPipe,
+        TdTimeDifferencePipe,
+        TdTimeUntilPipe,
+        TdBytesPipe,
+        TdDecimalBytesPipe,
+        TdDigitsPipe,
+        TdTruncatePipe], imports: [FormsModule, CommonModule], exports: [FormsModule, CommonModule, TdAutoTrimDirective, TdFullscreenDirective, TdTimeAgoPipe,
+        TdTimeDifferencePipe,
+        TdTimeUntilPipe,
+        TdBytesPipe,
+        TdDecimalBytesPipe,
+        TdDigitsPipe,
+        TdTruncatePipe] });
+CovalentCommonModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: CovalentCommonModule, providers: [RouterPathService, IconService], imports: [FormsModule, CommonModule, FormsModule, CommonModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: CovalentCommonModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [FormsModule, CommonModule],
@@ -60,4 +60,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImpor
                     providers: [RouterPathService, IconService],
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/common/directives/fullscreen/fullscreen.directive.mjs

@@ -0,0 +1,85 @@
+import { Directive, HostListener, ElementRef, Inject } from '@angular/core';
+import { DOCUMENT } from '@angular/common';
+import * as i0 from "@angular/core";
+export class TdFullscreenDirective {
+    constructor(_document, _el) {
+        this._document = _document;
+        this._el = _el;
+        this.fullScreenIsActive = false;
+    }
+    fsChangeHandler(event) {
+        this.fullScreenIsActive = event.srcElement === this._getFullScreenElement();
+    }
+    toggleFullScreen() {
+        this._getFullScreenElement() === this._el.nativeElement
+            ? this.exitFullScreen()
+            : this.enterFullScreen();
+    }
+    enterFullScreen() {
+        const { _el: { nativeElement }, } = this;
+        const enterFullScreenMap = {
+            requestFullscreen: () => nativeElement.requestFullscreen(),
+            webkitRequestFullscreen: () => nativeElement.webkitRequestFullscreen(),
+            mozRequestFullScreen: () => nativeElement.mozRequestFullScreen(),
+            msRequestFullscreen: () => nativeElement.msRequestFullscreen(), // IE
+        };
+        for (const handler of Object.keys(enterFullScreenMap)) {
+            if (nativeElement[handler]) {
+                enterFullScreenMap[handler]();
+            }
+        }
+    }
+    exitFullScreen() {
+        const exitFullScreenMap = {
+            exitFullscreen: () => this._document.exitFullscreen(),
+            webkitExitFullscreen: () => this._document.webkitExitFullscreen(),
+            mozCancelFullScreen: () => this._document.mozCancelFullScreen(),
+            msExitFullscreen: () => this._document.msExitFullscreen(), // IE
+        };
+        for (const handler of Object.keys(exitFullScreenMap)) {
+            if (exitFullScreenMap[handler] &&
+                this._getFullScreenElement() === this._el.nativeElement) {
+                exitFullScreenMap[handler]();
+            }
+        }
+    }
+    _getFullScreenElement() {
+        const tdFullScreenElementMap = {
+            fullscreenElement: () => this._document.fullscreenElement,
+            webkitFullscreenElement: () => this._document.webkitFullscreenElement,
+            mozFullscreenElement: () => this._document.mozFullscreenElement,
+            msFullscreenElement: () => this._document.msFullscreenElement, // IE, Edge
+        };
+        for (const props of Object.keys(tdFullScreenElementMap)) {
+            if (tdFullScreenElementMap[props]) {
+                return tdFullScreenElementMap[props]();
+            }
+        }
+        return undefined;
+    }
+}
+TdFullscreenDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TdFullscreenDirective, deps: [{ token: DOCUMENT }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+TdFullscreenDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.10", type: TdFullscreenDirective, selector: "[tdFullScreen]", host: { listeners: { "document:fullscreenchange": "fsChangeHandler($event)", "document:webkitfullscreenchange": "fsChangeHandler($event)", "document:mozfullscreenchange": "fsChangeHandler($event)", "document:msfullscreenchange": "fsChangeHandler($event)" } }, exportAs: ["tdFullScreen"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TdFullscreenDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[tdFullScreen]',
+                    exportAs: 'tdFullScreen',
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i0.ElementRef }]; }, propDecorators: { fsChangeHandler: [{
+                type: HostListener,
+                args: ['document:fullscreenchange', ['$event']]
+            }, {
+                type: HostListener,
+                args: ['document:webkitfullscreenchange', ['$event']]
+            }, {
+                type: HostListener,
+                args: ['document:mozfullscreenchange', ['$event']]
+            }, {
+                type: HostListener,
+                args: ['document:msfullscreenchange', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/common/forms/auto-trim/auto-trim.directive.mjs

@@ -0,0 +1,36 @@
+import { Directive } from '@angular/core';
+import { HostListener, Host, Optional } from '@angular/core';
+import { NgModel } from '@angular/forms';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+export class TdAutoTrimDirective {
+    constructor(_model) {
+        this._model = _model;
+    }
+    /**
+     * Listens to host's (blur) event and trims value.
+     */
+    onBlur(event) {
+        if (this._model &&
+            this._model.value &&
+            typeof this._model.value === 'string') {
+            this._model.update.emit(this._model.value.trim());
+        }
+    }
+}
+TdAutoTrimDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TdAutoTrimDirective, deps: [{ token: i1.NgModel, host: true, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+TdAutoTrimDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.10", type: TdAutoTrimDirective, selector: "[tdAutoTrim]", host: { listeners: { "blur": "onBlur($event)" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TdAutoTrimDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[tdAutoTrim]',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.NgModel, decorators: [{
+                    type: Optional
+                }, {
+                    type: Host
+                }] }]; }, propDecorators: { onBlur: [{
+                type: HostListener,
+                args: ['blur', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0by10cmltLmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYW5ndWxhci9jb21tb24vc3JjL2Zvcm1zL2F1dG8tdHJpbS9hdXRvLXRyaW0uZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDMUMsT0FBTyxFQUFFLFlBQVksRUFBRSxJQUFJLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzdELE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQzs7O0FBS3pDLE1BQU0sT0FBTyxtQkFBbUI7SUFDOUIsWUFBd0MsTUFBZTtRQUFmLFdBQU0sR0FBTixNQUFNLENBQVM7SUFBRyxDQUFDO0lBRTNEOztPQUVHO0lBRUgsTUFBTSxDQUFDLEtBQVk7UUFDakIsSUFDRSxJQUFJLENBQUMsTUFBTTtZQUNYLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSztZQUNqQixPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxLQUFLLFFBQVEsRUFDckM7WUFDQSxJQUFJLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsSUFBSSxFQUFFLENBQUMsQ0FBQztTQUNuRDtJQUNILENBQUM7O2lIQWZVLG1CQUFtQjtxR0FBbkIsbUJBQW1COzRGQUFuQixtQkFBbUI7a0JBSC9CLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLGNBQWM7aUJBQ3pCOzswQkFFYyxRQUFROzswQkFBSSxJQUFJOzRDQU03QixNQUFNO3NCQURMLFlBQVk7dUJBQUMsTUFBTSxFQUFFLENBQUMsUUFBUSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGlyZWN0aXZlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBIb3N0TGlzdGVuZXIsIEhvc3QsIE9wdGlvbmFsIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBOZ01vZGVsIH0gZnJvbSAnQGFuZ3VsYXIvZm9ybXMnO1xuXG5ARGlyZWN0aXZlKHtcbiAgc2VsZWN0b3I6ICdbdGRBdXRvVHJpbV0nLFxufSlcbmV4cG9ydCBjbGFzcyBUZEF1dG9UcmltRGlyZWN0aXZlIHtcbiAgY29uc3RydWN0b3IoQE9wdGlvbmFsKCkgQEhvc3QoKSBwcml2YXRlIF9tb2RlbDogTmdNb2RlbCkge31cblxuICAvKipcbiAgICogTGlzdGVucyB0byBob3N0J3MgKGJsdXIpIGV2ZW50IGFuZCB0cmltcyB2YWx1ZS5cbiAgICovXG4gIEBIb3N0TGlzdGVuZXIoJ2JsdXInLCBbJyRldmVudCddKVxuICBvbkJsdXIoZXZlbnQ6IEV2ZW50KTogdm9pZCB7XG4gICAgaWYgKFxuICAgICAgdGhpcy5fbW9kZWwgJiZcbiAgICAgIHRoaXMuX21vZGVsLnZhbHVlICYmXG4gICAgICB0eXBlb2YgdGhpcy5fbW9kZWwudmFsdWUgPT09ICdzdHJpbmcnXG4gICAgKSB7XG4gICAgICB0aGlzLl9tb2RlbC51cGRhdGUuZW1pdCh0aGlzLl9tb2RlbC52YWx1ZS50cmltKCkpO1xuICAgIH1cbiAgfVxufVxuIl19

package/esm2020/common/functions/convert.mjs

@@ -0,0 +1,84 @@
+/**
+ * Conversion function that takes an array of objects and converts
+ * them to CSV format. Custom key and line separators can be specified.
+ *
+ * @param objects list of strings in JSON format or actual objects
+ * @param keySeparator optional parameter to specify custom value separator
+ * @param lineSeparator optional parameter to specify custom end of line separator
+ * @returns CSV formatted string
+ */
+export function convertObjectsToCSV(objects, keySeparator = ',', lineSeparator = '\r\n') {
+    if (!objects) {
+        return '';
+    }
+    let outputString = '';
+    // Iterate through array, creating one output line per object
+    objects.forEach((value, key) => {
+        let line = '';
+        for (const index of Object.keys(objects[key])) {
+            if (line !== '') {
+                line += keySeparator;
+            }
+            if (objects[key][index] === null || objects[key][index] === undefined) {
+                objects[key][index] = '';
+            }
+            line += objects[key][index];
+        }
+        outputString += `${line}${lineSeparator}`;
+    });
+    // Append header row identifying keys into output
+    if (objects[0]) {
+        const headers = Object.keys(objects[0]).join(keySeparator);
+        outputString = `${headers}${lineSeparator}${outputString}`;
+    }
+    return outputString;
+}
+/**
+ * Conversion function that takes a CSV representation
+ * of objects and converts them to JSON.
+ * The first row in the input must be the object keys.
+ * Custom key separator and line separator can be specified.
+ * Indentation size for output JSON can be specified.
+ *
+ * @param csv list of strings in JSON format or actual objects
+ * @param keySeparator optional parameter to specify custom value separator
+ * @param lineSeparator optional parameter to specify custom end of line separator
+ * @param indent optional parameter indicating space indentation for pretty output. Default is 2.
+ * @returns JSON formatted string
+ */
+export function convertCSVToJSON(csv, keySeparator = ',', lineSeparator = '\r\n', indent = 2) {
+    if (!csv) {
+        return '';
+    }
+    const csvArray = csv.split(lineSeparator);
+    // Input CSV must have a minimum of two rows
+    if (csvArray.length < 2) {
+        return '';
+    }
+    const newObjects = [];
+    // Extract object keys from header row
+    const keys = csvArray[0].split(keySeparator);
+    // Iterate through array, creating one output line per object
+    for (let i = 1; i < csvArray.length; i++) {
+        const newObject = {};
+        const values = csvArray[i].split(keySeparator);
+        if (values.length !== keys.length) {
+            continue;
+        }
+        for (let j = 0; j < keys.length; j++) {
+            newObject[keys[j]] = values[j];
+        }
+        newObjects.push(newObject);
+    }
+    return formatJSON(newObjects, indent);
+}
+/**
+ * Convert object to JSON using stringify. Indentation size for output JSON can be specified.
+ *
+ * @param json object to be converted
+ * @param indent optional parameter indicating space indentation for pretty output. Default is 2.
+ */
+export function formatJSON(json, indent = 2) {
+    return JSON.stringify(json, undefined, indent);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/common/functions/download.mjs

@@ -0,0 +1,75 @@
+import { convertObjectsToCSV, formatJSON } from './convert';
+/**
+ * Download CSV content to the specified file with .csv extension
+ * appended to the provided base file name.
+ *
+ * @param fileBaseName base name of destination file
+ * @param csv CSV contents
+ */
+export function downloadCSV(fileBaseName, csv) {
+    downloadFile(`${fileBaseName}.csv`, csv, 'text/csv');
+}
+/**
+ * Download JSON content to the specified file with .json extension
+ * appended to the provided base file name.
+ *
+ * @param fileBaseName base name of destination file
+ * @param json JSON contents
+ * @param format indicates if JSON should be prettied
+ * @param indent optional parameter indicating space indentation for pretty output. Default is 2
+ */
+export function downloadJSON(fileBaseName, json, format = false, indent = 2) {
+    downloadFile(`${fileBaseName}.json`, format ? formatJSON(JSON.parse(json), indent) : json, 'application/json');
+}
+/**
+ * Convert objects to CSV format and download to file with .csv
+ * extension appended to the provided base file name. Custom key
+ * separator and line separator can be specified.
+ *
+ * @param fileBaseName base name of destination file
+ * @param objects object array to be converted to CSV format
+ *   prior to writing to download destination
+ * @param keySeparator optional parameter to specify custom value separator
+ * @param lineSeparator optional parameter to specify custom end of line separator
+ */
+export function downloadObjectsToCSV(fileBaseName, objects, keySeparator = ',', lineSeparator = '\r\n') {
+    downloadFile(`${fileBaseName}.csv`, convertObjectsToCSV(objects, keySeparator, lineSeparator), 'text/csv');
+}
+/**
+ * Convert objects to JSON format and download to file with .json
+ * extension appended to the provided base file name.
+ *
+ * @param fileBaseName base name of destination file
+ * @param objects object array to be converted to JSON format
+ *   prior to writing to download destination
+ * @param indent optional parameter indicating space indentation for pretty output. Default is 2
+ */
+export function downloadObjectsToJSON(fileBaseName, objects, indent = 2) {
+    downloadFile(`${fileBaseName}.json`, formatJSON(objects, indent), 'application/json');
+}
+/**
+ * Download string content to the specified file with desired mime type.
+ *
+ * @param fileName full filename (including appropriate extension) of destination file
+ * @param contents string contents to be written to download destination
+ * @param mimeType mime type appropriate to file content to support consumption of destination file
+ */
+export function downloadFile(fileName, contents, mimeType = 'text/plain') {
+    if (!fileName || !contents) {
+        return;
+    }
+    // Create blob object and assign URL
+    const blob = new Blob([contents], { type: mimeType });
+    const url = window.URL.createObjectURL(blob);
+    // Construct anchor for URL, append to DOM, click and cleanup.
+    const a = document.createElement('a');
+    a.setAttribute('style', 'display: none');
+    a.setAttribute('download', fileName);
+    a.href = url;
+    document.body.appendChild(a);
+    a.click();
+    window.URL.revokeObjectURL(url);
+    document.body.removeChild(a);
+    window.URL.revokeObjectURL(url);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/common/pipes/bytes/bytes.pipe.mjs

@@ -0,0 +1,42 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+export class TdBytesPipe {
+    /* `bytes` needs to be `any` or TypeScript complains
+    Tried both `number` and `number | string` */
+    transform(bytes, precision = 2) {
+        if (bytes === 0) {
+            return '0 B';
+        }
+        else if (isNaN(parseInt(bytes, 10))) {
+            /* If not a valid number, return 'Invalid Number' */
+            return 'Invalid Number';
+        }
+        const k = 1024;
+        const sizes = [
+            'B',
+            'KiB',
+            'MiB',
+            'GiB',
+            'TiB',
+            'PiB',
+            'EiB',
+            'ZiB',
+            'YiB',
+        ];
+        const i = Math.floor(Math.log(bytes) / Math.log(k));
+        // if less than 1
+        if (i < 0) {
+            return 'Invalid Number';
+        }
+        return (parseFloat((bytes / Math.pow(k, i)).toFixed(precision)) + ' ' + sizes[i]);
+    }
+}
+TdBytesPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TdBytesPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+TdBytesPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.2.10", ngImport: i0, type: TdBytesPipe, name: "bytes" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TdBytesPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'bytes',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnl0ZXMucGlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYW5ndWxhci9jb21tb24vc3JjL3BpcGVzL2J5dGVzL2J5dGVzLnBpcGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLElBQUksRUFBaUIsTUFBTSxlQUFlLENBQUM7O0FBS3BELE1BQU0sT0FBTyxXQUFXO0lBQ3RCO2dEQUM0QztJQUM1QyxTQUFTLENBQUMsS0FBVSxFQUFFLFlBQW9CLENBQUM7UUFDekMsSUFBSSxLQUFLLEtBQUssQ0FBQyxFQUFFO1lBQ2YsT0FBTyxLQUFLLENBQUM7U0FDZDthQUFNLElBQUksS0FBSyxDQUFDLFFBQVEsQ0FBQyxLQUFLLEVBQUUsRUFBRSxDQUFDLENBQUMsRUFBRTtZQUNyQyxvREFBb0Q7WUFDcEQsT0FBTyxnQkFBZ0IsQ0FBQztTQUN6QjtRQUNELE1BQU0sQ0FBQyxHQUFHLElBQUksQ0FBQztRQUNmLE1BQU0sS0FBSyxHQUFhO1lBQ3RCLEdBQUc7WUFDSCxLQUFLO1lBQ0wsS0FBSztZQUNMLEtBQUs7WUFDTCxLQUFLO1lBQ0wsS0FBSztZQUNMLEtBQUs7WUFDTCxLQUFLO1lBQ0wsS0FBSztTQUNOLENBQUM7UUFDRixNQUFNLENBQUMsR0FBVyxJQUFJLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsS0FBSyxDQUFDLEdBQUcsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBQzVELGlCQUFpQjtRQUNqQixJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUU7WUFDVCxPQUFPLGdCQUFnQixDQUFDO1NBQ3pCO1FBQ0QsT0FBTyxDQUNMLFVBQVUsQ0FBQyxDQUFDLEtBQUssR0FBRyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxTQUFTLENBQUMsQ0FBQyxHQUFHLEdBQUcsR0FBRyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQ3pFLENBQUM7SUFDSixDQUFDOzt5R0E5QlUsV0FBVzt1R0FBWCxXQUFXOzRGQUFYLFdBQVc7a0JBSHZCLElBQUk7bUJBQUM7b0JBQ0osSUFBSSxFQUFFLE9BQU87aUJBQ2QiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBQaXBlLCBQaXBlVHJhbnNmb3JtIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBQaXBlKHtcbiAgbmFtZTogJ2J5dGVzJyxcbn0pXG5leHBvcnQgY2xhc3MgVGRCeXRlc1BpcGUgaW1wbGVtZW50cyBQaXBlVHJhbnNmb3JtIHtcbiAgLyogYGJ5dGVzYCBuZWVkcyB0byBiZSBgYW55YCBvciBUeXBlU2NyaXB0IGNvbXBsYWluc1xuICBUcmllZCBib3RoIGBudW1iZXJgIGFuZCBgbnVtYmVyIHwgc3RyaW5nYCAqL1xuICB0cmFuc2Zvcm0oYnl0ZXM6IGFueSwgcHJlY2lzaW9uOiBudW1iZXIgPSAyKTogc3RyaW5nIHtcbiAgICBpZiAoYnl0ZXMgPT09IDApIHtcbiAgICAgIHJldHVybiAnMCBCJztcbiAgICB9IGVsc2UgaWYgKGlzTmFOKHBhcnNlSW50KGJ5dGVzLCAxMCkpKSB7XG4gICAgICAvKiBJZiBub3QgYSB2YWxpZCBudW1iZXIsIHJldHVybiAnSW52YWxpZCBOdW1iZXInICovXG4gICAgICByZXR1cm4gJ0ludmFsaWQgTnVtYmVyJztcbiAgICB9XG4gICAgY29uc3QgayA9IDEwMjQ7XG4gICAgY29uc3Qgc2l6ZXM6IHN0cmluZ1tdID0gW1xuICAgICAgJ0InLFxuICAgICAgJ0tpQicsXG4gICAgICAnTWlCJyxcbiAgICAgICdHaUInLFxuICAgICAgJ1RpQicsXG4gICAgICAnUGlCJyxcbiAgICAgICdFaUInLFxuICAgICAgJ1ppQicsXG4gICAgICAnWWlCJyxcbiAgICBdO1xuICAgIGNvbnN0IGk6IG51bWJlciA9IE1hdGguZmxvb3IoTWF0aC5sb2coYnl0ZXMpIC8gTWF0aC5sb2coaykpO1xuICAgIC8vIGlmIGxlc3MgdGhhbiAxXG4gICAgaWYgKGkgPCAwKSB7XG4gICAgICByZXR1cm4gJ0ludmFsaWQgTnVtYmVyJztcbiAgICB9XG4gICAgcmV0dXJuIChcbiAgICAgIHBhcnNlRmxvYXQoKGJ5dGVzIC8gTWF0aC5wb3coaywgaSkpLnRvRml4ZWQocHJlY2lzaW9uKSkgKyAnICcgKyBzaXplc1tpXVxuICAgICk7XG4gIH1cbn1cbiJdfQ==

package/esm2020/common/pipes/decimal-bytes/decimal-bytes.pipe.mjs

@@ -0,0 +1,42 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+export class TdDecimalBytesPipe {
+    /* `bytes` needs to be `any` or TypeScript complains
+    Tried both `number` and `number | string` */
+    transform(bytes, precision = 2) {
+        if (bytes === 0) {
+            return '0 B';
+        }
+        else if (isNaN(parseInt(bytes, 10))) {
+            /* If not a valid number, return 'Invalid Number' */
+            return 'Invalid Number';
+        }
+        const k = 1000;
+        const sizes = [
+            'B',
+            'KB',
+            'MB',
+            'GB',
+            'TB',
+            'PB',
+            'EB',
+            'ZB',
+            'YB',
+        ];
+        const i = Math.floor(Math.log(bytes) / Math.log(k));
+        // if less than 1
+        if (i < 0) {
+            return 'Invalid Number';
+        }
+        return (parseFloat((bytes / Math.pow(k, i)).toFixed(precision)) + ' ' + sizes[i]);
+    }
+}
+TdDecimalBytesPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TdDecimalBytesPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+TdDecimalBytesPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.2.10", ngImport: i0, type: TdDecimalBytesPipe, name: "decimalBytes" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TdDecimalBytesPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'decimalBytes',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/common/pipes/digits/digits.pipe.mjs

@@ -0,0 +1,39 @@
+import { Pipe, Inject, LOCALE_ID } from '@angular/core';
+import { DecimalPipe } from '@angular/common';
+import * as i0 from "@angular/core";
+export class TdDigitsPipe {
+    constructor(_locale = 'en') {
+        this._locale = _locale;
+        this._decimalPipe = new DecimalPipe(this._locale);
+    }
+    /* `digits` needs to be type `digits: any` or TypeScript complains */
+    transform(digits, precision = 1) {
+        if (digits === 0) {
+            return '0';
+        }
+        else if (isNaN(parseInt(digits, 10))) {
+            /* If not a valid number, return the value */
+            return digits;
+        }
+        else if (digits < 1) {
+            return this._decimalPipe.transform(digits.toFixed(precision)) ?? '';
+        }
+        const k = 1000;
+        const sizes = ['', 'K', 'M', 'B', 'T', 'Q'];
+        const i = Math.floor(Math.log(digits) / Math.log(k));
+        const size = sizes[i];
+        return (this._decimalPipe.transform(parseFloat((digits / Math.pow(k, i)).toFixed(precision))) + (size ? ' ' + size : ''));
+    }
+}
+TdDigitsPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TdDigitsPipe, deps: [{ token: LOCALE_ID }], target: i0.ɵɵFactoryTarget.Pipe });
+TdDigitsPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.2.10", ngImport: i0, type: TdDigitsPipe, name: "digits" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TdDigitsPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'digits',
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [LOCALE_ID]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2022 → esm2020}/common/pipes/time-ago/time-ago.pipe.mjs

@@ -60,13 +60,13 @@ export class TdTimeAgoPipe {
             return Math.floor(diff) + ' years ago';
         }
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: TdTimeAgoPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
-    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "16.1.7", ngImport: i0, type: TdTimeAgoPipe, name: "timeAgo" });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: TdTimeAgoPipe, decorators: [{
+TdTimeAgoPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TdTimeAgoPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+TdTimeAgoPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.2.10", ngImport: i0, type: TdTimeAgoPipe, name: "timeAgo" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TdTimeAgoPipe, decorators: [{
             type: Pipe,
             args: [{
                     name: 'timeAgo',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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