@rokt/dcui-orchestrator 0.0.2-rc.0

package/node_modules/@rokt/kit/testing/promise-state.js

@@ -0,0 +1,29 @@
+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) {
+        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());
+    });
+};
+export const PromiseState = {
+    Pending: 'Pending',
+    Resolved: 'Resolved',
+    Rejected: 'Rejected',
+};
+const key = {};
+export const getPromiseState = (target) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const result = yield Promise.race([target, Promise.resolve(key)]);
+        if (result === key) {
+            return PromiseState.Pending;
+        }
+        else {
+            return PromiseState.Resolved;
+        }
+    }
+    catch (error) {
+        return PromiseState.Rejected;
+    }
+});

package/node_modules/@rokt/kit/time/constants.d.ts

@@ -0,0 +1,5 @@
+export type Duration = number;
+export declare const millisecond: Duration;
+export declare const second: Duration;
+export declare const minute: Duration;
+export declare const hour: Duration;

package/node_modules/@rokt/kit/time/constants.js

@@ -0,0 +1,4 @@
+export const millisecond = 1;
+export const second = 1000 * millisecond;
+export const minute = 60 * second;
+export const hour = 60 * minute;

package/node_modules/@rokt/kit/time/index.barrel.d.ts

@@ -0,0 +1,3 @@
+export * from './is-iso-date';
+export * from './sleep';
+export * from './constants';

package/node_modules/@rokt/kit/time/index.barrel.js

@@ -0,0 +1,3 @@
+export * from './is-iso-date';
+export * from './sleep';
+export * from './constants';

package/node_modules/@rokt/kit/time/index.d.ts

@@ -0,0 +1,2 @@
+import * as time from './index.barrel';
+export { time };

package/node_modules/@rokt/kit/time/index.js

@@ -0,0 +1,2 @@
+import * as time from './index.barrel';
+export { time };

package/node_modules/@rokt/kit/time/is-iso-date.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Test whether a `string` is an ISO date.
+ *
+ * @param {String} input
+ */
+export declare const isIsoDate: (input: string) => boolean;

package/node_modules/@rokt/kit/time/is-iso-date.js

@@ -0,0 +1,13 @@
+// Source: https://github.com/segmentio/isostring/blob/master/index.js
+const matcher = new RegExp('^\\d{4}-\\d{2}-\\d{2}' + // Match YYYY-MM-DD
+    '((T\\d{2}:\\d{2}(:\\d{2})?)' + // Match THH:mm:ss
+    '(\\.\\d{1,6})?' + // Match .sssss
+    '(Z|(\\+|-)\\d{2}:\\d{2})?)?$');
+/**
+ * Test whether a `string` is an ISO date.
+ *
+ * @param {String} input
+ */
+export const isIsoDate = (input) => {
+    return typeof input === 'string' && matcher.test(input) && !isNaN(Date.parse(input));
+};

package/node_modules/@rokt/kit/time/sleep.d.ts

@@ -0,0 +1 @@
+export declare const sleep: (ms?: number) => Promise<void>;

package/node_modules/@rokt/kit/time/sleep.js

@@ -0,0 +1 @@
+export const sleep = (ms = 0) => new Promise((res) => setTimeout(res, ms));

package/node_modules/@rokt/kit/typings/basic-type.d.ts

@@ -0,0 +1,6 @@
+export type BasicType = string | number | boolean | undefined | void;
+export type BasicArray = Array<BasicType> | Array<BasicObject> | Array<BasicArray>;
+export type BasicObject = {
+    [key: string]: BasicType | BasicObject | Array<BasicObject> | Array<BasicType>;
+};
+export type BasicObjectArray = BasicObject | BasicArray;

package/node_modules/@rokt/kit/typings/basic-type.js

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

package/node_modules/@rokt/kit/typings/cast-to-enum.d.ts

@@ -0,0 +1 @@
+export declare const castToEnum: <T>(valueToCast: any, sourceEnum: T, fallbackValue?: T[keyof T] | undefined) => T[keyof T];

package/node_modules/@rokt/kit/typings/cast-to-enum.js

@@ -0,0 +1,10 @@
+export const castToEnum = (valueToCast, sourceEnum, fallbackValue) => {
+    if ((valueToCast === null || valueToCast === undefined) && fallbackValue !== undefined) {
+        return fallbackValue;
+    }
+    // @ts-expect-error - TS doesn't support Object.values on generics
+    if (Object.values(sourceEnum).includes(valueToCast)) {
+        return valueToCast;
+    }
+    throw new Error('ValueDoesNotExistInEnum');
+};

package/node_modules/@rokt/kit/typings/deep-partial.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Same as Partial<T> but goes deeper and makes Partial<T> all its properties and sub-properties.
+ *
+ * Extracted from https://github.com/typeorm/typeorm/blob/master/src/common/DeepPartial.ts
+ */
+export type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends Array<infer U> ? Array<DeepPartial<U>> : T[P] extends ReadonlyArray<infer V> ? ReadonlyArray<DeepPartial<V>> : DeepPartial<T[P]>;
+};

package/node_modules/@rokt/kit/typings/deep-partial.js

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

package/node_modules/@rokt/kit/typings/deep-readonly.d.ts

@@ -0,0 +1,3 @@
+export type DeepReadonly<T> = {
+    readonly [P in keyof T]: DeepReadonly<T[P]>;
+};

package/node_modules/@rokt/kit/typings/deep-readonly.js

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

package/node_modules/@rokt/kit/typings/index.barrel.d.ts

@@ -0,0 +1,8 @@
+export * from './basic-type';
+export * from './cast-to-enum';
+export * from './deep-readonly';
+export * from './deep-partial';
+export * from './nullable';
+export * from './omit';
+export * from './promisify';
+export * from './resolved-promise';

package/node_modules/@rokt/kit/typings/index.barrel.js

@@ -0,0 +1,8 @@
+export * from './basic-type';
+export * from './cast-to-enum';
+export * from './deep-readonly';
+export * from './deep-partial';
+export * from './nullable';
+export * from './omit';
+export * from './promisify';
+export * from './resolved-promise';

package/node_modules/@rokt/kit/typings/index.d.ts

@@ -0,0 +1,3 @@
+import * as typings from './index.barrel';
+export { typings };
+export * from './index.barrel';

package/node_modules/@rokt/kit/typings/index.js

@@ -0,0 +1,3 @@
+import * as typings from './index.barrel';
+export { typings };
+export * from './index.barrel';

package/node_modules/@rokt/kit/typings/nullable.d.ts

@@ -0,0 +1,3 @@
+export type Nullable<T> = {
+    [P in keyof T]: T[P] | null;
+};

package/node_modules/@rokt/kit/typings/nullable.js

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

package/node_modules/@rokt/kit/typings/omit.d.ts

@@ -0,0 +1 @@
+export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;

package/node_modules/@rokt/kit/typings/omit.js

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

package/node_modules/@rokt/kit/typings/promisify.d.ts

@@ -0,0 +1,3 @@
+export type Promisify<T> = {
+    [K in keyof T]: T[K] extends (...args: any) => any ? (...args: Parameters<T[K]>) => Promise<ReturnType<T[K]>> : T[K];
+};

package/node_modules/@rokt/kit/typings/promisify.js

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

package/node_modules/@rokt/kit/typings/resolved-promise.d.ts

@@ -0,0 +1 @@
+export type PromiseValue<T extends Promise<any>> = T extends Promise<infer U> ? U : never;

package/node_modules/@rokt/kit/typings/resolved-promise.js

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

package/node_modules/@rokt/kit/urls/index.barrel.d.ts

@@ -0,0 +1,4 @@
+export * from './validator';
+export * from './replace-origin';
+export * from './match-origin';
+export * from './parse-url';

package/node_modules/@rokt/kit/urls/index.barrel.js

@@ -0,0 +1,4 @@
+export * from './validator';
+export * from './replace-origin';
+export * from './match-origin';
+export * from './parse-url';

package/node_modules/@rokt/kit/urls/index.d.ts

@@ -0,0 +1,2 @@
+import * as urls from './index.barrel';
+export { urls };

package/node_modules/@rokt/kit/urls/index.js

@@ -0,0 +1,2 @@
+import * as urls from './index.barrel';
+export { urls };

package/node_modules/@rokt/kit/urls/match-origin.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Verify the origins of two URLs match.
+ */
+export declare function matchOrigin(url1: string, url2: string): boolean;

package/node_modules/@rokt/kit/urls/match-origin.js

@@ -0,0 +1,7 @@
+import { UrlValidator } from './validator';
+/**
+ * Verify the origins of two URLs match.
+ */
+export function matchOrigin(url1, url2) {
+    return new UrlValidator([url1]).verify(url2);
+}

package/node_modules/@rokt/kit/urls/parse-url.d.ts

@@ -0,0 +1,6 @@
+type ParsedUrl = Pick<URL, 'origin' | 'protocol' | 'hostname' | 'port' | 'pathname' | 'search'>;
+/**
+ * Parse the given URL into a partial URL object that is a plain object
+ */
+export declare function parseUrl(url: string): ParsedUrl;
+export {};

package/node_modules/@rokt/kit/urls/parse-url.js

@@ -0,0 +1,16 @@
+const URL_REGEX = /^((:?\/\/|https?:)?(?:\/\/)?(?:[^/]*@)?([a-zA-z\d-\.\*]+?)(:\d{2,5})?)([/][^\?]*?)?([?].*)?$/;
+/**
+ * Parse the given URL into a partial URL object that is a plain object
+ */
+export function parseUrl(url) {
+    var _a;
+    const groups = (_a = URL_REGEX.exec(url)) !== null && _a !== void 0 ? _a : [];
+    return {
+        origin: groups[1],
+        protocol: groups[2],
+        hostname: groups[3],
+        port: groups[4],
+        pathname: groups[5],
+        search: groups[6],
+    };
+}

package/node_modules/@rokt/kit/urls/replace-origin.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Replace the domain in the first URL argument with the domain from the second.
+ * @param url1 - Url who's domain should be replaced.
+ * @param url2 - Url who's domain should be used.
+ */
+export declare function replaceOrigin(url1: string, url2: string): string;

package/node_modules/@rokt/kit/urls/replace-origin.js

@@ -0,0 +1,11 @@
+import { parseUrl } from './parse-url';
+/**
+ * Replace the domain in the first URL argument with the domain from the second.
+ * @param url1 - Url who's domain should be replaced.
+ * @param url2 - Url who's domain should be used.
+ */
+export function replaceOrigin(url1, url2) {
+    const parsedUrl1 = parseUrl(url1);
+    const parsedUrl2 = parseUrl(url2);
+    return parsedUrl1.origin && parsedUrl2.origin ? url1.replace(parsedUrl1.origin, parsedUrl2.origin) : url1;
+}

package/node_modules/@rokt/kit/urls/validator.d.ts

@@ -0,0 +1,12 @@
+export interface Validator {
+    verify(origin: string): boolean;
+}
+export declare class UrlValidator implements Validator {
+    private whitelist;
+    constructor(whitelist: ReadonlyArray<string>);
+    verify(origin: string): boolean;
+    private _parseOrigin;
+    private _matchHostname;
+    private _matchOrigin;
+}
+export declare const createValidator: (whitelist: Array<string>) => UrlValidator;

package/node_modules/@rokt/kit/urls/validator.js

@@ -0,0 +1,58 @@
+import { parseUrl } from './parse-url';
+export class UrlValidator {
+    constructor(whitelist) {
+        this.whitelist = whitelist;
+    }
+    verify(origin) {
+        return this.whitelist.some((whitelist) => this._matchOrigin(whitelist, origin));
+    }
+    _parseOrigin(origin) {
+        const normalisedOrigin = origin === null || origin === void 0 ? void 0 : origin.trim().toLowerCase();
+        const result = parseUrl(normalisedOrigin);
+        if (!result || !result.hostname) {
+            return null;
+        }
+        const { protocol, hostname, port } = result;
+        return [protocol, hostname, port];
+    }
+    _matchHostname(whitelistedHostname, targetHostname) {
+        if (!whitelistedHostname || !targetHostname) {
+            return false;
+        }
+        const whitelist = whitelistedHostname.split('.');
+        const target = targetHostname.split('.');
+        // The strategy to match hostnames is to progressively match from the TLD down to each subdomain.
+        // If a wildcard subdomain is encountered, accept any remaining subdomains
+        while (whitelist.length > 0) {
+            const currentWhitelist = whitelist.pop();
+            const currentTarget = target.pop();
+            // Wildcards will only be reached if all previous superdomains have successfully matched
+            if (currentWhitelist === '*') {
+                return true;
+            }
+            if (currentWhitelist !== currentTarget) {
+                return false;
+            }
+        }
+        // Not a match if the target has remaining unmatched subdomains
+        if (target.length > 0) {
+            return false;
+        }
+        return true;
+    }
+    _matchOrigin(whitelistedOrigin, targetOrigin) {
+        const parsedWhitelist = this._parseOrigin(whitelistedOrigin);
+        const parsedOrigin = this._parseOrigin(targetOrigin);
+        // Return false if either origins failed to parse
+        if (parsedWhitelist === null || parsedOrigin === null) {
+            return false;
+        }
+        const [whitelistedProtocol, whitelistedHostname, whitelistedPort] = parsedWhitelist;
+        const [targetProtocol, targetHostname, targetPort] = parsedOrigin;
+        // Match Protocol, Hostname and Port
+        return (whitelistedProtocol === targetProtocol &&
+            this._matchHostname(whitelistedHostname, targetHostname) &&
+            whitelistedPort === targetPort);
+    }
+}
+export const createValidator = (whitelist) => new UrlValidator(whitelist);

package/node_modules/@rokt/kit/weblink/__tests__/counter.d.ts

@@ -0,0 +1,8 @@
+export declare class Counter {
+    private total;
+    private onDone;
+    done: boolean;
+    private ticks;
+    constructor(total: number, onDone: () => void);
+    tick(): void;
+}

package/node_modules/@rokt/kit/weblink/__tests__/counter.js

@@ -0,0 +1,15 @@
+export class Counter {
+    constructor(total, onDone) {
+        this.total = total;
+        this.onDone = onDone;
+        this.done = false;
+        this.ticks = 0;
+    }
+    tick() {
+        this.ticks++;
+        if (this.ticks === this.total) {
+            this.done = true;
+            this.onDone();
+        }
+    }
+}

package/node_modules/@rokt/kit/weblink/__tests__/event-listener.d.ts

@@ -0,0 +1,9 @@
+import { Subject } from '../../reactive';
+export declare class EventListener {
+    onEvent: Subject<void>;
+    private subs;
+    triggerRaw(event: any): void;
+    trigger(data: any): void;
+    addEventListener(_type: string, callback: (event: any) => any): void;
+    removeEventListener(_type: string, callback: (event: any) => any): void;
+}

package/node_modules/@rokt/kit/weblink/__tests__/event-listener.js

@@ -0,0 +1,31 @@
+import { Subject } from '../../reactive';
+export class EventListener {
+    constructor() {
+        this.onEvent = new Subject();
+        this.subs = [];
+    }
+    // triggerRaw is used to emit an event from the event listener
+    triggerRaw(event) {
+        setTimeout(() => this.onEvent.next(event), 0);
+    }
+    // Trigger will emit an event but assign the values to the data attribute, as would be the case in the DOM
+    trigger(data) {
+        this.triggerRaw({ data });
+    }
+    addEventListener(_type, callback) {
+        const sub = {
+            callback,
+            subscription: this.onEvent.subscribe((event) => setTimeout(() => callback(event), 0)),
+        };
+        this.subs.push(sub);
+    }
+    removeEventListener(_type, callback) {
+        for (const i in this.subs) {
+            if (callback !== this.subs[i].callback) {
+                continue;
+            }
+            this.subs[i].subscription.unsubscribe();
+            this.subs.splice(parseInt(i, 10), 1);
+        }
+    }
+}

package/node_modules/@rokt/kit/weblink/__tests__/index.d.ts

@@ -0,0 +1,7 @@
+export * from './message-port';
+export * from './message-channel';
+export * from './post-messenger';
+export * from './page';
+export * from './tick';
+export * from './window-link-mock';
+export * from './target-window';

package/node_modules/@rokt/kit/weblink/__tests__/index.js

@@ -0,0 +1,7 @@
+export * from './message-port';
+export * from './message-channel';
+export * from './post-messenger';
+export * from './page';
+export * from './tick';
+export * from './window-link-mock';
+export * from './target-window';

package/node_modules/@rokt/kit/weblink/__tests__/message-channel.d.ts

@@ -0,0 +1,6 @@
+import { MockPort } from './message-port';
+export declare class MockMessageChannel {
+    port1: MockPort;
+    port2: MockPort;
+    constructor();
+}

package/node_modules/@rokt/kit/weblink/__tests__/message-channel.js

@@ -0,0 +1,9 @@
+import { MockPort } from './message-port';
+export class MockMessageChannel {
+    constructor() {
+        this.port1 = new MockPort('port1');
+        this.port2 = new MockPort('port2');
+        this.port1.onPostMessage.subscribe((e) => this.port2.recieveMessage(e));
+        this.port2.onPostMessage.subscribe((e) => this.port1.recieveMessage(e));
+    }
+}

package/node_modules/@rokt/kit/weblink/__tests__/message-port.d.ts

@@ -0,0 +1,17 @@
+import { Subject } from '../../reactive';
+import { EventListener } from './event-listener';
+export declare class MockPort {
+    meta?: any;
+    onPostMessage: Subject<void>;
+    listener: EventListener;
+    hasStarted: boolean;
+    hasClosed: boolean;
+    buffer: Array<any>;
+    get addEventListener(): (_type: string, callback: (event: any) => any) => void;
+    get removeEventListener(): (_type: string, callback: (event: any) => any) => void;
+    constructor(meta?: any);
+    start(): void;
+    close(): void;
+    recieveMessage(msg: any): void;
+    postMessage(msg: any): void;
+}

package/node_modules/@rokt/kit/weblink/__tests__/message-port.js

@@ -0,0 +1,41 @@
+import { Subject } from '../../reactive';
+import { EventListener } from './event-listener';
+export class MockPort {
+    get addEventListener() {
+        return this.listener.addEventListener.bind(this.listener);
+    }
+    get removeEventListener() {
+        return this.listener.removeEventListener.bind(this.listener);
+    }
+    constructor(meta) {
+        this.meta = meta;
+        this.onPostMessage = new Subject();
+        this.listener = new EventListener();
+        this.hasStarted = false;
+        this.hasClosed = false;
+        this.buffer = [];
+    }
+    start() {
+        this.hasStarted = true;
+        for (const msg of this.buffer) {
+            this.listener.trigger(msg);
+        }
+        this.buffer = [];
+    }
+    close() {
+        this.hasClosed = true;
+    }
+    recieveMessage(msg) {
+        if (this.hasClosed) {
+            return;
+        }
+        if (this.hasStarted === false) {
+            this.buffer.push(msg);
+            return;
+        }
+        this.listener.trigger(msg);
+    }
+    postMessage(msg) {
+        this.onPostMessage.next(msg);
+    }
+}

package/node_modules/@rokt/kit/weblink/__tests__/page.d.ts

@@ -0,0 +1,3 @@
+export declare class Page {
+    script(cb: () => void): Promise<void>;
+}

package/node_modules/@rokt/kit/weblink/__tests__/page.js

@@ -0,0 +1,19 @@
+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) {
+        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());
+    });
+};
+export class Page {
+    script(cb) {
+        return new Promise((res) => {
+            setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                yield Promise.resolve(cb());
+                res();
+            }), 0);
+        });
+    }
+}

package/node_modules/@rokt/kit/weblink/__tests__/post-messenger.d.ts

@@ -0,0 +1,12 @@
+import { EventListener } from './event-listener';
+export declare class MockPostMessenger {
+    name: string;
+    source: any;
+    listener: EventListener;
+    get addEventListener(): (_type: string, callback: (event: any) => any) => void;
+    get removeEventListener(): (_type: string, callback: (event: any) => any) => void;
+    private postMessengers;
+    constructor(name?: string);
+    addEventSource(pm: MockPostMessenger): void;
+    postMessage(msg: any, _origin?: string, transferable?: Array<any>): void;
+}

package/node_modules/@rokt/kit/weblink/__tests__/post-messenger.js

@@ -0,0 +1,37 @@
+import { EventListener } from './event-listener';
+import { MockPort } from './message-port';
+export class MockPostMessenger {
+    get addEventListener() {
+        return this.listener.addEventListener.bind(this.listener);
+    }
+    get removeEventListener() {
+        return this.listener.removeEventListener.bind(this.listener);
+    }
+    constructor(name = '') {
+        this.name = name;
+        this.source = undefined;
+        this.listener = new EventListener();
+        this.postMessengers = [];
+    }
+    addEventSource(pm) {
+        this.postMessengers.push(pm);
+    }
+    postMessage(msg, _origin, transferable = []) {
+        if (transferable[0] && transferable[0] instanceof MockPort) {
+            transferable[0].hasStarted = false;
+            transferable[0].buffer = [];
+        }
+        this.listener.triggerRaw({
+            data: msg,
+            ports: transferable,
+            source: this.source,
+        });
+        for (const postMessenger of this.postMessengers) {
+            this.listener.triggerRaw({
+                data: msg,
+                ports: transferable,
+                source: postMessenger,
+            });
+        }
+    }
+}

package/node_modules/@rokt/kit/weblink/__tests__/target-window.d.ts

@@ -0,0 +1,7 @@
+import { MockMessageChannel } from './message-channel';
+import { MockPostMessenger } from './post-messenger';
+export declare class TargetWindow extends MockPostMessenger {
+    location: URL;
+    MessageChannel: typeof MockMessageChannel;
+    script(cb: () => void): Promise<void>;
+}

package/node_modules/@rokt/kit/weblink/__tests__/target-window.js

@@ -0,0 +1,26 @@
+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) {
+        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());
+    });
+};
+import { MockMessageChannel } from './message-channel';
+import { MockPostMessenger } from './post-messenger';
+export class TargetWindow extends MockPostMessenger {
+    constructor() {
+        super(...arguments);
+        this.location = new URL('http://localhost');
+        this.MessageChannel = MockMessageChannel;
+    }
+    script(cb) {
+        return new Promise((res) => {
+            setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                yield Promise.resolve(cb());
+                res();
+            }), 0);
+        });
+    }
+}