@raydiant/playlist-window-manager 0.29.1 → 0.30.0

package/build/IFrameRenderer.d.ts

@@ -14,6 +14,7 @@ export default class IFrameRenderer implements PresentationWindowRenderer {
     sendMessageObject(windowId: string, type: string, payload?: any): void;
     muteWindow(windowId: string): void;
     unMuteWindow(windowId: string): void;
+    setWindowBackground(windowId: string, color: string): void;
     destroy(): void;
     private getWindow;
     private globalMessageHandler;

package/build/IFrameRenderer.js

@@ -36,6 +36,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+var surfaces_1 = require("./surfaces");
 var namespace = 'raydiant';
 var IFrameRenderer = /** @class */ (function () {
     function IFrameRenderer(container) {
@@ -55,6 +56,12 @@ var IFrameRenderer = /** @class */ (function () {
                 if (!window_1) {
                     throw new Error("Failed add receive message callback to window, window with window id: '".concat(windowId, "' was not found"));
                 }
+                // A surface costs a hardware decoder, so only the window's own frame may
+                // ask for one; any frame can post here and name any window.
+                if (surfaces_1.VIDEO_REQUESTS.indexOf(type) !== -1 &&
+                    event.source !== window_1.frame.contentWindow) {
+                    return;
+                }
                 if (window_1.receiveMessageCallback) {
                     window_1.receiveMessageCallback(type, payload);
                 }
@@ -218,6 +225,13 @@ var IFrameRenderer = /** @class */ (function () {
         // There is no  mute/unmute API for iframes so we rely on the window manager overriding any
         // mute presentation properties.
     };
+    IFrameRenderer.prototype.setWindowBackground = function (windowId, color) {
+        var window = this.getWindow(windowId);
+        if (!window) {
+            throw new Error("Failed to set window background, missing window id '".concat(windowId, "'"));
+        }
+        window.frame.style.backgroundColor = color;
+    };
     IFrameRenderer.prototype.destroy = function () {
         window.removeEventListener('message', this.globalMessageHandler, false);
     };

package/build/IFrameRenderer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/IFrameRenderer.test.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var IFrameRenderer_1 = __importDefault(require("./IFrameRenderer"));
+function setup() {
+    var container = document.createElement('div');
+    document.body.appendChild(container);
+    var renderer = new IFrameRenderer_1.default(container);
+    var received = [];
+    renderer.createWindow({
+        windowId: 'w1',
+        backgroundColor: '#000000',
+        receiveMessageCallback: function (type, payload) { return received.push([type, payload]); },
+        errorCallback: function () { return undefined; },
+    });
+    var frame = container.querySelector('iframe');
+    var post = function (type, source) {
+        window.dispatchEvent(new MessageEvent('message', {
+            data: "raydiant:".concat(JSON.stringify({ windowId: 'w1', type: type })),
+            source: source,
+        }));
+    };
+    var teardown = function () {
+        renderer.destroy();
+        document.body.removeChild(container);
+    };
+    return { renderer: renderer, frame: frame, received: received, post: post, teardown: teardown };
+}
+describe('only the window’s own frame asks for a video surface', function () {
+    test.each(['open_video', 'video_bounds', 'video_hole_open', 'close_video'])("%s from another frame's source is dropped", function (type) {
+        var _a = setup(), frame = _a.frame, received = _a.received, post = _a.post, teardown = _a.teardown;
+        var other = document.createElement('iframe');
+        document.body.appendChild(other);
+        post(type, other.contentWindow);
+        expect(received).toEqual([]);
+        post(type, frame.contentWindow);
+        expect(received).toEqual([[type, undefined]]);
+        document.body.removeChild(other);
+        teardown();
+    });
+    test("every other message keeps today's routing by window id", function () {
+        var _a = setup(), received = _a.received, post = _a.post, teardown = _a.teardown;
+        post('presentation_ready', null);
+        expect(received).toEqual([['presentation_ready', undefined]]);
+        teardown();
+    });
+});
+describe('the frame background', function () {
+    test('setWindowBackground sets the frame’s inline background', function () {
+        var _a = setup(), renderer = _a.renderer, frame = _a.frame, teardown = _a.teardown;
+        expect(frame.style.backgroundColor).toBe('rgb(0, 0, 0)');
+        renderer.setWindowBackground('w1', 'transparent');
+        expect(frame.style.backgroundColor).toBe('transparent');
+        renderer.setWindowBackground('w1', '#000000');
+        expect(frame.style.backgroundColor).toBe('rgb(0, 0, 0)');
+        teardown();
+    });
+});
+describe('no colour scheme', function () {
+    test('a created frame declares no color-scheme', function () {
+        var _a = setup(), frame = _a.frame, renderer = _a.renderer, teardown = _a.teardown;
+        renderer.showWindow('w1', false);
+        renderer.setWindowBackground('w1', 'transparent');
+        expect(frame.style.getPropertyValue('color-scheme')).toBe('');
+        expect(frame.getAttribute('style')).not.toMatch(/color-scheme/);
+        teardown();
+    });
+});

package/build/PlaylistWindowManager.d.ts

@@ -2,6 +2,7 @@ import * as RE from '@raydiant/playlist-rule-engine';
 import EventEmitter from 'eventemitter3';
 import { PresentationWindowRenderer, Device, WindowBounds, Theme, Logger, WorkerState, Charge, ChargeResponse, Terminal } from './types';
 import PlaylistWindowManagerState from './PlaylistWindowManagerState';
+import { SurfaceHost } from './surfaces';
 export interface PlaylistWindowManagerOptions {
     ruleEngine: RE.RuleEngine;
     state: PlaylistWindowManagerState;
@@ -22,6 +23,7 @@ export interface PlaylistWindowManagerOptions {
     onDisableInterruptLock?: () => void;
     getTerminal?: () => Terminal | null;
     getOnlineStatus?: () => boolean;
+    surfaces?: SurfaceHost;
 }
 export default class PlaylistWindowManager extends EventEmitter {
     private options;
@@ -45,6 +47,8 @@ export default class PlaylistWindowManager extends EventEmitter {
     private forceMute;
     private isFocused;
     private workerState;
+    private surfaceBroker;
+    private pendingPreload;
     constructor(options: PlaylistWindowManagerOptions);
     private currentPresentationId;
     private nextPresentationId;
@@ -84,6 +88,8 @@ export default class PlaylistWindowManager extends EventEmitter {
     sendTerminal(terminal: Terminal | null): void;
     sendOnlineStatus(isOnline: boolean): void;
     private createWindow;
+    private showAfterRevealMs;
+    private surfaceSwapDelayMs;
     private loadCurrentWindow;
     private shouldPreload;
     private preloadNextWindow;
@@ -94,6 +100,7 @@ export default class PlaylistWindowManager extends EventEmitter {
     private removeCurrentWindow;
     private removeNextWindow;
     private swapWindows;
+    private swapWithSurfaces;
     private evalRuleEngine;
     private handleEnableInterruptLock;
     private handleDisableInterruptLock;

package/build/PlaylistWindowManager.js

@@ -25,6 +25,29 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (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;
+};
 var __awaiter = (this && this.__awaiter) || function (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) {
@@ -71,6 +94,7 @@ var PresentationWindow_1 = __importDefault(require("./PresentationWindow"));
 var WindowUnresponsiveError_1 = __importDefault(require("./WindowUnresponsiveError"));
 var WindowTimeoutError_1 = __importDefault(require("./WindowTimeoutError"));
 var WindowLoadError_1 = __importDefault(require("./WindowLoadError"));
+var SurfaceBroker_1 = __importStar(require("./SurfaceBroker"));
 // Wait at least 3 seconds before restarting or moving onto the next window
 // to prevent log spam causing devices to become unresponsive.
 var minTimeBetweenCompletes = 3000;
@@ -97,6 +121,10 @@ var PlaylistWindowManager = /** @class */ (function (_super) {
         _this.forceMute = false;
         _this.isFocused = false;
         _this.workerState = {};
+        _this.surfaceBroker = null;
+        // The surface swap the next window's preload waits to finish. A newer
+        // preload or the next window's removal clears it, cancelling that preload.
+        _this.pendingPreload = null;
         _this.handleEnableInterruptLock = function () {
             var onEnableInterruptLock = _this.options.onEnableInterruptLock;
             if (onEnableInterruptLock) {
@@ -164,6 +192,12 @@ var PlaylistWindowManager = /** @class */ (function (_super) {
                         }
                         // Clear current window error flag.
                         this.currentWindowError = null;
+                        // A complete while the next window's preload waits for its surface swap
+                        // preloads it now, and the current window restarts while it loads, as
+                        // for any next window not yet ready.
+                        if (this.pendingPreload && this.nextPresentation) {
+                            this.preloadNextWindow();
+                        }
                         if (!(!this.isLocked() &&
                             !this.restartCurrentWindowOnEnd &&
                             this.currentWindow &&
@@ -318,6 +352,9 @@ var PlaylistWindowManager = /** @class */ (function (_super) {
         _this.bounds = options.bounds;
         _this.themeOverride = options.themeOverride;
         _this.forceMute = options.forceMute || false;
+        if (options.surfaces) {
+            _this.surfaceBroker = new SurfaceBroker_1.default(options.surfaces, options.logger);
+        }
         return _this;
     }
     PlaylistWindowManager.prototype.currentPresentationId = function () {
@@ -546,7 +583,14 @@ var PlaylistWindowManager = /** @class */ (function (_super) {
                         return [4 /*yield*/, Promise.all([this.removeCurrentWindow(), this.removeNextWindow()])];
                     case 1:
                         _a.sent();
-                        return [2 /*return*/];
+                        if (!this.surfaceBroker) return [3 /*break*/, 3];
+                        // Also closes a surface whose window is still leaving a swap.
+                        return [4 /*yield*/, this.surfaceBroker.closeAll()];
+                    case 2:
+                        // Also closes a surface whose window is still leaving a swap.
+                        _a.sent();
+                        _a.label = 3;
+                    case 3: return [2 /*return*/];
                 }
             });
         });
@@ -702,35 +746,24 @@ var PlaylistWindowManager = /** @class */ (function (_super) {
         var presentation = this.state.getPresentation(presentationId);
         var applicationVersion = this.state.getApplicationVersion(presentation.applicationDeploymentId);
         var windowId = (0, uuid_1.v4)();
-        return new PresentationWindow_1.default({
-            windowManager: this,
-            renderer: this.renderer,
-            logger: logger,
-            windowId: windowId,
-            windowName: windowName,
-            parentWindowId: parentWindowId,
-            presentation: presentation,
-            applicationVersion: applicationVersion,
-            device: device,
-            playlistId: pr.playlistId,
-            playlistName: this.ruleEngine.state.playlist(pr.playlistId).name,
-            rule: pr.rule,
-            publishedAt: this.state.getPublishedAt(),
-            theme: this.getTheme(presentationId),
-            forceMute: this.forceMute,
-            readyTimeoutDurationSeconds: readyTimeoutDurationSeconds,
-            appRendererUrl: appRendererUrl,
-            appRendererOfflineSupport: appRendererOfflineSupport,
-            bounds: this.bounds,
-            backgroundColor: backgroundColor,
-            playlistWindowManagerState: this.state,
-            ruleEngineState: this.ruleEngine.state,
-            globalRule: this.ruleEngine.globalRule,
-            isPreview: isPreview,
-            workerState: this.workerState,
-            getTerminal: this.options.getTerminal,
-            getOnlineStatus: this.options.getOnlineStatus,
-        });
+        return new PresentationWindow_1.default(__assign({ windowManager: this, renderer: this.renderer, logger: logger, windowId: windowId, windowName: windowName, parentWindowId: parentWindowId, presentation: presentation, applicationVersion: applicationVersion, device: device, playlistId: pr.playlistId, playlistName: this.ruleEngine.state.playlist(pr.playlistId).name, rule: pr.rule, publishedAt: this.state.getPublishedAt(), theme: this.getTheme(presentationId), forceMute: this.forceMute, readyTimeoutDurationSeconds: readyTimeoutDurationSeconds, appRendererUrl: appRendererUrl, appRendererOfflineSupport: appRendererOfflineSupport, bounds: this.bounds, backgroundColor: backgroundColor, playlistWindowManagerState: this.state, ruleEngineState: this.ruleEngine.state, globalRule: this.ruleEngine.globalRule, isPreview: isPreview, workerState: this.workerState, getTerminal: this.options.getTerminal, getOnlineStatus: this.options.getOnlineStatus }, (this.surfaceBroker
+            ? {
+                surfaceBroker: this.surfaceBroker,
+                surfaceShowDeadlineMs: this.surfaceSwapDelayMs(),
+            }
+            : {})));
+    };
+    PlaylistWindowManager.prototype.showAfterRevealMs = function () {
+        var surfaces = this.options.surfaces;
+        return surfaces && surfaces.showAfterRevealMs !== undefined
+            ? surfaces.showAfterRevealMs
+            : SurfaceBroker_1.DEFAULT_SHOW_AFTER_REVEAL_MS;
+    };
+    PlaylistWindowManager.prototype.surfaceSwapDelayMs = function () {
+        var closeWindowDelayMs = this.options.closeWindowDelayMs;
+        return closeWindowDelayMs !== undefined
+            ? closeWindowDelayMs
+            : SurfaceBroker_1.DEFAULT_SURFACE_SWAP_DELAY_MS;
     };
     PlaylistWindowManager.prototype.loadCurrentWindow = function () {
         return __awaiter(this, void 0, void 0, function () {
@@ -784,6 +817,9 @@ var PlaylistWindowManager = /** @class */ (function (_super) {
                 switch (_a.label) {
                     case 0:
                         logger = this.options.logger;
+                        // A publish, a preview change or a complete preloads now, in place of a
+                        // preload still waiting for its surface swap.
+                        this.pendingPreload = null;
                         if (!this.nextPresentation) {
                             logger.warn("Attempted to preload next window but nextPresentation not set");
                             return [2 /*return*/];
@@ -889,6 +925,7 @@ var PlaylistWindowManager = /** @class */ (function (_super) {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
+                        this.pendingPreload = null;
                         if (!this.nextWindow) return [3 /*break*/, 2];
                         return [4 /*yield*/, this.nextWindow.remove()];
                     case 1:
@@ -904,7 +941,7 @@ var PlaylistWindowManager = /** @class */ (function (_super) {
     };
     PlaylistWindowManager.prototype.swapWindows = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var nextPreviewPresentationId, preview, result, nextPresentation, shouldPreload, closeWindowPromise;
+            var nextPreviewPresentationId, preview, result, nextPresentation, shouldPreload, isSurfaceSwap, closeWindowPromise, windowToClose_1, incomingWindow_1, closeWindowDelayMs_1, preloadAfterSwap;
             var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
@@ -935,40 +972,56 @@ var PlaylistWindowManager = /** @class */ (function (_super) {
                         }
                         // Clear the pending interrupt whenever we swap the current window for the next one.
                         this.hasPendingInterrupt = false;
-                        // Next window is ready, show the next one, hide the current window, and
-                        // then remove the current window. Show the next window before hiding the
-                        // current to avoid flashes when rendering with BrowserWindows on device.
-                        if (this.nextWindow) {
+                        isSurfaceSwap = !!this.surfaceBroker &&
+                            ((!!this.currentWindow && this.currentWindow.holdsSurface()) ||
+                                (!!this.nextWindow && this.nextWindow.holdsSurface()));
+                        if (isSurfaceSwap) {
+                            closeWindowPromise = this.swapWithSurfaces(this.currentWindow, this.nextWindow);
+                        }
+                        else if (this.nextWindow) {
+                            // Next window is ready, show the next one, hide the current window, and
+                            // then remove the current window. Show the next window before hiding the
+                            // current to avoid flashes when rendering with BrowserWindows on device.
                             this.nextWindow.show(this.isFocused);
                         }
-                        if (!this.currentWindow) return [3 /*break*/, 3];
+                        if (!(!isSurfaceSwap && this.currentWindow)) return [3 /*break*/, 3];
                         if (!(this.options.closeWindowDelayMs !== undefined)) return [3 /*break*/, 1];
-                        // Don't await here because this will cause a slight delay when playing the next window.
-                        // Instead we want to wait for window close at the end of this method.
-                        closeWindowPromise = new Promise(function (resolve) {
-                            // Capture the current window reference to close because this.currentWindow will be
-                            // set to the next window before the timeout fires.
-                            var windowToClose = _this.currentWindow;
-                            setTimeout(function () { return __awaiter(_this, void 0, void 0, function () {
-                                return __generator(this, function (_a) {
-                                    switch (_a.label) {
-                                        case 0:
-                                            if (!windowToClose) return [3 /*break*/, 2];
-                                            // We can't use this.removeCurrentWindow because the currentWindow reference has already
-                                            // changed by the time the timeout fires.
-                                            return [4 /*yield*/, windowToClose.remove()];
-                                        case 1:
-                                            // We can't use this.removeCurrentWindow because the currentWindow reference has already
-                                            // changed by the time the timeout fires.
-                                            _a.sent();
-                                            _a.label = 2;
-                                        case 2:
-                                            resolve(undefined);
-                                            return [2 /*return*/];
-                                    }
-                                });
-                            }); }, _this.options.closeWindowDelayMs);
-                        });
+                        windowToClose_1 = this.currentWindow;
+                        incomingWindow_1 = this.nextWindow;
+                        closeWindowDelayMs_1 = this.options.closeWindowDelayMs;
+                        // The outgoing window stays on screen only as a visual backdrop from
+                        // here on: stop delivering its events (a late complete or error must
+                        // not end the incoming presentation) and mute it so audio does not
+                        // bleed into the incoming presentation during the overlap.
+                        windowToClose_1.detachCallbacks();
+                        windowToClose_1.mute();
+                        closeWindowPromise = (function () { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        if (!incomingWindow_1) return [3 /*break*/, 2];
+                                        return [4 /*yield*/, incomingWindow_1.waitForFirstPaint(closeWindowDelayMs_1)];
+                                    case 1:
+                                        _a.sent();
+                                        return [3 /*break*/, 4];
+                                    case 2: return [4 /*yield*/, new Promise(function (resolve) {
+                                            return setTimeout(resolve, closeWindowDelayMs_1);
+                                        })];
+                                    case 3:
+                                        _a.sent();
+                                        _a.label = 4;
+                                    case 4: 
+                                    // We can't use this.removeCurrentWindow because the currentWindow
+                                    // reference has already changed by the time the wait finishes.
+                                    return [4 /*yield*/, windowToClose_1.remove()];
+                                    case 5:
+                                        // We can't use this.removeCurrentWindow because the currentWindow
+                                        // reference has already changed by the time the wait finishes.
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); })();
                         return [3 /*break*/, 3];
                     case 1:
                         this.currentWindow.hide();
@@ -994,8 +1047,17 @@ var PlaylistWindowManager = /** @class */ (function (_super) {
                         }
                         // Play new current window.
                         this.playCurrentWindow();
-                        // Preload the next presentation if there is one.
-                        if (shouldPreload) {
+                        preloadAfterSwap = null;
+                        if (shouldPreload && isSurfaceSwap) {
+                            // Once the swap has finished, so the next surface's decoder does not
+                            // start during it: on the Stick a preload started in the swap held the
+                            // outgoing clip's last frame for about 70 ms. The next window is the
+                            // current one now.
+                            this.nextWindow = null;
+                            preloadAfterSwap = closeWindowPromise;
+                            this.pendingPreload = preloadAfterSwap;
+                        }
+                        else if (shouldPreload) {
                             this.preloadNextWindow();
                         }
                         else {
@@ -1009,11 +1071,70 @@ var PlaylistWindowManager = /** @class */ (function (_super) {
                     case 4:
                         _a.sent();
                         _a.label = 5;
-                    case 5: return [2 /*return*/];
+                    case 5:
+                        if (preloadAfterSwap && this.pendingPreload === preloadAfterSwap) {
+                            this.preloadNextWindow();
+                        }
+                        return [2 /*return*/];
                 }
             });
         });
     };
+    // The swap when either window holds a video surface. The outgoing surface
+    // is muted and marked leaving here, in the swap's own task; the rest runs
+    // on the two windows held here, so a publish, a preview check or a preload
+    // error during its waits acts on the new next window, never these two.
+    PlaylistWindowManager.prototype.swapWithSurfaces = function (outgoing, incoming) {
+        var _this = this;
+        var delayMs = this.surfaceSwapDelayMs();
+        if (outgoing) {
+            // A late complete or error from the outgoing window must not end the
+            // incoming presentation, and two surfaces never sound at once.
+            outgoing.detachCallbacks();
+            outgoing.muteSurfaceOrFrame();
+        }
+        return (function () { return __awaiter(_this, void 0, void 0, function () {
+            var isOutgoingHidden;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        isOutgoingHidden = false;
+                        if (!incoming) return [3 /*break*/, 3];
+                        // The new is shown before the old is hidden: an incoming surface's
+                        // frame is revealed over its open hole and the outgoing frame hidden
+                        // in that same task, so neither the outgoing paint-over nor its theme
+                        // shows through the incoming hole.
+                        return [4 /*yield*/, incoming.show(this.isFocused, function () {
+                                if (outgoing) {
+                                    outgoing.hide();
+                                    isOutgoingHidden = true;
+                                }
+                            }, this.showAfterRevealMs())];
+                    case 1:
+                        // The new is shown before the old is hidden: an incoming surface's
+                        // frame is revealed over its open hole and the outgoing frame hidden
+                        // in that same task, so neither the outgoing paint-over nor its theme
+                        // shows through the incoming hole.
+                        _a.sent();
+                        if (!(outgoing && !incoming.wasRemoved())) return [3 /*break*/, 3];
+                        return [4 /*yield*/, incoming.waitForFirstPaint(delayMs)];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        if (!outgoing) return [3 /*break*/, 5];
+                        if (!isOutgoingHidden) {
+                            outgoing.hide();
+                        }
+                        return [4 /*yield*/, outgoing.remove()];
+                    case 4:
+                        _a.sent();
+                        _a.label = 5;
+                    case 5: return [2 /*return*/];
+                }
+            });
+        }); })();
+    };
     PlaylistWindowManager.prototype.evalRuleEngine = function (warnIfPreloadMismatch) {
         if (warnIfPreloadMismatch === void 0) { warnIfPreloadMismatch = true; }
         var logger = this.options.logger;

package/build/PlaylistWindowManager.test.d.ts

@@ -0,0 +1 @@
+export {};