@nativescript/core 8.9.0-alpha.3 → 8.9.0-napi-es5.0

package/application/application-common.js

@@ -8,22 +8,23 @@ import { Trace } from '../trace';
 import { Builder } from '../ui/builder';
 import * as bindableResources from '../ui/core/bindable/bindable-resources';
 // prettier-ignore
-const ORIENTATION_CSS_CLASSES = [
-    `${CSSUtils.CLASS_PREFIX}${CoreTypes.DeviceOrientation.portrait}`,
-    `${CSSUtils.CLASS_PREFIX}${CoreTypes.DeviceOrientation.landscape}`,
-    `${CSSUtils.CLASS_PREFIX}${CoreTypes.DeviceOrientation.unknown}`,
+var ORIENTATION_CSS_CLASSES = [
+    "".concat(CSSUtils.CLASS_PREFIX).concat(CoreTypes.DeviceOrientation.portrait),
+    "".concat(CSSUtils.CLASS_PREFIX).concat(CoreTypes.DeviceOrientation.landscape),
+    "".concat(CSSUtils.CLASS_PREFIX).concat(CoreTypes.DeviceOrientation.unknown),
 ];
 // prettier-ignore
-const SYSTEM_APPEARANCE_CSS_CLASSES = [
-    `${CSSUtils.CLASS_PREFIX}${CoreTypes.SystemAppearance.light}`,
-    `${CSSUtils.CLASS_PREFIX}${CoreTypes.SystemAppearance.dark}`,
+var SYSTEM_APPEARANCE_CSS_CLASSES = [
+    "".concat(CSSUtils.CLASS_PREFIX).concat(CoreTypes.SystemAppearance.light),
+    "".concat(CSSUtils.CLASS_PREFIX).concat(CoreTypes.SystemAppearance.dark),
 ];
-const globalEvents = global.NativeScriptGlobals.events;
-export class ApplicationCommon {
+var globalEvents = global.NativeScriptGlobals.events;
+var ApplicationCommon = /** @class */ (function () {
     /**
      * @internal - should not be constructed by the user.
      */
-    constructor() {
+    function ApplicationCommon() {
+        var _this = this;
         this.launchEvent = 'launch';
         this.suspendEvent = 'suspend';
         this.displayedEvent = 'displayed';
@@ -56,43 +57,43 @@ export class ApplicationCommon {
         this._suspended = false;
         this.started = false;
         global.NativeScriptGlobals.appInstanceReady = true;
-        global.__onUncaughtError = (error) => {
-            this.notify({
-                eventName: this.uncaughtErrorEvent,
-                object: this,
+        global.__onUncaughtError = function (error) {
+            _this.notify({
+                eventName: _this.uncaughtErrorEvent,
+                object: _this,
                 android: error,
                 ios: error,
                 error: error,
             });
         };
-        global.__onDiscardedError = (error) => {
-            this.notify({
-                eventName: this.discardedErrorEvent,
-                object: this,
+        global.__onDiscardedError = function (error) {
+            _this.notify({
+                eventName: _this.discardedErrorEvent,
+                object: _this,
                 error: error,
             });
         };
-        global.__onLiveSync = (context) => {
-            if (this.suspended) {
+        global.__onLiveSync = function (context) {
+            if (_this.suspended) {
                 return;
             }
-            const rootView = this.getRootView();
-            this.livesync(rootView, context);
+            var rootView = _this.getRootView();
+            _this.livesync(rootView, context);
         };
     }
     /**
      * @internal
      */
-    livesync(rootView, context) {
+    ApplicationCommon.prototype.livesync = function (rootView, context) {
         this.notify({ eventName: this.livesyncEvent, object: this });
-        const liveSyncCore = global.__onLiveSyncCore;
-        let reapplyAppStyles = false;
+        var liveSyncCore = global.__onLiveSyncCore;
+        var reapplyAppStyles = false;
         // ModuleContext is available only for Hot Module Replacement
         if (context && context.path) {
-            const styleExtensions = ['css', 'scss'];
-            const appStylesFullFileName = this.getCssFileName();
-            const appStylesFileName = appStylesFullFileName.substring(0, appStylesFullFileName.lastIndexOf('.') + 1);
-            reapplyAppStyles = styleExtensions.some((ext) => context.path === appStylesFileName.concat(ext));
+            var styleExtensions = ['css', 'scss'];
+            var appStylesFullFileName = this.getCssFileName();
+            var appStylesFileName_1 = appStylesFullFileName.substring(0, appStylesFullFileName.lastIndexOf('.') + 1);
+            reapplyAppStyles = styleExtensions.some(function (ext) { return context.path === appStylesFileName_1.concat(ext); });
         }
         // Handle application styles
         if (rootView && reapplyAppStyles) {
@@ -101,7 +102,7 @@ export class ApplicationCommon {
         else if (liveSyncCore) {
             liveSyncCore(context);
         }
-    }
+    };
     /**
      * Applies the the `newCssClass` to the `rootView` and removes all other css classes from `cssClasses`
      * previously applied to the `rootView`.
@@ -110,61 +111,64 @@ export class ApplicationCommon {
      * @param newCssClass
      * @param skipCssUpdate
      */
-    applyCssClass(rootView, cssClasses, newCssClass, skipCssUpdate = false) {
+    ApplicationCommon.prototype.applyCssClass = function (rootView, cssClasses, newCssClass, skipCssUpdate) {
+        var _this = this;
+        if (skipCssUpdate === void 0) { skipCssUpdate = false; }
         if (!rootView.cssClasses.has(newCssClass)) {
-            cssClasses.forEach((cssClass) => this.removeCssClass(rootView, cssClass));
+            cssClasses.forEach(function (cssClass) { return _this.removeCssClass(rootView, cssClass); });
             this.addCssClass(rootView, newCssClass);
             this.increaseStyleScopeApplicationCssSelectorVersion(rootView);
             if (!skipCssUpdate) {
                 rootView._onCssStateChange();
             }
             if (Trace.isEnabled()) {
-                const rootCssClasses = Array.from(rootView.cssClasses);
-                Trace.write(`Applying root css class: ${newCssClass}. rootView css classes: ${rootCssClasses.join(' ')}`, Trace.categories.Style);
+                var rootCssClasses = Array.from(rootView.cssClasses);
+                Trace.write("Applying root css class: ".concat(newCssClass, ". rootView css classes: ").concat(rootCssClasses.join(' ')), Trace.categories.Style);
             }
         }
-    }
-    addCssClass(rootView, cssClass) {
+    };
+    ApplicationCommon.prototype.addCssClass = function (rootView, cssClass) {
         CSSUtils.pushToSystemCssClasses(cssClass);
         rootView.cssClasses.add(cssClass);
-    }
-    removeCssClass(rootView, cssClass) {
+    };
+    ApplicationCommon.prototype.removeCssClass = function (rootView, cssClass) {
         CSSUtils.removeSystemCssClass(cssClass);
         rootView.cssClasses.delete(cssClass);
-    }
-    increaseStyleScopeApplicationCssSelectorVersion(rootView) {
-        const styleScope = rootView._styleScope ?? rootView?.currentPage?._styleScope;
+    };
+    ApplicationCommon.prototype.increaseStyleScopeApplicationCssSelectorVersion = function (rootView) {
+        var _a, _b;
+        var styleScope = (_a = rootView._styleScope) !== null && _a !== void 0 ? _a : (_b = rootView === null || rootView === void 0 ? void 0 : rootView.currentPage) === null || _b === void 0 ? void 0 : _b._styleScope;
         if (styleScope) {
             styleScope._increaseApplicationCssSelectorVersion();
         }
-    }
-    setRootViewCSSClasses(rootView) {
-        const platform = Device.os.toLowerCase();
-        const deviceType = Device.deviceType.toLowerCase();
-        const orientation = this.orientation();
-        const systemAppearance = this.systemAppearance();
+    };
+    ApplicationCommon.prototype.setRootViewCSSClasses = function (rootView) {
+        var platform = Device.os.toLowerCase();
+        var deviceType = Device.deviceType.toLowerCase();
+        var orientation = this.orientation();
+        var systemAppearance = this.systemAppearance();
         if (platform) {
-            CSSUtils.pushToSystemCssClasses(`${CSSUtils.CLASS_PREFIX}${platform}`);
+            CSSUtils.pushToSystemCssClasses("".concat(CSSUtils.CLASS_PREFIX).concat(platform));
         }
         if (deviceType) {
-            CSSUtils.pushToSystemCssClasses(`${CSSUtils.CLASS_PREFIX}${deviceType}`);
+            CSSUtils.pushToSystemCssClasses("".concat(CSSUtils.CLASS_PREFIX).concat(deviceType));
         }
         if (orientation) {
-            CSSUtils.pushToSystemCssClasses(`${CSSUtils.CLASS_PREFIX}${orientation}`);
+            CSSUtils.pushToSystemCssClasses("".concat(CSSUtils.CLASS_PREFIX).concat(orientation));
         }
         if (systemAppearance) {
-            CSSUtils.pushToSystemCssClasses(`${CSSUtils.CLASS_PREFIX}${systemAppearance}`);
+            CSSUtils.pushToSystemCssClasses("".concat(CSSUtils.CLASS_PREFIX).concat(systemAppearance));
         }
         rootView.cssClasses.add(CSSUtils.ROOT_VIEW_CSS_CLASS);
-        const rootViewCssClasses = CSSUtils.getSystemCssClasses();
-        rootViewCssClasses.forEach((c) => rootView.cssClasses.add(c));
+        var rootViewCssClasses = CSSUtils.getSystemCssClasses();
+        rootViewCssClasses.forEach(function (c) { return rootView.cssClasses.add(c); });
         this.increaseStyleScopeApplicationCssSelectorVersion(rootView);
         rootView._onCssStateChange();
         if (Trace.isEnabled()) {
-            const rootCssClasses = Array.from(rootView.cssClasses);
-            Trace.write(`Setting root css classes: ${rootCssClasses.join(' ')}`, Trace.categories.Style);
+            var rootCssClasses = Array.from(rootView.cssClasses);
+            Trace.write("Setting root css classes: ".concat(rootCssClasses.join(' ')), Trace.categories.Style);
         }
-    }
+    };
     /**
      * iOS Only
      * Dynamically change the preferred frame rate
@@ -178,29 +182,24 @@ export class ApplicationCommon {
      * ```
      * @param options { min?: number; max?: number; preferred?: number }
      */
-    setMaxRefreshRate(options) {
+    ApplicationCommon.prototype.setMaxRefreshRate = function (options) {
         // implement in platform specific files (iOS only for now)
-    }
+    };
     /**
      * @returns The main entry of the application
      */
-    getMainEntry() {
+    ApplicationCommon.prototype.getMainEntry = function () {
         return this.mainEntry;
-    }
-    notifyLaunch(additionalLanchEventData) {
-        const launchArgs = {
-            eventName: this.launchEvent,
-            object: this,
-            ios: this.ios,
-            android: this.android,
-            ...additionalLanchEventData,
-        };
+    };
+    ApplicationCommon.prototype.notifyLaunch = function (additionalLanchEventData) {
+        var launchArgs = __assign({ eventName: this.launchEvent, object: this, ios: this.ios, android: this.android }, additionalLanchEventData);
         this.notify(launchArgs);
         this.loadAppCss();
         return launchArgs.root;
-    }
-    createRootView(view, fireLaunchEvent = false, additionalLanchEventData) {
-        let rootView = view;
+    };
+    ApplicationCommon.prototype.createRootView = function (view, fireLaunchEvent, additionalLanchEventData) {
+        if (fireLaunchEvent === void 0) { fireLaunchEvent = false; }
+        var rootView = view;
         if (!rootView) {
             if (fireLaunchEvent) {
                 rootView = this.notifyLaunch(additionalLanchEventData);
@@ -218,56 +217,56 @@ export class ApplicationCommon {
             }
         }
         return rootView;
-    }
-    getRootView() {
+    };
+    ApplicationCommon.prototype.getRootView = function () {
         throw new Error('getRootView() Not implemented.');
-    }
-    resetRootView(entry) {
+    };
+    ApplicationCommon.prototype.resetRootView = function (entry) {
         this.mainEntry = typeof entry === 'string' ? { moduleName: entry } : entry;
         // rest of implementation is platform specific
-    }
-    initRootView(rootView) {
+    };
+    ApplicationCommon.prototype.initRootView = function (rootView) {
         this.setRootViewCSSClasses(rootView);
         initAccessibilityCssHelper();
         initAccessibilityFontScale();
-        this.notify({ eventName: this.initRootViewEvent, rootView });
-    }
+        this.notify({ eventName: this.initRootViewEvent, rootView: rootView });
+    };
     /**
      * Get application level static resources.
      */
-    getResources() {
+    ApplicationCommon.prototype.getResources = function () {
         return bindableResources.get();
-    }
+    };
     /**
      * Set application level static resources.
      */
-    setResources(res) {
+    ApplicationCommon.prototype.setResources = function (res) {
         bindableResources.set(res);
-    }
+    };
     /**
      * Sets css file name for the application.
      */
-    setCssFileName(cssFileName) {
+    ApplicationCommon.prototype.setCssFileName = function (cssFileName) {
         this.cssFile = cssFileName;
         this.notify({
             eventName: this.cssChangedEvent,
             object: this,
             cssFile: cssFileName,
         });
-    }
+    };
     /**
      * Gets css file name for the application.
      */
-    getCssFileName() {
+    ApplicationCommon.prototype.getCssFileName = function () {
         return this.cssFile;
-    }
+    };
     /**
      * Loads immediately the app.css.
      * By default the app.css file is loaded shortly after "loaded".
      * For the Android snapshot the CSS can be parsed during the snapshot generation,
      * as the CSS does not depend on runtime APIs, and loadAppCss will be called explicitly.
      */
-    loadAppCss() {
+    ApplicationCommon.prototype.loadAppCss = function () {
         try {
             this.notify({
                 eventName: this.loadAppCssEvent,
@@ -279,31 +278,31 @@ export class ApplicationCommon {
         }
         catch (e) {
             if (Trace.isEnabled()) {
-                Trace.write(`The app CSS file ${this.getCssFileName()} couldn't be loaded!`, Trace.categories.Style, Trace.messageType.warn);
+                Trace.write("The app CSS file ".concat(this.getCssFileName(), " couldn't be loaded!"), Trace.categories.Style, Trace.messageType.warn);
             }
         }
-    }
-    addCss(cssText, attributeScoped) {
+    };
+    ApplicationCommon.prototype.addCss = function (cssText, attributeScoped) {
         this.notify({
             eventName: this.cssChangedEvent,
             object: this,
             cssText: cssText,
         });
         if (!attributeScoped) {
-            const rootView = this.getRootView();
+            var rootView = this.getRootView();
             if (rootView) {
                 rootView._onCssStateChange();
             }
         }
-    }
-    run(entry) {
+    };
+    ApplicationCommon.prototype.run = function (entry) {
         throw new Error('run() Not implemented.');
-    }
-    getOrientation() {
+    };
+    ApplicationCommon.prototype.getOrientation = function () {
         // override in platform specific Application class
         throw new Error('getOrientation() not implemented');
-    }
-    setOrientation(value) {
+    };
+    ApplicationCommon.prototype.setOrientation = function (value) {
         if (this._orientation === value) {
             return;
         }
@@ -319,37 +318,39 @@ export class ApplicationCommon {
             newValue: value,
             object: this,
         });
-    }
-    orientation() {
-        return (this._orientation ?? (this._orientation = this.getOrientation()));
-    }
-    orientationChanged(rootView, newOrientation) {
+    };
+    ApplicationCommon.prototype.orientation = function () {
+        var _a;
+        return ((_a = this._orientation) !== null && _a !== void 0 ? _a : (this._orientation = this.getOrientation()));
+    };
+    ApplicationCommon.prototype.orientationChanged = function (rootView, newOrientation) {
+        var _this = this;
         if (!rootView) {
             return;
         }
-        const newOrientationCssClass = `${CSSUtils.CLASS_PREFIX}${newOrientation}`;
+        var newOrientationCssClass = "".concat(CSSUtils.CLASS_PREFIX).concat(newOrientation);
         this.applyCssClass(rootView, ORIENTATION_CSS_CLASSES, newOrientationCssClass, true);
-        const rootModalViews = rootView._getRootModalViews();
-        rootModalViews.forEach((rootModalView) => {
-            this.applyCssClass(rootModalView, ORIENTATION_CSS_CLASSES, newOrientationCssClass, true);
+        var rootModalViews = rootView._getRootModalViews();
+        rootModalViews.forEach(function (rootModalView) {
+            _this.applyCssClass(rootModalView, ORIENTATION_CSS_CLASSES, newOrientationCssClass, true);
             // Trigger state change for root modal view classes and media queries
             rootModalView._onCssStateChange();
         });
         // Trigger state change for root view classes and media queries
         rootView._onCssStateChange();
-    }
-    getNativeApplication() {
+    };
+    ApplicationCommon.prototype.getNativeApplication = function () {
         // override in platform specific Application class
         throw new Error('getNativeApplication() not implemented');
-    }
-    hasLaunched() {
+    };
+    ApplicationCommon.prototype.hasLaunched = function () {
         return global.NativeScriptGlobals && global.NativeScriptGlobals.launched;
-    }
-    getSystemAppearance() {
+    };
+    ApplicationCommon.prototype.getSystemAppearance = function () {
         // override in platform specific Application class
         throw new Error('getSystemAppearance() not implemented');
-    }
-    setSystemAppearance(value) {
+    };
+    ApplicationCommon.prototype.setSystemAppearance = function (value) {
         if (this._systemAppearance === value) {
             return;
         }
@@ -362,106 +363,123 @@ export class ApplicationCommon {
             newValue: value,
             object: this,
         });
-    }
-    systemAppearance() {
+    };
+    ApplicationCommon.prototype.systemAppearance = function () {
+        var _a;
         // return cached value, or get it from the platform specific override
-        return (this._systemAppearance ?? (this._systemAppearance = this.getSystemAppearance()));
-    }
+        return ((_a = this._systemAppearance) !== null && _a !== void 0 ? _a : (this._systemAppearance = this.getSystemAppearance()));
+    };
     /**
      * enable/disable systemAppearanceChanged
      */
-    setAutoSystemAppearanceChanged(value) {
+    ApplicationCommon.prototype.setAutoSystemAppearanceChanged = function (value) {
         this.autoSystemAppearanceChanged = value;
-    }
+    };
     /**
      * Updates root view classes including those of modals
      * @param rootView the root view
      * @param newSystemAppearance the new appearance change
      */
-    systemAppearanceChanged(rootView, newSystemAppearance) {
+    ApplicationCommon.prototype.systemAppearanceChanged = function (rootView, newSystemAppearance) {
+        var _this = this;
         if (!rootView || !this.autoSystemAppearanceChanged) {
             return;
         }
-        const newSystemAppearanceCssClass = `${CSSUtils.CLASS_PREFIX}${newSystemAppearance}`;
+        var newSystemAppearanceCssClass = "".concat(CSSUtils.CLASS_PREFIX).concat(newSystemAppearance);
         this.applyCssClass(rootView, SYSTEM_APPEARANCE_CSS_CLASSES, newSystemAppearanceCssClass, true);
-        const rootModalViews = rootView._getRootModalViews();
-        rootModalViews.forEach((rootModalView) => {
-            this.applyCssClass(rootModalView, SYSTEM_APPEARANCE_CSS_CLASSES, newSystemAppearanceCssClass, true);
+        var rootModalViews = rootView._getRootModalViews();
+        rootModalViews.forEach(function (rootModalView) {
+            _this.applyCssClass(rootModalView, SYSTEM_APPEARANCE_CSS_CLASSES, newSystemAppearanceCssClass, true);
             // Trigger state change for root modal view classes and media queries
             rootModalView._onCssStateChange();
         });
         // Trigger state change for root view classes and media queries
         rootView._onCssStateChange();
-    }
-    get inBackground() {
-        return this._inBackground;
-    }
-    setInBackground(value, additonalData) {
+    };
+    Object.defineProperty(ApplicationCommon.prototype, "inBackground", {
+        get: function () {
+            return this._inBackground;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ApplicationCommon.prototype.setInBackground = function (value, additonalData) {
         this._inBackground = value;
-        this.notify({
-            eventName: value ? this.backgroundEvent : this.foregroundEvent,
-            object: this,
-            ios: this.ios,
-            ...additonalData,
-        });
-    }
-    get suspended() {
-        return this._suspended;
-    }
-    setSuspended(value, additonalData) {
+        this.notify(__assign({ eventName: value ? this.backgroundEvent : this.foregroundEvent, object: this, ios: this.ios }, additonalData));
+    };
+    Object.defineProperty(ApplicationCommon.prototype, "suspended", {
+        get: function () {
+            return this._suspended;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ApplicationCommon.prototype.setSuspended = function (value, additonalData) {
         this._suspended = value;
-        this.notify({
-            eventName: value ? this.suspendEvent : this.resumeEvent,
-            object: this,
-            ios: this.ios,
-            android: this.android,
-            ...additonalData,
-        });
-    }
-    get android() {
-        return undefined;
-    }
-    get ios() {
-        return undefined;
-    }
-    get AndroidApplication() {
-        return this.android;
-    }
-    get iOSApplication() {
-        return this.ios;
-    }
-}
-// Expose statically for backwards compat on AndroidApplication.on etc.
-/**
- * @deprecated Use `Application.android.on()` instead.
- */
-ApplicationCommon.on = globalEvents.on.bind(globalEvents);
-/**
- * @deprecated Use `Application.android.once()` instead.
- */
-ApplicationCommon.once = globalEvents.once.bind(globalEvents);
-/**
- * @deprecated Use `Application.android.off()` instead.
- */
-ApplicationCommon.off = globalEvents.off.bind(globalEvents);
-/**
- * @deprecated Use `Application.android.notify()` instead.
- */
-ApplicationCommon.notify = globalEvents.notify.bind(globalEvents);
-/**
- * @deprecated Use `Application.android.hasListeners()` instead.
- */
-ApplicationCommon.hasListeners = globalEvents.hasListeners.bind(globalEvents);
-__decorate([
-    profile,
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", Function)
-], ApplicationCommon.prototype, "notifyLaunch", null);
-__decorate([
-    profile,
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Function, Object, Object]),
-    __metadata("design:returntype", void 0)
-], ApplicationCommon.prototype, "createRootView", null);
+        this.notify(__assign({ eventName: value ? this.suspendEvent : this.resumeEvent, object: this, ios: this.ios, android: this.android }, additonalData));
+    };
+    Object.defineProperty(ApplicationCommon.prototype, "android", {
+        get: function () {
+            return undefined;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ApplicationCommon.prototype, "ios", {
+        get: function () {
+            return undefined;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ApplicationCommon.prototype, "AndroidApplication", {
+        get: function () {
+            return this.android;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ApplicationCommon.prototype, "iOSApplication", {
+        get: function () {
+            return this.ios;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    // Expose statically for backwards compat on AndroidApplication.on etc.
+    /**
+     * @deprecated Use `Application.android.on()` instead.
+     */
+    ApplicationCommon.on = globalEvents.on.bind(globalEvents);
+    /**
+     * @deprecated Use `Application.android.once()` instead.
+     */
+    ApplicationCommon.once = globalEvents.once.bind(globalEvents);
+    /**
+     * @deprecated Use `Application.android.off()` instead.
+     */
+    ApplicationCommon.off = globalEvents.off.bind(globalEvents);
+    /**
+     * @deprecated Use `Application.android.notify()` instead.
+     */
+    ApplicationCommon.notify = globalEvents.notify.bind(globalEvents);
+    /**
+     * @deprecated Use `Application.android.hasListeners()` instead.
+     */
+    ApplicationCommon.hasListeners = globalEvents.hasListeners.bind(globalEvents);
+    __decorate([
+        profile,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", Function)
+    ], ApplicationCommon.prototype, "notifyLaunch", null);
+    __decorate([
+        profile,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Function, Object, Object]),
+        __metadata("design:returntype", void 0)
+    ], ApplicationCommon.prototype, "createRootView", null);
+    return ApplicationCommon;
+}());
+export { ApplicationCommon };
 //# sourceMappingURL=application-common.js.map