nmce-func 0.0.3 → 0.0.7

package/bundles/nmce-func.umd.js

@@ -0,0 +1,1294 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/common/http'), require('@angular/core'), require('rxjs/operators'), require('moment'), require('uuid')) :
+    typeof define === 'function' && define.amd ? define('nmce-func', ['exports', '@angular/common/http', '@angular/core', 'rxjs/operators', 'moment', 'uuid'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global['nmce-func'] = {}, global.ng.common.http, global.ng.core, global.rxjs.operators, global.moment, global.uuid));
+}(this, (function (exports, http, core, operators, moment, uuid) { 'use strict';
+
+    function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+    var moment__default = /*#__PURE__*/_interopDefaultLegacy(moment);
+
+    var AddressFunc = /** @class */ (function () {
+        function AddressFunc() {
+        }
+        /**
+         * Compose to one line separated by comma
+         * @param st1
+         * @param st2
+         * @param city
+         * @param state
+         * @param postcode
+         */
+        AddressFunc.composeOneLineAddress = function (st1, st2, city, state, postcode) {
+            return AddressFunc.composeAddress(st1, st2, city, state, postcode, ', ');
+        };
+        /**
+         * Compose to multiple separated by \n
+         * @param st1
+         * @param st2
+         * @param city
+         * @param state
+         * @param postcode
+         */
+        AddressFunc.composeMultiLineAddress = function (st1, st2, city, state, postcode) {
+            return AddressFunc.composeAddress(st1, st2, city, state, postcode, '\n');
+        };
+        /**
+         * Compose with separator
+         * @param st1
+         * @param st2
+         * @param city
+         * @param state
+         * @param postcode
+         * @param sep
+         */
+        AddressFunc.composeAddress = function (st1, st2, city, state, postcode, sep) {
+            var r = (st1 ? (st1 + sep) : '') + (st2 ? (st2 + sep) : '') + (city ? (city + sep) : '') + (state ? (state + ' ') : '') + (postcode ? postcode : '');
+            return r;
+        };
+        AddressFunc.composeGoogleMapsAuUrl = function (st1, st2, city, state, country) {
+            var googleBaseUrl = 'https://www.google.com.au/maps?hl=en&q=';
+            var fff = function (s) {
+                if (!s) {
+                    return '';
+                }
+                return '+' + encodeURIComponent(s.replace(' ', '+')) + ',';
+            };
+            var ss = fff(st1) + fff(st2) + fff(city) + fff(state) + fff(country);
+            return googleBaseUrl + ss;
+        };
+        return AddressFunc;
+    }());
+
+    /**
+     * Login and saving tokens in sessionStorage.
+     * App needs to provide constant 'auth.tokenUrl'.
+     */
+    var AuthenticationService = /** @class */ (function () {
+        function AuthenticationService(authUri, http) {
+            this.authUri = authUri;
+            this.http = http;
+        }
+        /**
+         * Login and save tokens to sessionStorage then return an observable.
+         * @param username
+         * @param password
+         */
+        AuthenticationService.prototype.login = function (username, password) {
+            var _this = this;
+            var body = 'username=' + username + '&password=' + password + '&grant_type=password';
+            var options = { headers: { 'content-type': 'application/x-www-form-urlencoded; charset=UTF-8' } };
+            return this.http.post(this.authUri, body, options)
+                .pipe(operators.map(function (response) {
+                //sessionStorage.setItem('access_token', response.access_token); The client code is response to doing these.
+                //sessionStorage.setItem('expires_in', response.expires_in.toString());
+                //sessionStorage.setItem('token_type', response.token_type);
+                //sessionStorage.setItem('issued', response.issued);
+                //sessionStorage.setItem('expires', response.expires); // often up to 2 weeks by default in Asp.net identity 2.
+                _this.userName = response.username;
+                //APP_STATUSES.userName = this.userName;
+                return response;
+            }));
+        };
+        return AuthenticationService;
+    }());
+    AuthenticationService.decorators = [
+        { type: core.Injectable }
+    ];
+    AuthenticationService.ctorParameters = function () { return [
+        { type: String, decorators: [{ type: core.Inject, args: ['auth.tokenUrl',] }] },
+        { type: http.HttpClient }
+    ]; };
+
+    /*! *****************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+    /* global Reflect, Promise */
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b)
+                if (Object.prototype.hasOwnProperty.call(b, p))
+                    d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    function __extends(d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    }
+    var __assign = function () {
+        __assign = Object.assign || function __assign(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s)
+                    if (Object.prototype.hasOwnProperty.call(s, p))
+                        t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign.apply(this, arguments);
+    };
+    function __rest(s, e) {
+        var t = {};
+        for (var p in s)
+            if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+                t[p] = s[p];
+        if (s != null && typeof Object.getOwnPropertySymbols === "function")
+            for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+                if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                    t[p[i]] = s[p[i]];
+            }
+        return t;
+    }
+    function __decorate(decorators, target, key, desc) {
+        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+        if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+            r = Reflect.decorate(decorators, target, key, desc);
+        else
+            for (var i = decorators.length - 1; i >= 0; i--)
+                if (d = decorators[i])
+                    r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+        return c > 3 && r && Object.defineProperty(target, key, r), r;
+    }
+    function __param(paramIndex, decorator) {
+        return function (target, key) { decorator(target, key, paramIndex); };
+    }
+    function __metadata(metadataKey, metadataValue) {
+        if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+            return Reflect.metadata(metadataKey, metadataValue);
+    }
+    function __awaiter(thisArg, _arguments, P, generator) {
+        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+        return new (P || (P = Promise))(function (resolve, reject) {
+            function fulfilled(value) { try {
+                step(generator.next(value));
+            }
+            catch (e) {
+                reject(e);
+            } }
+            function rejected(value) { try {
+                step(generator["throw"](value));
+            }
+            catch (e) {
+                reject(e);
+            } }
+            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+            step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+    }
+    function __generator(thisArg, body) {
+        var _ = { label: 0, sent: function () { if (t[0] & 1)
+                throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function () { return this; }), g;
+        function verb(n) { return function (v) { return step([n, v]); }; }
+        function step(op) {
+            if (f)
+                throw new TypeError("Generator is already executing.");
+            while (_)
+                try {
+                    if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+                        return t;
+                    if (y = 0, t)
+                        op = [op[0] & 2, t.value];
+                    switch (op[0]) {
+                        case 0:
+                        case 1:
+                            t = op;
+                            break;
+                        case 4:
+                            _.label++;
+                            return { value: op[1], done: false };
+                        case 5:
+                            _.label++;
+                            y = op[1];
+                            op = [0];
+                            continue;
+                        case 7:
+                            op = _.ops.pop();
+                            _.trys.pop();
+                            continue;
+                        default:
+                            if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                                _ = 0;
+                                continue;
+                            }
+                            if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) {
+                                _.label = op[1];
+                                break;
+                            }
+                            if (op[0] === 6 && _.label < t[1]) {
+                                _.label = t[1];
+                                t = op;
+                                break;
+                            }
+                            if (t && _.label < t[2]) {
+                                _.label = t[2];
+                                _.ops.push(op);
+                                break;
+                            }
+                            if (t[2])
+                                _.ops.pop();
+                            _.trys.pop();
+                            continue;
+                    }
+                    op = body.call(thisArg, _);
+                }
+                catch (e) {
+                    op = [6, e];
+                    y = 0;
+                }
+                finally {
+                    f = t = 0;
+                }
+            if (op[0] & 5)
+                throw op[1];
+            return { value: op[0] ? op[1] : void 0, done: true };
+        }
+    }
+    var __createBinding = Object.create ? (function (o, m, k, k2) {
+        if (k2 === undefined)
+            k2 = k;
+        Object.defineProperty(o, k2, { enumerable: true, get: function () { return m[k]; } });
+    }) : (function (o, m, k, k2) {
+        if (k2 === undefined)
+            k2 = k;
+        o[k2] = m[k];
+    });
+    function __exportStar(m, o) {
+        for (var p in m)
+            if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p))
+                __createBinding(o, m, p);
+    }
+    function __values(o) {
+        var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+        if (m)
+            return m.call(o);
+        if (o && typeof o.length === "number")
+            return {
+                next: function () {
+                    if (o && i >= o.length)
+                        o = void 0;
+                    return { value: o && o[i++], done: !o };
+                }
+            };
+        throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+    }
+    function __read(o, n) {
+        var m = typeof Symbol === "function" && o[Symbol.iterator];
+        if (!m)
+            return o;
+        var i = m.call(o), r, ar = [], e;
+        try {
+            while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
+                ar.push(r.value);
+        }
+        catch (error) {
+            e = { error: error };
+        }
+        finally {
+            try {
+                if (r && !r.done && (m = i["return"]))
+                    m.call(i);
+            }
+            finally {
+                if (e)
+                    throw e.error;
+            }
+        }
+        return ar;
+    }
+    /** @deprecated */
+    function __spread() {
+        for (var ar = [], i = 0; i < arguments.length; i++)
+            ar = ar.concat(__read(arguments[i]));
+        return ar;
+    }
+    /** @deprecated */
+    function __spreadArrays() {
+        for (var s = 0, i = 0, il = arguments.length; i < il; i++)
+            s += arguments[i].length;
+        for (var r = Array(s), k = 0, i = 0; i < il; i++)
+            for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+                r[k] = a[j];
+        return r;
+    }
+    function __spreadArray(to, from) {
+        for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+            to[j] = from[i];
+        return to;
+    }
+    function __await(v) {
+        return this instanceof __await ? (this.v = v, this) : new __await(v);
+    }
+    function __asyncGenerator(thisArg, _arguments, generator) {
+        if (!Symbol.asyncIterator)
+            throw new TypeError("Symbol.asyncIterator is not defined.");
+        var g = generator.apply(thisArg, _arguments || []), i, q = [];
+        return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+        function verb(n) { if (g[n])
+            i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+        function resume(n, v) { try {
+            step(g[n](v));
+        }
+        catch (e) {
+            settle(q[0][3], e);
+        } }
+        function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+        function fulfill(value) { resume("next", value); }
+        function reject(value) { resume("throw", value); }
+        function settle(f, v) { if (f(v), q.shift(), q.length)
+            resume(q[0][0], q[0][1]); }
+    }
+    function __asyncDelegator(o) {
+        var i, p;
+        return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
+        function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
+    }
+    function __asyncValues(o) {
+        if (!Symbol.asyncIterator)
+            throw new TypeError("Symbol.asyncIterator is not defined.");
+        var m = o[Symbol.asyncIterator], i;
+        return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+        function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+        function settle(resolve, reject, d, v) { Promise.resolve(v).then(function (v) { resolve({ value: v, done: d }); }, reject); }
+    }
+    function __makeTemplateObject(cooked, raw) {
+        if (Object.defineProperty) {
+            Object.defineProperty(cooked, "raw", { value: raw });
+        }
+        else {
+            cooked.raw = raw;
+        }
+        return cooked;
+    }
+    ;
+    var __setModuleDefault = Object.create ? (function (o, v) {
+        Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function (o, v) {
+        o["default"] = v;
+    };
+    function __importStar(mod) {
+        if (mod && mod.__esModule)
+            return mod;
+        var result = {};
+        if (mod != null)
+            for (var k in mod)
+                if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+                    __createBinding(result, mod, k);
+        __setModuleDefault(result, mod);
+        return result;
+    }
+    function __importDefault(mod) {
+        return (mod && mod.__esModule) ? mod : { default: mod };
+    }
+    function __classPrivateFieldGet(receiver, state, kind, f) {
+        if (kind === "a" && !f)
+            throw new TypeError("Private accessor was defined without a getter");
+        if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
+            throw new TypeError("Cannot read private member from an object whose class did not declare it");
+        return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+    }
+    function __classPrivateFieldSet(receiver, state, value, kind, f) {
+        if (kind === "m")
+            throw new TypeError("Private method is not writable");
+        if (kind === "a" && !f)
+            throw new TypeError("Private accessor was defined without a setter");
+        if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
+            throw new TypeError("Cannot write private member to an object whose class did not declare it");
+        return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+    }
+
+    /**
+     * Currency calculations. Undefined input of number is considered zero, just like null.
+     */
+    var CurrencyFunc = /** @class */ (function () {
+        function CurrencyFunc() {
+        }
+        /**
+         *
+         * @param num
+         * @param decimalPlaces default 0
+         */
+        CurrencyFunc.bankerRound = function (num, decimalPlaces) {
+            if (!num) {
+                return 0;
+            }
+            var d = decimalPlaces || 0;
+            var m = Math.pow(10, d);
+            var n = +(d ? num * m : num).toFixed(8); // Avoid rounding errors
+            var i = Math.floor(n), f = n - i;
+            var e = 1e-8; // Allow for rounding errors in f
+            var r = (f > 0.5 - e && f < 0.5 + e) ?
+                ((i % 2 === 0) ? i : i + 1) : Math.round(n);
+            return d ? r / m : r;
+        };
+        CurrencyFunc.bankerRoundTo5cents = function (num) {
+            if (!num) {
+                return 0;
+            }
+            var r = this.bankerRound(Math.ceil(num * 20 - 0.5) / 20, 2);
+            return r;
+        };
+        CurrencyFunc.ceilTo5cents = function (num) {
+            if (!num) {
+                return 0;
+            }
+            var r = this.bankerRound(Math.ceil(num * 20) / 20, 4);
+            var roundup = Math.ceil(r * 10000) / 10000;
+            return roundup;
+        };
+        CurrencyFunc.transformCurrency = function (value, fractionSize) {
+            if (fractionSize === void 0) { fractionSize = 2; }
+            var _a = __read((value || '').toString()
+                .split(this.DECIMAL_SEPARATOR), 2), integer = _a[0], _b = _a[1], fraction = _b === void 0 ? '' : _b;
+            fraction = fractionSize > 0
+                ? this.DECIMAL_SEPARATOR + (fraction + this.PADDING).substring(0, fractionSize)
+                : '';
+            integer = integer.replace(/\B(?=(\d{3})+(?!\d))/g, this.THOUSANDS_SEPARATOR);
+            return integer + fraction;
+        };
+        CurrencyFunc.parseCurrency = function (value, fractionSize) {
+            if (fractionSize === void 0) { fractionSize = 2; }
+            var _a = __read((value || '').split(this.DECIMAL_SEPARATOR), 2), integer = _a[0], _b = _a[1], fraction = _b === void 0 ? '' : _b;
+            integer = integer.replace(new RegExp(this.THOUSANDS_SEPARATOR, 'g'), '');
+            fraction = parseInt(fraction, 10) > 0 && fractionSize > 0
+                ? this.DECIMAL_SEPARATOR + (fraction + this.PADDING).substring(0, fractionSize)
+                : '';
+            return integer + fraction;
+        };
+        //http://stackoverflow.com/questions/2998784/how-to-output-integers-with-leading-zeros-in-javascript
+        CurrencyFunc.pad = function (num, size) {
+            num = null;
+            var s = num + '';
+            while (s.length < size) {
+                s = '0' + s;
+            }
+            return s;
+        };
+        CurrencyFunc.sum = function (ns) {
+            var r = ns.reduce(function (a, b) { return (a !== null && a !== void 0 ? a : 0) + (b !== null && b !== void 0 ? b : 0); }, 0);
+            return r;
+        };
+        return CurrencyFunc;
+    }());
+    CurrencyFunc.DECIMAL_SEPARATOR = '.';
+    CurrencyFunc.THOUSANDS_SEPARATOR = ',';
+    CurrencyFunc.PADDING = '000000';
+
+    var DateFunc = /** @class */ (function () {
+        function DateFunc() {
+        }
+        /**
+         * Transform UTC DateTime to local date without H, M and S. For example, the month day of 2018-01-23T22:00:00Z is 24 in Australia.
+         * @param dtUtc
+         * @param offsetMinutes if not defined, it will be new Date().getTimezoneOffset(). //https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getTimezoneOffset
+         */
+        DateFunc.dateTimeUtcToLocalDateNumber = function (dtUtc) {
+            if (!dtUtc) {
+                return 0; //0 is better for calculation by the clients.
+            }
+            var localDt = DateFunc.dateTimeUtcToLocalDateTime(dtUtc);
+            var localDNum = localDt.setHours(0, 0, 0, 0);
+            return localDNum;
+        };
+        /**
+         * Date only. However, the date may still be in UTC.
+         * @param dtUtc
+         */
+        DateFunc.dateTimeUtcToLocalDate = function (dtUtc) {
+            var localDt = DateFunc.dateTimeUtcToLocalDateTime(dtUtc);
+            var localD = localDt.setHours(0, 0, 0, 0);
+            return new Date(localD);
+        };
+        DateFunc.localISODateString = function (dtUtc) {
+            var dt = moment__default['default'](dtUtc).local();
+            return dt.format('YYYY-MM-DD');
+        };
+        /**
+         * locate date ONLY (no time) to UTC date.
+         * @param dt if dt contain time info, it will become dt.setHours(0, 0, 0, 0)
+         */
+        DateFunc.localDateToUtc = function (d) {
+            var dt = moment__default['default'](d).toDate();
+            var n = dt.setHours(0, 0, 0, 0);
+            var offset = dt.getTimezoneOffset() * 60000;
+            return new Date(n + offset);
+        };
+        DateFunc.getTimezoneOffset = function () {
+            var dt = this.today;
+            return dt.getTimezoneOffset();
+        };
+        /**
+         * Transform UTC DateTime to local dateTime.
+         * @param dtUtc
+         * @param offsetMinutes if not defined, it will be new Date().getTimezoneOffset(). //https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getTimezoneOffset
+         */
+        DateFunc.dateTimeUtcToLocalDateTime = function (dtUtc) {
+            var stillUtc = moment__default['default'].utc(dtUtc).toDate();
+            return moment__default['default'](stillUtc).local().toDate();
+        };
+        DateFunc.dateTimeUtcToLocaMoment = function (dtUtc) {
+            var stillUtc = moment__default['default'].utc(dtUtc);
+            return stillUtc.local();
+        };
+        DateFunc.getEndOfWeek = function (dt) {
+            return moment__default['default'](dt).endOf('isoWeek').toDate();
+        };
+        DateFunc.getStartOfWeek = function (dt) {
+            return moment__default['default'](dt).startOf('isoWeek').toDate();
+        };
+        DateFunc.getEndOfMonth = function (dt) {
+            //  return new Date(dt.getFullYear(), dt.getMonth() + 1, 0, 23, 59, 59, 999);
+            return moment__default['default'](dt).endOf('month').toDate();
+        };
+        DateFunc.getStartOfMonth = function (dt) {
+            return moment__default['default'](dt).startOf('month').toDate();
+        };
+        DateFunc.getDaysBetweenDates = function (dt1, dt2) {
+            return this.getDaysBetween(dt1, dt2);
+        };
+        DateFunc.getEndOfDate = function (dt) {
+            return dt ? new Date(dt.setHours(23, 59, 59, 999)) :
+                new Date(this.now.setHours(23, 59, 59, 999));
+        };
+        DateFunc.getStartOfDate = function (dt) {
+            return moment__default['default'](dt).startOf('day').toDate();
+        };
+        DateFunc.getEndOfToday = function () {
+            //	return new Date((new Date(Date.now())).setHours(23, 59, 59, 999));
+            return moment__default['default'](Date.now()).endOf('day').toDate();
+        };
+        DateFunc.getStartOfToday = function () {
+            //	return new Date((new Date(Date.now())).setHours(0, 0, 0, 0));
+            return moment__default['default'](Date.now()).startOf('day').toDate();
+        };
+        //inspired https://stackoverflow.com/questions/563406/add-days-to-javascript-date
+        DateFunc.addDays = function (dt, days) {
+            if (days === void 0) { days = 0; }
+            var dat = moment__default['default'](dt);
+            dat.add(days, 'days');
+            return dat.toDate();
+        };
+        DateFunc.subtractDays = function (dt, days) {
+            if (days === void 0) { days = 0; }
+            var dat = moment__default['default'](dt);
+            dat.subtract(days, 'days');
+            return dat.toDate();
+        };
+        Object.defineProperty(DateFunc, "today", {
+            /**
+             * Start of today
+             */
+            get: function () {
+                return this.getStartOfToday();
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(DateFunc, "now", {
+            get: function () {
+                return new Date(Date.now());
+            },
+            enumerable: false,
+            configurable: true
+        });
+        DateFunc.getNext5MinuteMark = function () {
+            var m = moment__default['default']().set('second', 0).set('millisecond', 0);
+            var minute = m.minute();
+            var mod = minute % 5;
+            if (mod) {
+                var delta = 5 - mod;
+                return m.add(delta, 'm').toDate();
+            }
+            return m.toDate();
+        };
+        DateFunc.getYMD = function (d) {
+            return moment__default['default'](d).format('YYYYMMDD');
+        };
+        DateFunc.getDMYWithSlash = function (d) {
+            return moment__default['default'](d).format('DD/MM/YYYY');
+        };
+        DateFunc.getDMYHmWithSlash = function (d) {
+            return moment__default['default'](d).format('DD/MM/YYYY HH:mm');
+        };
+        DateFunc.getMcpTime = function (dt) {
+            return moment__default['default'](dt).format('HH:mm:ss.SSSZ');
+        };
+        /**
+         * In 24 hour format
+         * @param dtUtc
+         */
+        DateFunc.getLocalDMYHmWithSlash = function (dtUtc) {
+            var d = DateFunc.dateTimeUtcToLocalDateTime(dtUtc);
+            return moment__default['default'](d).format('DD/MM/YYYY HH:mm');
+        };
+        /**
+         * Offset minutes comparing with today
+         */
+        DateFunc.getOffsetMinutes = function (dtUtc) {
+            var dm1 = moment__default['default'](dtUtc);
+            var dm2 = moment__default['default'](new Date().setHours(0, 0, 0, 0));
+            return dm1.diff(dm2, 'minutes');
+        };
+        DateFunc.getDaysBetween = function (d1, d2) {
+            var dm1 = moment__default['default'](d1);
+            var dm2 = moment__default['default'](d2);
+            return dm2.diff(dm1, 'days');
+        };
+        /**
+         * Get hour of the date. If Date is not defined, the hour will be current hour.
+         * @param dtUtc
+         */
+        DateFunc.getHour = function (dtUtc) {
+            var m = moment__default['default'](dtUtc);
+            return m.hours();
+        };
+        DateFunc.getMinute = function (dtUtc) {
+            var m = moment__default['default'](dtUtc);
+            return m.minutes();
+        };
+        DateFunc.composeDateTime = function (dt, h, minute) {
+            if (h === void 0) { h = 0; }
+            if (minute === void 0) { minute = 0; }
+            var mt = moment__default['default'](dt);
+            return new Date(mt.toDate().setHours(h, minute, 0, 0));
+        };
+        DateFunc.olderThan24Hours = function (d) {
+            var m = moment__default['default'](d);
+            return moment__default['default']().diff(m, 'hours') >= 24;
+        };
+        DateFunc.olderThan24HoursUtc = function (dtUtc) {
+            return DateFunc.getHourAgeUtc(dtUtc) >= 24;
+        };
+        DateFunc.olderThanHours = function (d, hours) {
+            var m = moment__default['default'](d);
+            return moment__default['default']().diff(m, 'hours') >= hours;
+        };
+        DateFunc.olderThanHoursUtc = function (dtUtc, hours) {
+            return DateFunc.getHourAgeUtc(dtUtc) >= hours;
+        };
+        DateFunc.olderThanMinutes = function (d, minutes) {
+            var m = moment__default['default'](d);
+            return moment__default['default']().diff(m, 'minutes') >= minutes;
+        };
+        /**
+         * It could be 11PM yesterday, and 1 AM today. Actually based on local today.
+         */
+        DateFunc.olderThan1Day = function (dtUtc) {
+            return DateFunc.getDayAgeUtc(dtUtc) > 0;
+        };
+        DateFunc.getHourAge = function (d) {
+            var m = moment__default['default'](d);
+            return moment__default['default']().diff(m, 'hours');
+        };
+        DateFunc.getHourAgeUtc = function (dtUtc) {
+            var m = moment__default['default'].utc(dtUtc);
+            return moment__default['default'].utc().diff(m, 'hours');
+        };
+        /**
+         * Compare utc date with utc now.
+         * @param dtUtc
+         */
+        DateFunc.getDayAgeUtc = function (dtUtc) {
+            var m = moment__default['default'].utc(dtUtc);
+            return moment__default['default'].utc().diff(m, 'days');
+        };
+        /**
+         * How many years from now.
+         * @param d
+         * @returns
+         */
+        DateFunc.getAge = function (d) {
+            var m = moment__default['default'](d);
+            return moment__default['default']().diff(m, 'years');
+        };
+        /**
+         * Year of date.
+         * @param d
+         * @returns
+         */
+        DateFunc.getYear = function (d) {
+            var m = moment__default['default'](d);
+            return m.year();
+        };
+        DateFunc.getUtcNow = function () {
+            return moment__default['default'].utc().toDate();
+        };
+        DateFunc.addMinutes = function (d, m) {
+            return moment__default['default'](d).add(m, 'm').toDate();
+        };
+        DateFunc.addMonth = function (d, m) {
+            return moment__default['default'](d).add(m, 'M').toDate();
+        };
+        DateFunc.getDuration = function (d1, d2) {
+            var md1 = moment__default['default'](d1);
+            var md2 = moment__default['default'](d2);
+            return moment__default['default'].duration(md2.diff(md1));
+        };
+        /**
+         * Convert minutes from midnight to HH:mm text
+         * @param mins
+         */
+        DateFunc.getHMFromMins = function (mins) {
+            // do not include the first validation check if you want, for example,
+            // getTimeFromMins(1530) to equal getTimeFromMins(90) (i.e. mins rollover)
+            if (mins >= 24 * 60 || mins < 0) {
+                throw new RangeError('Valid input should be greater than or equal to 0 and less than 1440.');
+            }
+            var h = mins / 60 | 0, m = mins % 60 | 0;
+            return moment__default['default'].utc().hours(h).minutes(m).format('HH:mm');
+        };
+        DateFunc.getMinutesSinceMidnight = function (d) {
+            var m = moment__default['default'](d);
+            var midnight = moment__default['default'](d).startOf('day'); //Mutates the original moment by setting it to the start of a unit of time. So I have better not to use m which wil be changed by calling this function
+            return m.diff(midnight, 'minutes');
+        };
+        DateFunc.getMinutesBetween = function (start, end) {
+            var m = moment__default['default'](start);
+            var m2 = moment__default['default'](end);
+            return m2.diff(m, 'minutes');
+        };
+        /**
+         * Parse json string with date serialized into string, and get proper date object back
+         * @param s
+         */
+        DateFunc.dateSafeJsonParse = function (s) {
+            return JSON.parse(s, this.dateReviver);
+        };
+        DateFunc.dateReviver = function (key, value) {
+            if (DateFunc.isSerializedDate(value)) {
+                return (new Date(value));
+            }
+            // If it's not a date-string, we want to return the value as-is. If we fail to return
+            // a value, it will be omitted from the resultant data structure.
+            return (value);
+        };
+        // I determine if the given value is a string that matches the serialized-date pattern.
+        DateFunc.isSerializedDate = function (value) {
+            // Dates are serialized in TZ format, example: '1981-12-20T04:00:14.000Z'.
+            var datePattern = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+            return (DateFunc.isString(value) && datePattern.test(value));
+        };
+        // I determine if the given value is a String.
+        DateFunc.isString = function (value) {
+            return ({}.toString.call(value) === '[object String]');
+        };
+        DateFunc.dateSafeParse = function (s) {
+            var m = moment__default['default'](s);
+            return m.toDate();
+        };
+        DateFunc.composeDateWithMinutes = function (d, minute) {
+            var m = moment__default['default'](d);
+            var midnight = moment__default['default'](d).startOf('day'); // Mutates the original moment by setting it to the start of a unit of time. So I have better not to use m which wil be changed by calling this function
+            midnight.add(minute, 'minutes');
+            return midnight.toDate();
+        };
+        /**
+         * Safe compare since date data may be considered as string rather than date.
+         * @param d1
+         * @param d2
+         */
+        DateFunc.compare = function (d1, d2) {
+            if (!d1 && !d2) {
+                return 0;
+            }
+            if (!d1) {
+                return -NaN;
+            }
+            if (!d2) {
+                return NaN;
+            }
+            var dd1 = (new Date(d1)).valueOf();
+            var dd2 = (new Date(d2)).valueOf();
+            return dd1 - dd2;
+        };
+        return DateFunc;
+    }());
+
+    var HtmlPrintFunc = /** @class */ (function () {
+        function HtmlPrintFunc() {
+        }
+        /**
+         * Print with CSS for internal reports
+         * @param htmlTags
+         * @param cssUrl
+         */
+        HtmlPrintFunc.printWithCSS = function (htmlTags, cssUrl) {
+            if (window) {
+                var htmlToPrint = "<html><head>\n<meta name=\"viewport\" content=\"width=device-width, initial-scale=1, shrink-to-fit=no\"/>\n<link rel=\"stylesheet\" type=\"text/css\" href=\"" + cssUrl + "\" media=\"screen,print\"/>\n</head><body onload=\"window.print()\">" + htmlTags + "</body></html>";
+                var popup = window.open('', '_blank', 'width=1024,height=768');
+                popup === null || popup === void 0 ? void 0 : popup.document.open();
+                popup === null || popup === void 0 ? void 0 : popup.document.write(htmlToPrint);
+                popup === null || popup === void 0 ? void 0 : popup.document.close();
+            }
+            return true;
+        };
+        /**
+         * Print for external documents.
+         * @param htmlTags
+         */
+        HtmlPrintFunc.print = function (htmlTags) {
+            if (window) {
+                var htmlToPrint = "<html><head>\n<meta name=\"viewport\" content=\"width=device-width, initial-scale=1, shrink-to-fit=no\"/>\n</head><body onload=\"window.print()\">" + htmlTags + "</body></html>";
+                var popup = window.open('', '_blank', 'width=1024,height=768');
+                popup === null || popup === void 0 ? void 0 : popup.document.open();
+                popup === null || popup === void 0 ? void 0 : popup.document.write(htmlToPrint);
+                popup === null || popup === void 0 ? void 0 : popup.document.close();
+            }
+            return true;
+        };
+        /**
+         * Print image url through html img.
+         * @param url
+         */
+        HtmlPrintFunc.printImage = function (url) {
+            var imageTags = "<img src=\"" + url + "\" alt=\"Image from URL\"/>";
+            HtmlPrintFunc.print(imageTags);
+        };
+        return HtmlPrintFunc;
+    }());
+
+    var JavaScriptFunc = /** @class */ (function () {
+        function JavaScriptFunc() {
+        }
+        /**
+         * Some business functions depend on external JavaScript libraries. Lazy loading of respective business modules is good,
+         * and this function supports lazy loading of JS libraries.
+         * @param scriptUrl
+         * @returns Promise for subsequent JS function calls.
+         */
+        JavaScriptFunc.loadExternalScript = function (scriptUrl) {
+            return new Promise(function (resolve, reject) {
+                var scriptElement = document.createElement('script');
+                scriptElement.src = scriptUrl;
+                scriptElement.onload = resolve;
+                document.body.appendChild(scriptElement);
+            });
+        };
+        return JavaScriptFunc;
+    }());
+
+    /**
+     * Basic JSON functions
+     */
+    var JsonFunc = /** @class */ (function () {
+        function JsonFunc() {
+        }
+        /**
+         *
+         * @param array Group by a property of array element.
+         * @param propertyName
+         * @returns
+         */
+        JsonFunc.groupBy = function (array, propertyName) {
+            return array.reduce(function (acc, obj) {
+                var key = obj[propertyName];
+                if (!acc[key]) {
+                    acc[key] = [];
+                }
+                acc[key].push(obj);
+                return acc;
+            }, {});
+        };
+        /**
+         * Group by a date property. The key is always of string type and representing milliseconds.
+         * The client should convert the string to number.
+         * Angular date pipe could actually consume such string without explicitly converting to number.
+         * @param array
+         * @param propertyName
+         */
+        JsonFunc.groupByDate = function (array, propertyName) {
+            return array.reduce(function (acc, obj) {
+                var key = DateFunc.dateTimeUtcToLocalDateNumber(obj[propertyName]);
+                if (!acc[key]) {
+                    acc[key] = [];
+                }
+                acc[key].push(obj);
+                return acc;
+            }, {});
+        };
+        /**
+         * Remove null or empty fields including those in nested objects.
+         * This is useful for reducing payload of AJAX serialization.
+         * @param obj
+         */
+        JsonFunc.removeNullOrEmptyFields = function (obj) {
+            for (var f in obj) {
+                var p = obj[f];
+                if (p === null || p === '') {
+                    delete obj[f];
+                }
+                else if (typeof p === 'object' && p !== null) {
+                    this.removeNullOrEmptyFields(p);
+                }
+            }
+        };
+        /**
+         *
+         * @param obj Remove null fields of object at only the 1st level.
+         */
+        JsonFunc.removeNullFields = function (obj) {
+            for (var f in obj) {
+                if (obj[f] === null) {
+                    delete obj[f];
+                }
+            }
+        };
+        return JsonFunc;
+    }());
+
+    /**
+     * String functions specific to Australia
+     */
+    var StringAusFunc = /** @class */ (function () {
+        function StringAusFunc() {
+        }
+        /**
+         * Validate medicare number
+         * @param n
+         * @returns validation error message
+         */
+        StringAusFunc.validateMedicare = function (n) {
+            if (!n) {
+                return null;
+            }
+            if (n && n.length === 10) {
+                var matches = n.match(/^(\d{8})(\d)/);
+                if (!matches) {
+                    return {
+                        code: 2, message: 'Medicare number should be all digit.'
+                    };
+                }
+                var base = matches[1];
+                var checkDigit = matches[2];
+                var weights = [1, 3, 7, 9, 1, 3, 7, 9];
+                var sum = 0;
+                for (var i = 0; i < weights.length; i++) {
+                    sum += parseInt(base[i], 10) * weights[i];
+                }
+                //console.debug(`sum: ${sum}  checkDigits: ${checkDigit}`);
+                var isValid = sum % 10 === parseInt(checkDigit, 10);
+                if (!isValid) {
+                    return {
+                        code: 3, message: 'Checksum is incorrect.'
+                    };
+                }
+            }
+            else {
+                return { code: 1, message: 'Length should be 10.' };
+            }
+            return null;
+        };
+        StringAusFunc.validateMedicareProviderNumber = function (providerNumber) {
+            if (!providerNumber) {
+                return null;
+            }
+            if (!/^[0-9]{6}[0-9ABCDEFGHJKLMNPQRTUVWXY][ABFHJKLTWXY]/.test(providerNumber)) {
+                return { code: 1, message: 'Not matching provider number format.' };
+            }
+            var practiceLocationValues = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'N', 'P', 'Q', 'R', 'T', 'U', 'V', 'W', 'X', 'Y'];
+            var remainderValues = ['Y', 'X', 'W', 'T', 'L', 'K', 'J', 'H', 'F', 'B', 'A'];
+            var stemWeights = [3, 5, 8, 4, 2, 1];
+            var stemNumbers = providerNumber.substr(0, 6).split('').map(function (char) { return parseInt(char); });
+            var practiceLoc = practiceLocationValues.findIndex(function (e) { return e === providerNumber[6]; });
+            var checksum = providerNumber[7];
+            var zipped = stemWeights.map(function (x, i) { return [x, stemNumbers[i]]; });
+            var sumWeights = zipped.map(function (y) { return y[1] * y[0]; }).reduce(function (total, num) { return total + num; });
+            var remainder = (sumWeights + practiceLoc * 6) % 11;
+            var result = remainderValues[remainder];
+            var valid = result === checksum;
+            if (!valid) {
+                return { code: 2, message: 'Checksum is incorrect.' };
+            }
+            return null;
+        };
+        StringAusFunc.validateDVAFileNumber = function (dva) {
+            if (!dva) {
+                return null;
+            }
+            var states = ['N', 'V', 'Q', 'S', 'W', 'T'];
+            var warCodes = [' ', 'X', 'KM', 'SR', 'SS', 'SM', 'SWP', 'AGX', 'BW', 'GW', 'CGW',
+                'P', 'PX', 'PAD', 'PAM', 'PCA', 'PCR', 'PCV', 'PMS', 'PSW', 'PWO', 'HKX', 'MAL',
+                'CN', 'CNX', 'IV', 'NF', 'NG', 'RD', 'RDX', 'SA', 'SAX', 'A',
+                'N', 'NX', 'NSW', 'NSM',
+                'BUR', 'CNK', 'CNS', 'FIJ', 'GHA', 'HKS', 'IND', 'KYA', 'MAU', 'MLS', 'MTX', 'MWI', 'NK', 'NGR', 'NRD', 'NSS', 'PK']; //British Commonwealth Countries - SP Eligibility
+            if (!states.includes(dva.charAt(0))) {
+                return { code: 1, message: 'State incorrect.' };
+            }
+            var ns = dva.match(/\d+/);
+            if (!ns) {
+                return { code: 2, message: 'No number.' };
+            }
+            var n = ns[0];
+            var idxOfN = dva.indexOf(n);
+            var warCode = dva.substring(1, idxOfN);
+            if (!warCodes.includes(warCode)) {
+                return { code: 3, message: 'War code invalid.' };
+            }
+            var lenOfN = n.length;
+            var lenOfWc = warCode.length;
+            if (lenOfN + lenOfWc > 7) {
+                return { code: 4, message: 'File number length should not be greater 7.' };
+            }
+            return null;
+        };
+        StringAusFunc.validateTFN = function (n) {
+            if (!n) {
+                return null;
+            }
+            var tfn = n.replace(/\s+/g, '').replace(/[-]/g, '');
+            var isNumber = /^[0-9]+$/.test(tfn);
+            if (!isNumber) {
+                return { code: 1, message: 'Invalid TFN, only numbers are allowed.' };
+            }
+            var length = tfn.length;
+            if (length !== 9) {
+                return {
+                    code: 2, message: 'Invalid TFN, must have 9 digits.'
+                };
+            }
+            var digits = tfn.split('').map(function (d) { return parseInt(d); });
+            var sum = (digits[0] * 1)
+                + (digits[1] * 4)
+                + (digits[2] * 3)
+                + (digits[3] * 7)
+                + (digits[4] * 5)
+                + (digits[5] * 8)
+                + (digits[6] * 6)
+                + (digits[7] * 9)
+                + (digits[8] * 10);
+            var remainder = sum % 11;
+            var valid = remainder === 0;
+            if (!valid) {
+                return { code: 3, message: 'Checksum is incorrect.' };
+            }
+            return null;
+        };
+        StringAusFunc.addWeighted = function (p, v, i) {
+            return p + v * StringAusFunc.weights[i];
+        };
+        StringAusFunc.addAcnWeighted = function (p, v, i) {
+            return p + v * StringAusFunc.acnWeights[i];
+        };
+        StringAusFunc.generateLookup = function () {
+            var ns = [];
+            for (var i = 0; i < 10; ++i) {
+                ns[i * 19 % 89] = i;
+            }
+            return ns;
+        };
+        StringAusFunc.validateABN = function (abn) {
+            if (!abn) {
+                return null;
+            }
+            var digits = abn.replace(/[^\d]/g, '').split('').map(Number);
+            if (digits.length !== 11) {
+                return { code: 1, message: 'Expect 11-digit.' };
+            }
+            digits[0] -= 1;
+            var sum = digits.reduce(StringAusFunc.addWeighted, 0);
+            if (sum % 89 === 0) {
+                return null;
+            }
+            digits[0] += 1;
+            var sum1 = sum - digits[10] * StringAusFunc.weights[10];
+            var digit = StringAusFunc.suggestLookup[89 - sum1 % 89];
+            if (digit !== undefined) {
+                return {
+                    code: 2,
+                    message: 'Checksum1 is incorrect.'
+                };
+            }
+            else {
+                var sum2 = sum1 - digits[9] * StringAusFunc.weights[9];
+                for (var i = 0; i < 10; ++i) {
+                    sum1 = sum2 + i * StringAusFunc.weights[9];
+                    digit = StringAusFunc.suggestLookup[89 - sum1 % 89];
+                    if (digit !== undefined) {
+                        return {
+                            code: 3,
+                            message: 'Checksum2 is incorrect.'
+                        };
+                    }
+                }
+            }
+            return null;
+        };
+        StringAusFunc.validateACN = function (acn) {
+            if (!acn) {
+                return null;
+            }
+            var digits = acn.replace(/[^\d]/g, '').split('').map(Number);
+            console.log(digits);
+            if (digits.length !== 9) {
+                return { code: 1, message: 'Expect 9-digit.' };
+            }
+            var sum = digits.slice(0, 8).reduce(StringAusFunc.addAcnWeighted, 0);
+            var lastDigit = 10 - sum % 10;
+            if (lastDigit === digits[8]) {
+                return null;
+            }
+            return {
+                code: 2,
+                message: 'Checksum is incorrect.'
+            };
+        };
+        return StringAusFunc;
+    }());
+    //thanks to https://github.com/sidorares/australian-business-number/blob/0591475f5978fd122b472edcdc7efe6d96d56f26/index.js
+    StringAusFunc.acnWeights = [8, 7, 6, 5, 4, 3, 2, 1];
+    StringAusFunc.weights = [10, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19];
+    StringAusFunc.suggestLookup = StringAusFunc.generateLookup();
+
+    var StringFunc = /** @class */ (function () {
+        function StringFunc() {
+        }
+        /**
+         * Up to 2 letters. For John Smith, returns JS, for Huang, Zijian, returns ZH
+         * @param s
+         */
+        StringFunc.getAbbr = function (s) {
+            if (!s) {
+                return '';
+            }
+            var sArray = s.split(/[\s,]+/);
+            var comma = s.indexOf(',') >= 0;
+            if (sArray.length === 1) {
+                return sArray[0][0];
+            }
+            return comma ? sArray[1][0] + sArray[0][0] : sArray[0][0] + sArray[1][0];
+        };
+        /**
+         * A substring with line breaks replaced by space.
+         * @param s
+         * @param length
+         * @returns result, or empty string if the input is empty, null or undefined
+         */
+        StringFunc.getOneLineDigest = function (s, length) {
+            if (!s) {
+                return '';
+            }
+            var ss = s.substring(0, length);
+            var st = ss.replace(new RegExp('\n', 'g'), ' ') + ((s.length > length) ? '...' : '');
+            return st.trim();
+        };
+        /**
+         * Remove line breaks and econde with encodeURI() so the data could be saved in Azure as meta. If the string is truncated, the return will have ... suffix.
+         * @param s
+         * @param length
+         * @returns result, or empty string if the input is empty, null or undefined
+         */
+        StringFunc.getOneLineDigestOfHtml = function (s, length) {
+            if (!s) {
+                return '';
+            }
+            var ss = s.substring(0, length);
+            var st = ss.replace(new RegExp('\n', 'g'), ' ') + ((s.length > length) ? '...' : '');
+            return encodeURI(st.trim()); //need to encode in order to save as meta in Azure.
+        };
+        /**
+         * Pad number with zero
+         * @param num
+         * @param size
+         * @returns
+         */
+        StringFunc.pad = function (num, size) {
+            if (num == null) {
+                return '';
+            }
+            var s = num + '';
+            while (s.length < size) {
+                s = '0' + s;
+            }
+            return s;
+        };
+        /**
+         * get plain text of HTML content
+         * @param s
+         * @returns result. If input is empty, null, or undefined, return the same.
+         */
+        StringFunc.getHtmlPlainText = function (s) {
+            if (!s) {
+                return null;
+            }
+            var parser = new DOMParser();
+            var html = parser.parseFromString(s, 'text/html');
+            return html.body.textContent;
+        };
+        /**
+         *
+         * @param s
+         * @returns result. If input is empty, null, or undefined, return the same.
+         */
+        StringFunc.capitalizeWords = function (s) {
+            if (!s) {
+                return s;
+            }
+            return s.replace(/(?:^|\s)\S/g, function (a) { return a.toUpperCase(); });
+        };
+        StringFunc.validateEmail = function (email) {
+            if (!email) {
+                return true;
+            }
+            var re = /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
+            return re.test(email.toLowerCase());
+        };
+        return StringFunc;
+    }());
+
+    // import { v5 as uuid } from 'uuid/v5 causes ERROR in src / app / _func / helperFunc.ts(1, 10): error TS2305: Module '"C:/VSProjects/ApsCloudTrunk/APS.WebPos.NGCli/NGSource/node_modules/@types/uuid/v5"' has no exported member 'v5'
+    // https://github.com/DefinitelyTyped/DefinitelyTyped/pull/28439
+    var UuidFunc = /** @class */ (function () {
+        function UuidFunc() {
+        }
+        /**
+         * 36 UUID string including 4 hyphens. MySql stores GUID as 36 bytes anyway rather than 16bytes.
+         */
+        UuidFunc.newUUID = function () {
+            //		return uuid('medilink.com.au', 'apscloud');
+            return uuid.v4();
+        };
+        UuidFunc.newUUIDStartWith0 = function () {
+            var s = uuid.v4();
+            return '0000' + s.slice(4);
+        };
+        return UuidFunc;
+    }());
+
+    /*
+     * Public API Surface of nmce-func
+     */
+
+    /**
+     * Generated bundle index. Do not edit.
+     */
+
+    exports.AddressFunc = AddressFunc;
+    exports.AuthenticationService = AuthenticationService;
+    exports.CurrencyFunc = CurrencyFunc;
+    exports.DateFunc = DateFunc;
+    exports.HtmlPrintFunc = HtmlPrintFunc;
+    exports.JavaScriptFunc = JavaScriptFunc;
+    exports.JsonFunc = JsonFunc;
+    exports.StringAusFunc = StringAusFunc;
+    exports.StringFunc = StringFunc;
+    exports.UuidFunc = UuidFunc;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+})));
+//# sourceMappingURL=nmce-func.umd.js.map