@kalamba/sdk 0.1.0

package/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2024, Kalamba Games Limited
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,28 @@
+# Kalamba SDK
+
+## Getting Started
+
+### Overview
+
+Kalamba SDK is a toolkit designed to handle frontend communication between the Game Client, the Casino Frontend, the Telemetry Service, and the RGS.
+
+### Installation
+
+#### NPM
+
+```bash
+npm install @kalamba/sdk
+```
+
+#### Requirements
+
+Kalamba SDK uses the following APIs:
+
+- [Promises](https://caniuse.com/promises)
+- [postMessage](https://caniuse.com/x-doc-messaging)
+
+Click above links to check Browser compatibility.
+
+### Documentation
+
+Documentation can be found [here](https://docs.kalamba.games/sdk/)

package/dist/index.cjs

@@ -0,0 +1,5 @@
+/**
+ * BSD 3-Clause License
+ * Copyright (c) 2024, Kalamba Games Limited
+ */
+"use strict";var E=Object.defineProperty;var w=(s,e,r)=>e in s?E(s,e,{enumerable:!0,configurable:!0,writable:!0,value:r}):s[e]=r;var i=(s,e,r)=>(w(s,typeof e!="symbol"?e+"":e,r),r),m=(s,e,r)=>{if(!e.has(s))throw TypeError("Cannot "+r)};var u=(s,e,r)=>(m(s,e,"read from private field"),r?r.call(s):e.get(s)),p=(s,e,r)=>{if(e.has(s))throw TypeError("Cannot add the same private member more than once");e instanceof WeakSet?e.add(s):e.set(s,r)},l=(s,e,r,o)=>(m(s,e,"write to private field"),o?o.call(s,r):e.set(s,r),r);Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const g=()=>{};class d extends Error{constructor(r){super("OpenGameError");i(this,"error");this.name="OpenGameError",this.error=r}}class h extends Error{constructor(r){super("PlayError");i(this,"error");this.name="PlayError",this.error=r}}class c extends Error{constructor(){super("TimeoutError"),this.name="TimeoutError"}}var a;class f{constructor({messagePort:e}){i(this,"config");p(this,a,void 0);l(this,a,e),this.on("configured",r=>{this.config=r})}request(e,...[r]){return new Promise(o=>{this.on(`${e}Response`,t=>o({type:"response",response:t}),{once:!0}),this.on(`${e}Error`,t=>o({type:"error",error:t}),{once:!0}),this.send(e,r)})}on(e,r,o){const t=function y(n){n.data.message===`kalamba:wrapper:${e}`&&(g("on",n.data.message.replace(/^kalamba:/,""),n.data.payload),r(n.data.payload),o!=null&&o.once&&window.removeEventListener("message",y))};window.addEventListener("message",t)}send(e,...[r]){u(this,a).postMessage({message:`kalamba:sdk:${e}`,payload:r},"*")}async openGame(e){var o;const[,r]=await Promise.all([new Promise(t=>this.on("configured",t,{once:!0})),this.request("openGame",e)]);if(r.type==="response")return r.response;throw((o=r.error)==null?void 0:o.type)==="timeout"?new c:new d(r.error)}async play(e){var o;const r=await this.request("play",e);if(r.type==="response")return r.response;throw((o=r.error)==null?void 0:o.type)==="timeout"?new c:new h(r.error)}}a=new WeakMap;exports.KalambaSdk=f;exports.OpenGameError=d;exports.PlayError=h;exports.TimeoutError=c;

package/dist/index.d.ts

@@ -0,0 +1,384 @@
+declare interface AddEventListenerOptions_2 {
+    once: boolean;
+}
+
+export declare type AutoplayLimit = {
+    enabled: boolean;
+    showNoLimit: boolean;
+    showCustomLimit: boolean;
+    options: number[];
+};
+
+export declare type Bet = {
+    base: number;
+    multiplier: number;
+};
+
+export declare type Cashier = {
+    type: 'ON_DEMAND' | 'BALANCE_LOW' | 'BALANCE_INSUFFICIENT';
+};
+
+export declare type CashierConfig = {
+    enabled: boolean;
+    balanceThreshold: number[];
+};
+
+export declare type CasinoOnlyMessagePayloadMap = {
+    balance: {
+        balance: number;
+    };
+    bet: Bet;
+    cashier: Cashier;
+    choice: {
+        id: string;
+    };
+    close: never;
+    freeze: never;
+    help: {
+        show?: boolean;
+    };
+    history: History_2;
+    paytable: {
+        show?: boolean;
+    };
+    play: PlayRequest;
+    resume: never;
+    settings: Settings;
+    suspend: never;
+    unfreeze: never;
+};
+
+export declare type DomainAllowedPayloadMap<P extends DomainPrefix> = DomainToMessagePayloadMap[P];
+
+export declare type DomainMessage<P extends DomainPrefix> = keyof DomainAllowedPayloadMap<P>;
+
+export declare type DomainMessageMessageEvent<P extends DomainPrefix, M extends DomainMessage<P>> = MessageEvent<{
+    message: M;
+    payload: DomainMessagePayload<P, M>;
+}>;
+
+export declare type DomainMessagePayload<P extends DomainPrefix, M extends DomainMessage<P>> = DomainAllowedPayloadMap<P>[M];
+
+export declare type DomainPrefix = keyof DomainToMessagePayloadMap & string;
+
+export declare type DomainToMessagePayloadMap = {
+    sdk: SdkOnlyMessagePayloadMap;
+    wrapper: WrapperOnlyMessagePayloadMap;
+    casino: CasinoOnlyMessagePayloadMap;
+    rgs: RgsOnlyMessagePayloadMap;
+    telemetry: TelemetryOnlyMessagePayloadMap;
+};
+
+declare type Error_2 = {
+    message: string;
+    messageKey: string;
+    type: 'CLOSE' | 'RELOAD' | 'CONTINUE';
+};
+export { Error_2 as Error }
+
+export declare type ForwardToPluginsMessage<P extends PluginDomain> = keyof ForwardToPluginsMessageMap<'sdk'>[P] | keyof ForwardToPluginsMessageMap<'rgs'>[P] | keyof ForwardToPluginsMessageMap<'casino'>[P] | keyof ForwardToPluginsMessageMap<'telemetry'>[P];
+
+export declare interface ForwardToPluginsMessageMap<SourceDomain extends DomainPrefix> {
+    casino: ToCasinoPluginsForwardedMessageMap[SourceDomain];
+    rgs: ToRgsPluginsForwardedMessageMap[SourceDomain];
+    telemetry: ToTelemetryPluginsForwardedMessageMap[SourceDomain];
+}
+
+export declare type ForwardToPluginsMessagePayload<P extends PluginDomain, M extends ForwardToPluginsMessage<P>> = ForwardToPluginsMessageMap<'sdk'>[P][M] & ForwardToPluginsMessageMap<'rgs'>[P][M] & ForwardToPluginsMessageMap<'casino'>[P][M] & ForwardToPluginsMessageMap<'telemetry'>[P][M];
+
+export declare type ForwardToSdkMessage = keyof ToSdkForwardedMessageMap;
+
+export declare type ForwardToSdkMessagePayload<M extends ForwardToSdkMessage> = ToSdkForwardedMessageMap[M];
+
+declare type History_2 = {
+    source: 'realityCheck' | 'settings' | 'casino';
+};
+export { History_2 as History }
+
+export declare class KalambaSdk {
+    #private;
+    config: SdkConfig;
+    constructor({ messagePort }: {
+        messagePort: Window;
+    });
+    protected request<M extends DomainMessage<'sdk'>>(message: M, ...[payload]: DomainMessagePayload<'sdk', M> extends never ? [] : [payload: DomainMessagePayload<'sdk', M>]): Promise<RgsResponse<M>>;
+    on<M extends DomainMessage<'wrapper'> | ForwardToSdkMessage>(message: M, listener: (payload: M extends DomainMessage<'wrapper'> ? DomainMessagePayload<'wrapper', M> : M extends ForwardToSdkMessage ? ForwardToSdkMessagePayload<M> : never) => void, options?: AddEventListenerOptions_2): void;
+    send<M extends DomainMessage<'sdk'>>(message: M, ...[payload]: DomainMessagePayload<'sdk', M> extends never ? [] : [DomainMessagePayload<'sdk', M>]): void;
+    openGame(payload: DomainMessagePayload<'sdk', 'openGame'>): Promise<OpenGameResponse>;
+    play(payload: DomainMessagePayload<'sdk', 'play'>): Promise<PlayResponse>;
+}
+
+export declare type Message = keyof MessageMap;
+
+export declare type MessageMap = DomainAllowedPayloadMap<'sdk'> & DomainAllowedPayloadMap<'wrapper'> & DomainAllowedPayloadMap<'casino'> & DomainAllowedPayloadMap<'rgs'> & DomainAllowedPayloadMap<'telemetry'> & PrefixedMessageMap;
+
+export declare type MessageMessageEvent<M extends Message> = MessageEvent<{
+    message: M;
+    payload: MessagePayload<M>;
+}>;
+
+export declare type MessagePayload<M extends Message> = MessageMap[M];
+
+export declare class OpenGameError extends Error {
+    error: any;
+    constructor(error: any);
+}
+
+declare type OpenGameError_2 = {
+    data: any;
+    type?: string;
+};
+
+export declare type OpenGameRequest = {
+    gameName: string;
+    version: string;
+};
+
+export declare type OpenGameResponse = {
+    balance: number;
+    data: any;
+};
+
+export declare class PlayError extends Error {
+    error: any;
+    constructor(error: any);
+}
+
+declare type PlayError_2 = {
+    data: any;
+    type?: string;
+};
+
+export declare type PlayRequest = {
+    bet: Bet;
+} | {
+    userInput: unknown;
+} | {
+    opaqueGameAttributes: unknown;
+};
+
+export declare type PlayResponse = {
+    balance: number;
+    data: any;
+};
+
+export declare type PluginDomain = keyof ForwardToPluginsMessageMap<any>;
+
+export declare type PrefixedForwardToPluginsMessage<P extends PluginDomain> = PrefixTypes<keyof ForwardToPluginsMessageMap<'sdk'>[P], 'sdk'> | PrefixTypes<keyof ForwardToPluginsMessageMap<'rgs'>[P], 'rgs'> | PrefixTypes<keyof ForwardToPluginsMessageMap<'casino'>[P], 'casino'> | PrefixTypes<keyof ForwardToPluginsMessageMap<'telemetry'>[P], 'telemetry'>;
+
+export declare type PrefixedMessage = keyof PrefixedMessageMap;
+
+export declare type PrefixedMessageMap = PrefixedMessagePayloadMap<'sdk'> & PrefixedMessagePayloadMap<'wrapper'> & PrefixedMessagePayloadMap<'casino'> & PrefixedMessagePayloadMap<'rgs'> & PrefixedMessagePayloadMap<'telemetry'>;
+
+export declare type PrefixedMessageMessageEvent<M extends PrefixedMessage> = MessageEvent<{
+    message: M;
+    payload: PrefixedMessagePayload<M>;
+}>;
+
+export declare type PrefixedMessagePayload<M extends PrefixedMessage> = PrefixedMessageMap[M];
+
+export declare type PrefixedMessagePayloadMap<P extends DomainPrefix> = PrefixKeys<DomainToMessagePayloadMap[P], P>;
+
+declare type PrefixKeys<Base, Prefix extends string> = {
+    [Key in keyof Base as `${Prefix}:${string & Key}`]: Base[Key];
+};
+
+declare type PrefixTypes<Types, Prefix extends string> = `${Prefix}:${Types}`;
+
+export declare type RealityCheckConfig = {
+    sessionDurationPeriodFormat: 'seconds' | 'minutes' | 'hours';
+    showCloseGame: boolean;
+    showHistory: boolean;
+    showNetPosition: boolean;
+    showSessionDuration: boolean;
+    showSumBets: boolean;
+    showSumWins: boolean;
+};
+
+export declare type RgsOnlyMessagePayloadMap = {
+    openGameError: OpenGameError_2;
+    openGameResponse: OpenGameResponse;
+    playError: PlayError_2;
+    playResponse: PlayResponse;
+    realityCheck: {
+        duration: number;
+        sumBetAmount: number;
+        sumWinAmount: number;
+    };
+};
+
+export declare type RgsResponse<M extends DomainMessage<'sdk'>> = `${M}Response` extends DomainMessage<'rgs'> ? {
+    type: 'response';
+    response: DomainMessagePayload<'rgs', `${M}Response`>;
+} | {
+    type: 'error';
+    error: DomainMessagePayload<'rgs', `${M}Error`>;
+} : never;
+
+export declare interface SdkConfig {
+    api: {
+        brand: string;
+        cashierUrl?: string;
+        coinValueInCents: number;
+        country: string;
+        currency: string;
+        game: string;
+        gameHistoryUrl: string;
+        homeUrl?: string;
+        integration: string;
+        integrationData?: unknown;
+        jurisdiction: string;
+        playMode: 'FUN' | 'REAL';
+        user: string;
+    };
+    ui: {
+        autoplay: {
+            enabled: boolean;
+            rounds: AutoplayLimit;
+            lossLimit: AutoplayLimit;
+            winLimit: AutoplayLimit;
+            simple: boolean;
+            stopOnFeature: boolean;
+        };
+        cashier: CashierConfig;
+        feature: {
+            allowTelemetry: boolean;
+            allowFullscreen: boolean;
+            allowQuickStop: boolean;
+            showCashier: boolean;
+            showClock: boolean;
+            showCloseGame: boolean;
+            showCurrency: boolean;
+            showFastPlay: boolean;
+            showFeatureBuy: boolean;
+            showFeatureIntro: boolean;
+            showFeatureOutro: boolean;
+            showFunModeBanner: boolean;
+            showHistory: boolean;
+            showLowWinCelebration: boolean;
+            showMaximumWin: boolean;
+            showNetPosition: boolean;
+            showPaylineLines: boolean;
+            showPaytable: boolean;
+            showRoundId: boolean;
+            showRtp: boolean;
+            showRules: boolean;
+            showSessionDuration: boolean;
+            showUi: boolean;
+        };
+        language: string;
+        maximumBet?: number;
+        minimumSpinDuration: number;
+        requestTimeoutMs: number;
+        realityCheck: RealityCheckConfig;
+        skipInsufficientFundsCheck: boolean;
+        skipSplash: boolean;
+    };
+}
+
+export declare type SdkOnlyMessagePayloadMap = {
+    autoplay: {
+        action: 'start' | 'stop' | 'pause' | 'resume';
+    };
+    balance: {
+        balance: number;
+    };
+    bet: Bet;
+    cashier: Cashier;
+    choice: {
+        message: string;
+        options: {
+            id: string;
+            label: string;
+        }[];
+    };
+    close: never;
+    error: Error_2;
+    fullscreen: {
+        lock?: OrientationLockType;
+    };
+    history: History_2;
+    loadEnd: never;
+    loadProgress: {
+        progress: number;
+    };
+    loadStart: never;
+    openGame: OpenGameRequest;
+    play: PlayRequest;
+    playCycleEnd: PlayResponse;
+    playCycleStart: PlayRequest;
+    playEnd: PlayResponse;
+    playReady: {
+        ready: boolean;
+    };
+    playStart: PlayRequest;
+    translations: Record<string, Record<string, string>>;
+    settings: Settings;
+    'telemetry.click': {
+        location: string;
+        name: string;
+    };
+    'telemetry.orientationChange': never;
+};
+
+export declare type Settings = {
+    fastPlay?: boolean;
+    fastPlaySpeed?: number;
+    sounds?: boolean;
+    music?: boolean;
+};
+
+export declare type TelemetryOnlyMessagePayloadMap = {
+    [key: string]: unknown;
+};
+
+export declare class TimeoutError extends Error {
+    constructor();
+}
+
+export declare type ToCasinoPluginsForwardedMessageMap = {
+    sdk: Pick<SdkOnlyMessagePayloadMap, 'autoplay' | 'balance' | 'bet' | 'cashier' | 'choice' | 'close' | 'error' | 'history' | 'loadEnd' | 'loadProgress' | 'loadStart' | 'openGame' | 'play' | 'playCycleEnd' | 'playCycleStart' | 'playEnd' | 'playReady' | 'playStart' | 'settings'>;
+    casino: undefined;
+    rgs: Pick<RgsOnlyMessagePayloadMap, 'playResponse' | 'playError' | 'openGameResponse'>;
+    telemetry: undefined;
+    wrapper: undefined;
+};
+
+export declare type ToRgsPluginsForwardedMessageMap = {
+    sdk: Pick<SdkOnlyMessagePayloadMap, 'history' | 'openGame' | 'play'>;
+    casino: Pick<CasinoOnlyMessagePayloadMap, 'play' | 'cashier' | 'close' | 'history'>;
+    rgs: undefined;
+    telemetry: undefined;
+    wrapper: undefined;
+};
+
+export declare type ToSdkForwardedMessageMap = Pick<CasinoOnlyMessagePayloadMap, 'balance' | 'bet' | 'choice' | 'freeze' | 'help' | 'paytable' | 'resume' | 'settings' | 'suspend' | 'unfreeze'> & Pick<RgsOnlyMessagePayloadMap, 'realityCheck' | 'openGameError' | 'openGameResponse' | 'playError' | 'playResponse'>;
+
+export declare type ToTelemetryPluginsForwardedMessageMap = {
+    sdk: Pick<SdkOnlyMessagePayloadMap, 'autoplay' | 'error' | 'loadStart' | 'loadProgress' | 'loadEnd' | 'playCycleStart' | 'playCycleEnd' | 'settings' | 'telemetry.click' | 'telemetry.orientationChange'>;
+    casino: undefined;
+    rgs: Pick<RgsOnlyMessagePayloadMap, 'openGameResponse' | 'openGameError' | 'playResponse' | 'playError'>;
+    telemetry: undefined;
+    wrapper: undefined;
+};
+
+export declare type WrapperOnlyMessagePayloadMap = {
+    bet: Bet;
+    close: never;
+    configured: SdkConfig;
+    freeze: never;
+    history: History_2;
+    resume: never;
+    state: WrapperState;
+    suspend: never;
+    unfreeze: never;
+};
+
+export declare type WrapperState = {
+    balance: number;
+    bet: Bet;
+    gameName: string;
+    version: string;
+};
+
+export { }

package/dist/index.js

@@ -0,0 +1,98 @@
+/**
+ * BSD 3-Clause License
+ * Copyright (c) 2024, Kalamba Games Limited
+ */
+var h = Object.defineProperty;
+var w = (s, r, e) => r in s ? h(s, r, { enumerable: !0, configurable: !0, writable: !0, value: e }) : s[r] = e;
+var i = (s, r, e) => (w(s, typeof r != "symbol" ? r + "" : r, e), e), c = (s, r, e) => {
+  if (!r.has(s))
+    throw TypeError("Cannot " + e);
+};
+var p = (s, r, e) => (c(s, r, "read from private field"), e ? e.call(s) : r.get(s)), m = (s, r, e) => {
+  if (r.has(s))
+    throw TypeError("Cannot add the same private member more than once");
+  r instanceof WeakSet ? r.add(s) : r.set(s, e);
+}, u = (s, r, e, o) => (c(s, r, "write to private field"), o ? o.call(s, e) : r.set(s, e), e);
+const y = () => {
+};
+class E extends Error {
+  constructor(e) {
+    super("OpenGameError");
+    i(this, "error");
+    this.name = "OpenGameError", this.error = e;
+  }
+}
+class g extends Error {
+  constructor(e) {
+    super("PlayError");
+    i(this, "error");
+    this.name = "PlayError", this.error = e;
+  }
+}
+class l extends Error {
+  constructor() {
+    super("TimeoutError"), this.name = "TimeoutError";
+  }
+}
+var a;
+class P {
+  constructor({ messagePort: r }) {
+    // after open game we can be sure that config is set
+    // it's much easier to use it with type `SdkConfig` instead of `SdkConfig | undefined`
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    i(this, "config");
+    m(this, a, void 0);
+    u(this, a, r), this.on("configured", (e) => {
+      this.config = e;
+    });
+  }
+  request(r, ...[e]) {
+    return new Promise((o) => {
+      this.on(`${r}Response`, (t) => o({ type: "response", response: t }), {
+        once: !0
+      }), this.on(`${r}Error`, (t) => o({ type: "error", error: t }), { once: !0 }), this.send(r, e);
+    });
+  }
+  on(r, e, o) {
+    const t = function d(n) {
+      n.data.message === `kalamba:wrapper:${r}` && (y("on", n.data.message.replace(/^kalamba:/, ""), n.data.payload), e(n.data.payload), o != null && o.once && window.removeEventListener("message", d));
+    };
+    window.addEventListener("message", t);
+  }
+  // TODO error messages
+  send(r, ...[e]) {
+    p(this, a).postMessage(
+      {
+        message: `kalamba:sdk:${r}`,
+        payload: e
+      },
+      "*"
+    );
+  }
+  async openGame(r) {
+    var o;
+    const [, e] = await Promise.all([
+      // TODO: return promise from call to this.on if listener is not provided
+      new Promise((t) => this.on("configured", t, { once: !0 })),
+      this.request("openGame", r)
+    ]);
+    if (e.type === "response")
+      return e.response;
+    throw ((o = e.error) == null ? void 0 : o.type) === "timeout" ? new l() : new E(e.error);
+  }
+  async play(r) {
+    var o;
+    const e = await this.request("play", r);
+    if (e.type === "response")
+      return e.response;
+    throw ((o = e.error) == null ? void 0 : o.type) === "timeout" ? new l() : new g(e.error);
+  }
+}
+a = new WeakMap();
+export {
+  P as KalambaSdk,
+  E as OpenGameError,
+  g as PlayError,
+  l as TimeoutError
+};

package/dist/noop-3336849b.js

@@ -0,0 +1,18 @@
+/**
+ * BSD 3-Clause License
+ * Copyright (c) 2024, Kalamba Games Limited
+ */
+var t = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {};
+function e(o) {
+  return o && o.__esModule && Object.prototype.hasOwnProperty.call(o, "default") ? o.default : o;
+}
+function n() {
+}
+var l = n;
+const a = /* @__PURE__ */ e(l);
+export {
+  a,
+  t as c,
+  e as g,
+  l as n
+};

package/dist/noop-b3c54b76.cjs

@@ -0,0 +1,5 @@
+/**
+ * BSD 3-Clause License
+ * Copyright (c) 2024, Kalamba Games Limited
+ */
+"use strict";var t=typeof globalThis<"u"?globalThis:typeof window<"u"?window:typeof global<"u"?global:typeof self<"u"?self:{};function e(o){return o&&o.__esModule&&Object.prototype.hasOwnProperty.call(o,"default")?o.default:o}function l(){}var n=l;const f=e(n);exports.commonjsGlobal=t;exports.getDefaultExportFromCjs=e;exports.noop=f;exports.noop_1=n;