@stemy/ngx-utils 13.2.4 → 13.3.0

package/fesm2020/stemy-ngx-utils.mjs

@@ -342,6 +342,7 @@ var StorageMode;
 })(StorageMode || (StorageMode = {}));
 const TOASTER_SERVICE = new InjectionToken("toaster-service");
 const PROMISE_SERVICE = new InjectionToken("promise-service");
+const WASI_IMPLEMENTATION = new InjectionToken("wasi-implementation");
 // --- Unordered list ---
 class UnorederedListTemplate extends TemplateRef {
 }
@@ -1174,6 +1175,51 @@ class Initializer {
     }
 }
 
+class JSONfn {
+    static parse(text) {
+        return JSON.parse(text, JSONfn.reviver);
+    }
+    static stringify(obj) {
+        return JSON.stringify(obj, JSONfn.replacer);
+    }
+    static reviver(key, value) {
+        const iso8061 = /^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d(?:.\d+)?(?:Z|[+-]\d\d:\d\d)$/;
+        if (typeof value !== "string")
+            return value;
+        if (value.length < 8) {
+            return value;
+        }
+        if (value.match(iso8061)) {
+            return new Date(value);
+        }
+        const prefix = value.substring(0, 8);
+        if (prefix === "function") {
+            return new Function(`return ${value}`)();
+        }
+        if (prefix === "_NuFrRa_") {
+            return new Function(`return ${value.slice(8)}`)();
+        }
+        if (prefix === "_PxEgEr_") {
+            return new Function(`return ${value.slice(8)}`)();
+        }
+        return value;
+    }
+    static replacer(key, value) {
+        if (value instanceof Function || typeof value === "function") {
+            const fnBody = value.toString();
+            if (fnBody.length < 8 || fnBody.substring(0, 8) !== "function") {
+                // this is ES6 Arrow Function
+                return "_NuFrRa_" + fnBody;
+            }
+            return fnBody;
+        }
+        if (value instanceof RegExp) {
+            return "_PxEgEr_" + value;
+        }
+        return value;
+    }
+}
+
 class LoaderUtils {
     static loadScript(src, async = false) {
         this.scriptPromises[src] = this.scriptPromises[src] || new Promise((resolve, reject) => {
@@ -2061,81 +2107,103 @@ class Vector {
     }
 }
 
-const emptyGuards = [];
-class AclService {
-    constructor(injector, state, auth) {
-        this.injector = injector;
-        this.state = state;
-        this.auth = auth;
-        this.components = [];
-        this.auth.userChanged.subscribe(() => {
-            this.components.forEach(t => t.dirty = true);
-            const info = this.getStateInfo();
-            const check = info && info.guard instanceof AuthGuard ? info.guard.checkRoute(info.route) : Promise.resolve(true);
-            check.then(result => {
-                if (result) {
-                    if (!info || !info.dirty)
-                        return;
-                    info.dirty = false;
-                    const component = info.component;
-                    if (!info.component)
-                        return;
-                    if (info.first) {
-                        if (ObjectUtils.isFunction(component.onUserInitialized)) {
-                            component.onUserInitialized();
-                        }
-                        info.first = false;
-                        return;
+function workerFunction(JSONfn, logTimes) {
+    let wasmResolve = null;
+    const wasmInstance = new Promise(resolve => {
+        wasmResolve = resolve;
+    });
+    self.onmessage = function (e) {
+        const data = e.data;
+        const { type, payload } = data;
+        switch (type) {
+            case "wasm":
+                const { url, wasi } = payload;
+                fetch(url).then(response => response.arrayBuffer()).then(bytes => {
+                    const wasiImpl = JSONfn.parse(wasi);
+                    return new wasiImpl().instantiate(bytes);
+                }).then(instance => {
+                    wasmResolve(instance);
+                    const methods = Object.getOwnPropertyNames(instance).filter(key => typeof instance[key] === "function");
+                    self.postMessage({ type: "methods", payload: methods });
+                });
+                break;
+            case "call":
+                wasmInstance.then(instance => {
+                    const { name, id, args } = payload;
+                    if (logTimes) {
+                        console.time(id);
+                        console.timeLog(id, `Calling ${name} ...`);
                     }
-                    if (ObjectUtils.isFunction(component.onUserChanged)) {
-                        component.onUserChanged();
+                    const func = instance[name];
+                    const result = func(...args);
+                    if (logTimes) {
+                        console.timeLog(id, `Called ${name}`);
+                        console.timeEnd(id);
                     }
-                    return;
-                }
-                info.guard.getReturnState(info.route).then(returnState => {
-                    if (!returnState)
-                        return;
-                    this.state.navigate(returnState);
+                    self.postMessage({ type: "result", payload: { id, result } });
                 });
-            });
+                break;
+        }
+    };
+}
+class WasmWorkerProxy {
+    constructor(wasmPath, wasi, logTimes = false) {
+        this.methods = new Promise(resolve => {
+            this.onMethods = resolve;
         });
-        this.state.subscribe(() => {
-            const info = this.getStateInfo();
-            if (!info?.component)
-                return;
-            const component = info.component;
-            if (ObjectUtils.isFunction(component.onUserInitialized)) {
-                component.onUserInitialized();
+        const lt = logTimes ? "true" : "false";
+        const blob = new Blob([`${JSONfn.toString()} (${workerFunction.toString()})(JSONfn, ${lt})`], { type: 'application/javascript' });
+        this.worker = new Worker(URL.createObjectURL(blob));
+        this.worker.postMessage({
+            type: "wasm",
+            payload: { url: wasmPath, wasi: JSONfn.stringify(wasi), logTimes }
+        });
+        this.worker.onmessage = this.onMessage.bind(this);
+        this.promises = new Map();
+        return new Proxy(this, {
+            get: (target, prop, receiver) => {
+                const res = Reflect.get(target, prop, receiver);
+                if (res) {
+                    return res;
+                }
+                return (...args) => {
+                    return this.call(prop.toString(), args);
+                };
             }
         });
     }
-    getStateInfo() {
-        const route = this.state.route;
-        if (!route)
-            return null;
-        let info = this.components.find(t => t.route == this.state.route);
-        if (!info) {
-            const guardType = (route.canActivate || emptyGuards)[0];
-            info = {
-                route: this.state.route,
-                guard: guardType ? this.injector.get(guardType) : null,
-                dirty: true,
-                first: true
-            };
-            this.components.push(info);
+    onMessage(e) {
+        const data = e.data;
+        const { type, payload } = data;
+        switch (type) {
+            case "methods":
+                this.onMethods(payload);
+                break;
+            case "result":
+                const { id, result } = payload;
+                const promise = this.promises.get(id);
+                if (promise) {
+                    promise.resolve(result);
+                    this.promises.delete(id);
+                }
+                break;
         }
-        info.component = this.state.component;
-        return info;
     }
-}
-AclService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: AclService, deps: [{ token: i0.Injector }, { token: StateService }, { token: AUTH_SERVICE }], target: i0.ɵɵFactoryTarget.Injectable });
-AclService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: AclService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: AclService, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: i0.Injector }, { type: StateService }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: [AUTH_SERVICE]
-                }] }]; } });
+    async call(method, args) {
+        const methods = await this.methods;
+        if (!methods.includes(method)) {
+            throw new Error(`Method ${method} not found`);
+        }
+        return new Promise((resolve, reject) => {
+            const id = Math.random().toString(36).substring(2, 9);
+            this.worker.postMessage({
+                type: "call",
+                payload: { name: method, id, args }
+            });
+            this.promises.set(id, { resolve, reject });
+        });
+    }
+}
 
 class BaseHttpClient extends HttpClient {
     constructor(handler) {
@@ -2234,6 +2302,7 @@ class BaseHttpService {
         this.requestHeaders = {};
         this.requestParams = {};
         this.cache = {};
+        this.initService();
     }
     get name() {
         return "base";
@@ -2248,6 +2317,8 @@ class BaseHttpService {
     get universal() {
         return this.storage.universal;
     }
+    initService() {
+    }
     url(url) {
         return url;
     }
@@ -2510,6 +2581,164 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImpor
                     args: [EXPRESS_REQUEST]
                 }] }]; } });
 
+class LocalHttpService extends BaseHttpService {
+    get name() {
+        return "local-http";
+    }
+    get withCredentials() {
+        return false;
+    }
+    initService() {
+        this.images = {};
+    }
+    url(url) {
+        if (!url)
+            return url;
+        const config = this.configs.config;
+        const baseUrl = config.cdnUrl || config.baseUrl || "";
+        return url.startsWith("data:") || url.startsWith("http") || url.startsWith("//")
+            ? url
+            : `${baseUrl}${url}`;
+    }
+    get(url, options) {
+        this.cache[url] = this.cache[url] || this.getPromise(url, options);
+        return this.cache[url];
+    }
+    getImage(url) {
+        if (this.universal.isServer)
+            return Promise.resolve(null);
+        if (!url)
+            return Promise.resolve(new Image());
+        this.images[url] = this.images[url] || new Promise((resolve, reject) => {
+            const image = new Image();
+            image.crossOrigin = "Anonymous";
+            image.src = this.url(url);
+            image.onload = () => resolve(image);
+            image.onerror = reject;
+        });
+        return this.images[url];
+    }
+}
+LocalHttpService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: LocalHttpService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+LocalHttpService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: LocalHttpService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: LocalHttpService, decorators: [{
+            type: Injectable
+        }] });
+
+/**
+ * Use this service to load WebAssembly modules
+ */
+class WasmService {
+    constructor(universal, http, wasi) {
+        this.universal = universal;
+        this.http = http;
+        this.wasi = wasi.constructor;
+    }
+    async getModule(name) {
+        if (!this.universal.isBrowser || !name)
+            return null;
+        this.modules = this.modules || {};
+        this.modules[name] = this.modules[name] || this.http.get(`wasm/${name}.wasm`, {
+            responseType: "arraybuffer"
+        }).then(async (bytes) => {
+            const wasi = new this.wasi();
+            return await wasi.instantiate(bytes);
+        });
+        return this.modules[name];
+    }
+    getWorkerModule(name) {
+        if (!this.universal.isBrowser || !name)
+            return null;
+        this.workerModules = this.workerModules || {};
+        this.workerModules[name] = new WasmWorkerProxy(this.http.url(`wasm/${name}.wasm`), this.wasi);
+        return this.workerModules[name];
+    }
+}
+WasmService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: WasmService, deps: [{ token: UniversalService }, { token: LocalHttpService }, { token: WASI_IMPLEMENTATION }], target: i0.ɵɵFactoryTarget.Injectable });
+WasmService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: WasmService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: WasmService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: UniversalService }, { type: LocalHttpService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [WASI_IMPLEMENTATION]
+                }] }]; } });
+
+const emptyGuards = [];
+class AclService {
+    constructor(injector, state, auth) {
+        this.injector = injector;
+        this.state = state;
+        this.auth = auth;
+        this.components = [];
+        this.auth.userChanged.subscribe(() => {
+            this.components.forEach(t => t.dirty = true);
+            const info = this.getStateInfo();
+            const check = info && info.guard instanceof AuthGuard ? info.guard.checkRoute(info.route) : Promise.resolve(true);
+            check.then(result => {
+                if (result) {
+                    if (!info || !info.dirty)
+                        return;
+                    info.dirty = false;
+                    const component = info.component;
+                    if (!info.component)
+                        return;
+                    if (info.first) {
+                        if (ObjectUtils.isFunction(component.onUserInitialized)) {
+                            component.onUserInitialized();
+                        }
+                        info.first = false;
+                        return;
+                    }
+                    if (ObjectUtils.isFunction(component.onUserChanged)) {
+                        component.onUserChanged();
+                    }
+                    return;
+                }
+                info.guard.getReturnState(info.route).then(returnState => {
+                    if (!returnState)
+                        return;
+                    this.state.navigate(returnState);
+                });
+            });
+        });
+        this.state.subscribe(() => {
+            const info = this.getStateInfo();
+            if (!info?.component)
+                return;
+            const component = info.component;
+            if (ObjectUtils.isFunction(component.onUserInitialized)) {
+                component.onUserInitialized();
+            }
+        });
+    }
+    getStateInfo() {
+        const route = this.state.route;
+        if (!route)
+            return null;
+        let info = this.components.find(t => t.route == this.state.route);
+        if (!info) {
+            const guardType = (route.canActivate || emptyGuards)[0];
+            info = {
+                route: this.state.route,
+                guard: guardType ? this.injector.get(guardType) : null,
+                dirty: true,
+                first: true
+            };
+            this.components.push(info);
+        }
+        info.component = this.state.component;
+        return info;
+    }
+}
+AclService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: AclService, deps: [{ token: i0.Injector }, { token: StateService }, { token: AUTH_SERVICE }], target: i0.ɵɵFactoryTarget.Injectable });
+AclService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: AclService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: AclService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.Injector }, { type: StateService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [AUTH_SERVICE]
+                }] }]; } });
+
 class ApiService extends BaseHttpService {
     get name() {
         return "api";
@@ -5059,6 +5288,7 @@ const providers = [
     GlobalTemplateService,
     IconService,
     LanguageService,
+    LocalHttpService,
     OpenApiService,
     PromiseService,
     StateService,
@@ -5067,6 +5297,7 @@ const providers = [
     ConsoleToasterService,
     TranslatedUrlSerializer,
     UniversalService,
+    WasmService,
     DeviceDetectorService,
     {
         provide: EVENT_MANAGER_PLUGINS,
@@ -5091,6 +5322,163 @@ function loadConfig(config) {
     return config.load;
 }
 
+const WASI_ESUCCESS = 0;
+const WASI_EBADF = 8;
+const WASI_EINVAL = 28;
+const WASI_ENOSYS = 52;
+const WASI_STDOUT_FILENO = 1;
+const wasi_fns = [
+    "emscripten_notify_memory_growth",
+    "proc_exit",
+    "environ_get",
+    "environ_sizes_get",
+    "fd_close",
+    "fd_write",
+    "fd_read",
+    "fd_seek",
+];
+class Wasi {
+    constructor() {
+        this.env = {};
+        this.instantiated = false;
+        this.wasi = wasi_fns.reduce((res, key) => {
+            if (typeof this[key] === "function") {
+                res[key] = this[key].bind(this);
+            }
+            return res;
+        }, {});
+    }
+    instantiate(bytes) {
+        if (this.instantiated) {
+            throw new Error("WASI already instantiated");
+        }
+        this.instantiated = true;
+        return WebAssembly.instantiate(bytes, {
+            wasi_snapshot_preview1: this.wasi,
+            env: this.wasi
+        }).then(module => {
+            const exports = module.instance.exports;
+            this.wasm = {
+                ...exports,
+                writeArrayToMemory: (array) => {
+                    const bytes = array.length * array.BYTES_PER_ELEMENT;
+                    const pointer = exports.malloc(bytes);
+                    const ctr = array.constructor;
+                    const heapArray = new ctr(this.wasm.memory.buffer, pointer, array.length);
+                    heapArray.set(array);
+                    return pointer;
+                },
+                readArrayFromMemory: (pointer, array) => {
+                    const ctr = array.constructor;
+                    const heapArray = new ctr(this.wasm.memory.buffer, pointer, array.length);
+                    array.set(heapArray);
+                    return array;
+                }
+            };
+            this.updateMemoryViews();
+            return this.wasm;
+        });
+    }
+    updateMemoryViews() {
+        const buffer = this.wasm.memory.buffer;
+        this.wasm.HEAP8 = new Int8Array(buffer);
+        this.wasm.HEAP16 = new Int16Array(buffer);
+        this.wasm.HEAP32 = new Int32Array(buffer);
+        this.wasm.HEAPU8 = new Uint8Array(buffer);
+        this.wasm.HEAPU16 = new Uint16Array(buffer);
+        this.wasm.HEAPU32 = new Uint32Array(buffer);
+        this.wasm.HEAPF32 = new Float32Array(buffer);
+        this.wasm.HEAPF64 = new Float64Array(buffer);
+    }
+    getEnvStrings() {
+        if (!this.envStrings) {
+            let x;
+            const env = {};
+            for (x in this.env) {
+                if (this.env[x] === undefined)
+                    delete env[x];
+                else
+                    env[x] = this.env[x];
+            }
+            const strings = [];
+            for (x in env) {
+                strings.push(x + "=" + env[x]);
+            }
+            this.envStrings = strings;
+        }
+        return this.envStrings;
+    }
+    stringToAscii(str, buffer) {
+        const HEAP8 = this.wasm.HEAP8;
+        for (let i = 0; i < str.length; ++i) {
+            HEAP8[buffer++ >> 0] = str.charCodeAt(i);
+        }
+        HEAP8[buffer >> 0] = 0;
+    }
+    emscripten_notify_memory_growth(memoryIndex) {
+        this.updateMemoryViews();
+    }
+    proc_exit(rval) {
+        console.log("proc_exit", rval);
+    }
+    environ_get(environ, environ_buf) {
+        if (!this.wasm.HEAP8.byteLength) {
+            this.emscripten_notify_memory_growth(0);
+        }
+        const HEAPU32 = this.wasm.HEAPU32;
+        let bufSize = 0;
+        this.getEnvStrings().forEach((str, i) => {
+            const ptr = environ_buf + bufSize;
+            HEAPU32[environ + i * 4 >> 2] = ptr;
+            this.stringToAscii(str, ptr);
+            bufSize += str.length + 1;
+        });
+        return 0;
+    }
+    environ_sizes_get(penviron_count, penviron_buf_size) {
+        if (!this.wasm.HEAP8.byteLength) {
+            this.emscripten_notify_memory_growth(0);
+        }
+        const HEAPU32 = this.wasm.HEAPU32;
+        const strings = this.getEnvStrings();
+        HEAPU32[penviron_count >> 2] = strings.length;
+        let bufSize = 0;
+        strings.forEach(function (string) {
+            bufSize += string.length + 1;
+        });
+        HEAPU32[penviron_buf_size >> 2] = bufSize;
+        return 0;
+    }
+    fd_close(fd) {
+        return WASI_ESUCCESS;
+    }
+    fd_write(fd, iovs, iovs_len, nwritten) {
+        if (fd !== WASI_STDOUT_FILENO) {
+            return WASI_EBADF;
+        }
+        if (iovs_len !== 1) {
+            return WASI_ENOSYS;
+        }
+        const len = this.wasm.HEAPU32[iovs + 4 >> 2];
+        this.wasm.HEAPU32[nwritten >> 2] = len;
+        return WASI_ESUCCESS;
+    }
+    fd_read(fd, iovs, iovs_len, nread) {
+        return WASI_EINVAL;
+    }
+    fd_seek(fd, offset, whence, newOffset) {
+        return WASI_EINVAL;
+    }
+}
+Wasi.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: Wasi, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+Wasi.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: Wasi, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: Wasi, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root"
+                }]
+        }], ctorParameters: function () { return []; } });
+
 function loadBaseUrl() {
     if (typeof (document) === "undefined" || typeof (location) === "undefined")
         return "/";
@@ -5161,6 +5549,10 @@ class NgxUtilsModule {
                     provide: GLOBAL_TEMPLATES,
                     useExisting: (!config ? null : config.globalTemplates) || GlobalTemplateService
                 },
+                {
+                    provide: WASI_IMPLEMENTATION,
+                    useExisting: (!config ? null : config.wasiImplementation) || Wasi
+                },
                 {
                     provide: APP_BASE_URL,
                     useFactory: (!config ? null : config.baseUrl) || loadBaseUrl,
@@ -5218,5 +5610,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { API_SERVICE, APP_BASE_URL, AUTH_SERVICE, AclService, AjaxRequestHandler, ApiService, ArrayUtils, AsyncMethodBase, AsyncMethodDirective, AuthGuard, BASE_CONFIG, BackgroundDirective, BaseHttpClient, BaseHttpService, CONFIG_SERVICE, CanvasColor, CanvasUtils, ChunkPipe, Circle, ConfigService, ConsoleToasterService, DateUtils, DynamicTableComponent, DynamicTableTemplateDirective, ERROR_HANDLER, EXPRESS_REQUEST, EntriesPipe, ErrorHandlerService, EventsService, ExtraItemPropertiesPipe, FactoryDependencies, FileSystemEntry, FileUtils, FilterPipe, FindPipe, FormatNumberPipe, FormatterService, GLOBAL_TEMPLATES, GenericValue, GetOffsetPipe, GetTypePipe, GlobalTemplateDirective, GlobalTemplatePipe, GlobalTemplateService, GroupByPipe, HttpPromise, ICON_SERVICE, IConfiguration, IconDirective, IconService, Initializer, IsTypePipe, JoinPipe, KeysPipe, LANGUAGE_SERVICE, LanguageService, LoaderUtils, MapPipe, MathUtils, MaxPipe, MinPipe, NgxTemplateOutletDirective, NgxUtilsModule, ObjectUtils, ObservableUtils, OpenApiService, PROMISE_SERVICE, PaginationDirective, PaginationItemContext, PaginationItemDirective, PaginationMenuComponent, Point, PopPipe, PromiseService, ROOT_ELEMENT, Rect, ReducePipe, ReflectUtils, RemapPipe, ReplacePipe, ResizeEventPlugin, ResourceIfContext, ResourceIfDirective, ReversePipe, RoundPipe, SCRIPT_PARAMS, SafeHtmlPipe, ScrollEventPlugin, SetUtils, ShiftPipe, SplitPipe, StateService, StaticAuthService, StaticLanguageService, StickyClassDirective, StickyDirective, StorageMode, StorageService, StringUtils, TOASTER_SERVICE, TimerUtils, TranslatePipe, TranslatedUrlSerializer, UniqueUtils, UniversalService, UnorderedListComponent, UnorderedListItemDirective, UnorderedListTemplateDirective, UnorederedListTemplate, ValuedPromise, ValuesPipe, Vector };
+export { API_SERVICE, APP_BASE_URL, AUTH_SERVICE, AclService, AjaxRequestHandler, ApiService, ArrayUtils, AsyncMethodBase, AsyncMethodDirective, AuthGuard, BASE_CONFIG, BackgroundDirective, BaseHttpClient, BaseHttpService, CONFIG_SERVICE, CanvasColor, CanvasUtils, ChunkPipe, Circle, ConfigService, ConsoleToasterService, DateUtils, DynamicTableComponent, DynamicTableTemplateDirective, ERROR_HANDLER, EXPRESS_REQUEST, EntriesPipe, ErrorHandlerService, EventsService, ExtraItemPropertiesPipe, FactoryDependencies, FileSystemEntry, FileUtils, FilterPipe, FindPipe, FormatNumberPipe, FormatterService, GLOBAL_TEMPLATES, GenericValue, GetOffsetPipe, GetTypePipe, GlobalTemplateDirective, GlobalTemplatePipe, GlobalTemplateService, GroupByPipe, HttpPromise, ICON_SERVICE, IConfiguration, IconDirective, IconService, Initializer, IsTypePipe, JSONfn, JoinPipe, KeysPipe, LANGUAGE_SERVICE, LanguageService, LoaderUtils, LocalHttpService, MapPipe, MathUtils, MaxPipe, MinPipe, NgxTemplateOutletDirective, NgxUtilsModule, ObjectUtils, ObservableUtils, OpenApiService, PROMISE_SERVICE, PaginationDirective, PaginationItemContext, PaginationItemDirective, PaginationMenuComponent, Point, PopPipe, PromiseService, ROOT_ELEMENT, Rect, ReducePipe, ReflectUtils, RemapPipe, ReplacePipe, ResizeEventPlugin, ResourceIfContext, ResourceIfDirective, ReversePipe, RoundPipe, SCRIPT_PARAMS, SafeHtmlPipe, ScrollEventPlugin, SetUtils, ShiftPipe, SplitPipe, StateService, StaticAuthService, StaticLanguageService, StickyClassDirective, StickyDirective, StorageMode, StorageService, StringUtils, TOASTER_SERVICE, TimerUtils, TranslatePipe, TranslatedUrlSerializer, UniqueUtils, UniversalService, UnorderedListComponent, UnorderedListItemDirective, UnorderedListTemplateDirective, UnorederedListTemplate, ValuedPromise, ValuesPipe, Vector, WASI_IMPLEMENTATION, WasmService };
 //# sourceMappingURL=stemy-ngx-utils.mjs.map