@monterosa/sdk-interact-kit 0.19.0-rc.6 → 2.0.0-rc.2

package/dist/{index.esm.js → index.js}

@@ -1,45 +1,8 @@
-import { getConnect as getConnect$1, login as login$1, connect, disconnect, subscribe as subscribe$1, unsubscribe as unsubscribe$1, send, ConnState, onConnected } from '@monterosa/sdk-connect-kit';
-import { Emitter, memoizePromise, subscribe as subscribe$2, checksum, onTick, now, checkAvailability, calculatePercentage, getItem, setItem, createError } from '@monterosa/sdk-util';
+import { Emitter, memoizePromise, subscribe as subscribe$2, checksum, onTick, now, calculatePercentage, getErrorMessage, createError } from '@monterosa/sdk-util';
+import { getConnect as getConnect$1, connect, disconnect, subscribe as subscribe$1, unsubscribe as unsubscribe$1, send, ConnState, onConnected } from '@monterosa/sdk-connect-kit';
 import { getSdk, Logger } from '@monterosa/sdk-core';
-
-/**
- * @license
- * @monterosa/sdk-interact-kit
- *
- * Copyright © 2023-2024 Monterosa Productions Limited. All rights reserved.
- *
- * More details on the license can be found at https://www.monterosa.co/sdk/license
- */
-/**
- * Sign in the user to submit data that requires a verified user.
- *
- * @example
- * ```javascript
- * try {
- *   const sdk = getSdk();
- *   const userId = "b236e331-ee62-4238-90d0-47588c7facdc";
- *   const timestamp = 1684934960;
- *   const signature = "9ABC4892838DC13986A63B736E95A7D99DF95C72";
- *
- *   await login(sdk, userId, timestamp, signature);
- *
- *   console.log('logged in successfully!');
- * } catch (err) {
- *   console.log(err)
- * }
- * ```
- *
- * @param sdk - Monterosa SDK instance
- * @param userId - The unique user UUID
- * @param timestamp - The timecode when the signature was generated
- * @param signature - A unique identifier that serves as proof of the user's authenticity.
- *  The signature must only contain the following characters: 0-9, a-z, A-Z, and must be uppercased
- * @returns A Promise that resolves with `void` when the login is successful, otherwise it rejects.
- */
-async function login(sdk, userId, timestamp, signature) {
-    const connect = await getConnect$1(sdk.options.host);
-    return login$1(connect, userId, timestamp, signature);
-}
+import { fetchSettings } from '@monterosa/sdk-interact-interop';
+import { storageRead, storageWrite } from '@monterosa/sdk-storage-kit';
 
 /**
  * @license
@@ -219,7 +182,7 @@ var ConnectionHealthState;
     ConnectionHealthState["Ok"] = "ok";
     /**
      * The client is either trying to establish a connection but failing, or
-     * the client has been explicetily {@link @monterosa/sdk-connect-kit#disconnect() | disconnected}
+     * the client has been explicitly {@link @monterosa/sdk-connect-kit#disconnect() | disconnected}
      */
     ConnectionHealthState["Error"] = "error";
 })(ConnectionHealthState || (ConnectionHealthState = {}));
@@ -274,32 +237,24 @@ const getConnectionHealthMemoized = memoizePromise(async (sdk) => {
 }, (sdk) => sdk.options.host);
 /**
  * Returns {@link ConnectionHealth | connection health} instance
+ *
+ * @param sdk - The SDK instance to monitor
+ * @returns The connection health instance.
  */
 function getConnectionHealth(sdk = getSdk()) {
     return getConnectionHealthMemoized(sdk);
 }
 /**
  * Adds an observer for when
- * {@link ConnectionHealth.state | connection health state} changed
+ * {@link ConnectionHealth | connection health state} changed
+ *
+ * @param connectionHealth - The instance to observe
+ * @param callback - Called with the new state
  */
 function onConnectionHealthState(connectionHealth, callback) {
     return subscribe$2(connectionHealth, 'state', callback);
 }
 
-/**
- * @license
- * @monterosa/sdk-interact-kit
- *
- * Copyright © 2022 Monterosa Productions Limited. All rights reserved.
- *
- * More details on the license can be found at https://www.monterosa.co/sdk/license
- */
-async function fetchSettings(host, id) {
-    const response = await fetch(`https://${host}/projects/${id.substring(0, 2)}/${id}/settings.json`);
-    const data = await response.json();
-    return data;
-}
-
 /**
  * @license
  * @monterosa/sdk-interact-kit
@@ -664,36 +619,25 @@ const getProjectMemoized = memoizePromise(async (sdk) => {
     return project;
 }, (sdk) => sdk.options.projectId);
 /**
- * Returns {@link InteractProject | project instance} associated
- * with the {@link @monterosa/sdk-core#MonterosaSdk | configured sdk}
+ * Returns {@link InteractProject | Project instance} associated
+ * with the
+ * {@link @monterosa/sdk-core#MonterosaSdk | configured SDK}
+ *
+ * @param sdk - The SDK instance. Defaults to the default SDK.
+ * @returns The Project instance.
  */
 function getProject(sdk = getSdk()) {
     return getProjectMemoized(sdk);
 }
 /**
- * @internal
- */
-async function fetchListings(host, projectId) {
-    const response = await fetch(`https://${host}/projects/${projectId.substring(0, 2)}/${projectId}/listings.json`);
-    const data = (await response.json());
-    return data;
-}
-/**
- * Adds an observer for when {@link InteractProject.fields |  project fields}
- * are updated
+ * Adds an observer for when
+ * {@link InteractProject | Project fields} are updated
+ *
+ * @param project - The Project to observe
+ * @param callback - Called when Project fields change
  */
 function onProjectFieldsUpdated(project, callback) {
     return subscribe$2(project, 'updated', callback);
-}
-/**
- * Adds an observer that is called when the project listings are updated.
- *
- * @deprecated Use {@link onEventAdded()}, {@link onEventUpdated()} and
- * {@link onEventRemoved()} instead
- */
-function onProjectListingsUpdated(project, callback) {
-    console.warn('onProjectListingsUpdated() is deprecated. Please use onEventAdded(), onEventUpdated() and onEventRemoved() instead');
-    return subscribe$2(project, 'listings', callback);
 }
 
 /******************************************************************************
@@ -762,19 +706,19 @@ async function fetchHistory(host, id) {
  * More details on the license can be found at https://www.monterosa.co/sdk/license
  */
 /**
- * Describes the event state.
+ * Describes the Event state.
  */
 var EventState;
 (function (EventState) {
     /**
-     * The event is in the `upcoming` state when its {@link InteractEvent.startAt | start time}
-     * less than the {@link now | current time}.
+     * The Event is in the `upcoming` state when its {@link InteractEvent | startAt}
+     * less than the {@link @monterosa/sdk-util#now | current time}.
      */
     EventState["Upcoming"] = "upcoming";
     /**
-     * The event is in the `active` state when its {@link InteractEvent.startAt | start time}
-     * equal or more than the {@link now | current time} and less than the
-     * {@link InteractEvent.endAt | end time}.
+     * The Event is in the `active` state when its {@link InteractEvent | startAt}
+     * equal or more than the {@link @monterosa/sdk-util#now | current time} and less than the
+     * {@link InteractEvent | endAt}.
      */
     EventState["Active"] = "active";
     /**
@@ -782,8 +726,8 @@ var EventState;
      */
     EventState["Prolonged"] = "prolonged";
     /**
-     * The event is in the `finished` state when its {@link InteractEvent.endAt | end time}
-     * equal or more than the {@link now | current time}.
+     * The Event is in the `finished` state when its {@link InteractEvent | endAt}
+     * equal or more than the {@link @monterosa/sdk-util#now | current time}.
      */
     EventState["Finished"] = "finished";
 })(EventState || (EventState = {}));
@@ -1037,10 +981,10 @@ const getEventsMemoized = memoizePromise(async (project) => {
     }
     const context = Object.assign(Object.assign({}, project.context), { project });
     return (project.events
-        // Calling builder function that creates an event instance.
-        // Existing event will be returned if it already exists in the cache
+        // Calling builder function that creates an Event instance.
+        // Existing Event will be returned if it already exists in the cache
         .map((data) => buildEvent(data, context))
-        // Sort events so the most recent event is first, and the oldest is last
+        // Sort Events so the oldest Event is first, and the most recent is last
         .sort((a, b) => a.startAt - b.startAt));
 }, 
 /**
@@ -1071,12 +1015,13 @@ const getEventsMemoized = memoizePromise(async (project) => {
     return sdk.options.projectId;
 });
 /**
- * Returns all events in a project, including all active events and
- * past/upcoming events, according to Listings settings in Project Setup
+ * Returns all Events in a Project, including all active Events and
+ * past/upcoming Events, according to Listings settings in Project Setup
  * in Studio.
  *
- * @param project - A project instance. If not provided,
- *   the one from the default sdk will be fetched.
+ * @param project - A Project instance. If not provided,
+ *   the one from the default SDK will be fetched.
+ * @returns A promise that resolves to an array of Events.
  */
 function getEvents(project) {
     return getEventsMemoized(project);
@@ -1112,44 +1057,54 @@ const getEventMemoized = memoizePromise(async (id, project) => {
     }
 }, (id) => id);
 /**
- * Returns an event by its id
+ * Returns an Event by its id
  *
- * @param id - Id of the event
- * @param project - A project instance. If not provided,
- *   the one from the default sdk will be fetched.
+ * @param id - Id of the Event
+ * @param project - A Project instance. If not provided,
+ *   the one from the default SDK will be fetched.
  *
- * @returns A an event associated with the provided id and project or null if no such
- *   event exists in the project.
+ * @returns The Event associated with the provided id,
+ *   or null if no such Event exists in the Project.
  */
 function getEvent(id, project) {
     return getEventMemoized(id, project);
 }
 /**
- * Adds an observer for when {@link InteractEvent.state | event state} changed
+ * Adds an observer for when
+ * {@link InteractEvent | Event state} changed
+ *
+ * @param event - The Event to observe
+ * @param callback - Called with the new state
  */
 function onEventState(event, callback) {
     return subscribe$2(event, 'state', callback);
 }
 /**
- * Adds an observer for when event's data changed
+ * Adds an observer for when Event's data changed
+ *
+ * @param event - The Event to observe
+ * @param callback - Called when the Event data changes
  */
 function onEventUpdated(event, callback) {
     return subscribe$2(event, 'updated', callback);
 }
 /**
- * Adds an observer that is called when an event is added to listings.
+ * Adds an observer that is called when an Event is added to listings.
  *
  * @remarks
- * The following actions will result in adding an event to listings:
+ * The following actions will result in adding an Event to listings:
+ *
+ * - The start of the Event in Studio
  *
- * - The start of the event in Studio
+ * - The scheduling of a future Event in Studio, when listings are configured
+ *   to include future Events in Project Settings.
  *
- * - The scheduling of a future event in Studio, when listings are configured
- *   to include future events in Project Settings.
+ * - When a future Event starts, a new future Event may be added to the list,
+ *   depending on the Project configuration, to ensure a minimum number of
+ *   upcoming Events are always available.
  *
- * - When a future event starts, a new future event may be added to the list,
- *   depending on the project configuration, to ensure a minimum number of
- *   upcoming events are always available.
+ * @param project - The Project to observe
+ * @param callback - Called with the added Event
  */
 function onEventAdded(project, callback) {
     return subscribe$2(project, 'listings_events_created', async (data) => {
@@ -1180,28 +1135,22 @@ function onEventAdded(project, callback) {
     });
 }
 /**
- * {@link onEventAdded} alias.
- *
- * @deprecated Use the new {@link onEventAdded} function instead.
- */
-function onEventPublished(project, callback) {
-    console.warn('onEventPublished() is deprecated. Please use onEventAdded() instead');
-    return onEventAdded(project, callback);
-}
-/**
- * Adds an observer that is called when an event is removed from listings.
+ * Adds an observer that is called when an Event is removed from listings.
  *
  * @remarks
- * The following actions will result in removing an event from listings:
+ * The following actions will result in removing an Event from listings:
  *
- * - The deletion of the event from Studio
+ * - The deletion of the Event from Studio
  *
- * - The change of listings confuguration in Project Settings to exclude future
- *   or past events.
+ * - The change of listings configuration in Project Settings to exclude future
+ *   or past Events.
  *
- * - The event is removed after a period of time since its completion. This period
+ * - The Event is removed after a period of time since its completion. This period
  *   is calculated as 45 seconds plus the Maximum allowed delay (configured in
  *   Project Settings in Studio).
+ *
+ * @param project - The Project to observe
+ * @param callback - Called with the removed Event
  */
 function onEventRemoved(project, callback) {
     return subscribe$2(project, 'listings_events_deleted', async (data) => {
@@ -1246,13 +1195,21 @@ function onEventRemoved(project, callback) {
  */
 var AnswerError;
 (function (AnswerError) {
+    /** Selected option index is out of range. */
     AnswerError["OptionIndexOutOfRange"] = "out_of_range";
+    /** Fewer options selected than the minimum required. */
     AnswerError["BelowMinVoteOptions"] = "below_min_vote_options";
+    /** More options selected than the maximum allowed. */
     AnswerError["AboveMaxVoteOptions"] = "above_max_vote_options";
+    /** User has exceeded the maximum votes allowed. */
     AnswerError["AboveMaxVotesPerUser"] = "above_max_per_user";
+    /** A single option received more votes than allowed. */
     AnswerError["AboveMaxVotesPerOption"] = "above_max_per_option";
+    /** Attempted to vote on a non-interactive element. */
     AnswerError["VotedOnNonInteractiveElement"] = "non_interactive_element";
+    /** Attempted to vote on a closed element. */
     AnswerError["VotedOnClosedElement"] = "closed_element";
+    /** No vote value was provided. */
     AnswerError["EmptyVote"] = "empty_vote";
 })(AnswerError || (AnswerError = {}));
 const AnswerErrorMessages = {
@@ -1266,18 +1223,18 @@ const AnswerErrorMessages = {
     [AnswerError.EmptyVote]: (indices) => `Empty value for options indices: ${indices}`,
 };
 /**
- * The ElementState represents the potential states an element is in.
+ * The ElementState represents the potential states an Element is in.
  */
 var ElementState;
 (function (ElementState) {
     /**
      * Element is opened and active. The user can vote if
-     * element is `interactive`
+     * the Element is `interactive`
      */
     ElementState["Opened"] = "opened";
     /**
      * Element is closed and the user can no longer vote for
-     * `interactive` elements
+     * `interactive` Elements
      */
     ElementState["Closed"] = "closed";
 })(ElementState || (ElementState = {}));
@@ -1366,40 +1323,40 @@ class Answer {
  * More details on the license can be found at https://www.monterosa.co/sdk/license
  */
 /**
- * Describes element types
+ * Describes Element types
  */
 var ElementType;
 (function (ElementType) {
     /**
-     * Data element
+     * Data Element
      */
     ElementType["Data"] = "data";
     /**
-     * Poll element
+     * Poll Element
      */
     ElementType["Poll"] = "poll";
     /**
-     * Regular poll element
+     * Regular poll Element
      */
     ElementType["RegularPoll"] = "rpoll";
     /**
-     * Diametric poll element
+     * Diametric poll Element
      */
     ElementType["DiametricPoll"] = "dpoll";
     /**
-     * Emoting poll
+     * Emoting poll Element
      */
     ElementType["EmotingPoll"] = "emo";
     /**
-     * Powerbar element
+     * Powerbar Element
      */
     ElementType["Powerbar"] = "powerbar";
     /**
-     * Prediction element
+     * Prediction Element
      */
     ElementType["Prediction"] = "prediction";
     /**
-     * Trivia element
+     * Trivia Element
      */
     ElementType["Trivia"] = "trivia";
 })(ElementType || (ElementType = {}));
@@ -1458,6 +1415,7 @@ class ElementImpl extends Emitter {
     }
     update(data) {
         this._data = data;
+        this.handleState();
     }
     destroy() {
         this.unsubscribeStateHandler();
@@ -1596,13 +1554,12 @@ class ElementImpl extends Emitter {
  * More details on the license can be found at https://www.monterosa.co/sdk/license
  */
 const elements = new Map();
-const storageAvailable = checkAvailability();
-function buildElement(options, context) {
+async function buildElement(options, context) {
     if (elements.has(options.id)) {
         return elements.get(options.id);
     }
     const element = new ElementImpl(options, context);
-    restoreAnswer(element);
+    await restoreAnswer(element);
     elements.set(element.id, element);
     return element;
 }
@@ -1653,14 +1610,21 @@ async function handleCreateMessage(message) {
     }
     if (elements.has(options.id)) {
         const element = elements.get(options.id);
-        if (options.updated_at > element.updatedAt) {
+        if (options.updated_at > element.updatedAt ||
+            // This is a workaround to handle a Studio issue when two /create/ messages
+            // are sent upon correct option reveal. The first /create/ message contains
+            // the same duration but a different updated_at timestamp. The second /create/
+            // message contains the same updated_at timestamp but a different duration.
+            // Therefore, we need to check if the duration is different to ensure that
+            // the element is updated correctly.
+            options.duration !== element.duration) {
             element.update(options);
             event.emit('update', element);
         }
     }
     else {
         const context = Object.assign(Object.assign({}, event.context), { event });
-        const element = buildElement(options, context);
+        const element = await buildElement(options, context);
         event.emit('publish', element);
     }
 }
@@ -1705,10 +1669,13 @@ function handleRevealMessage(message) {
     if (!element) {
         return;
     }
-    element.correctOption = correctOption;
-    element.context.event.emit('update', element);
+    if (element.correctOption !== correctOption) {
+        element.correctOption = correctOption;
+        element.context.event.emit('update', element);
+    }
 }
 async function handleEventHistory(history) {
+    var _a, e_1, _b, _c;
     if (history.timeline.length === 0) {
         return;
     }
@@ -1717,10 +1684,27 @@ async function handleEventHistory(history) {
         return;
     }
     const context = Object.assign(Object.assign({}, event.context), { event });
-    for (const snapshot of history.timeline) {
-        if (!elements.has(snapshot.id)) {
-            buildElement(snapshot, context);
+    try {
+        for (var _d = true, _e = __asyncValues(history.timeline), _f; _f = await _e.next(), _a = _f.done, !_a;) {
+            _c = _f.value;
+            _d = false;
+            try {
+                const snapshot = _c;
+                if (!elements.has(snapshot.id)) {
+                    await buildElement(snapshot, context);
+                }
+            }
+            finally {
+                _d = true;
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (!_d && !_a && (_b = _e.return)) await _b.call(_e);
         }
+        finally { if (e_1) throw e_1.error; }
     }
 }
 async function sendAnswer(element, userAnswer) {
@@ -1732,27 +1716,19 @@ async function sendAnswer(element, userAnswer) {
         .join(':');
     connect.sendVote(event.id, element.pollId, answer);
 }
-function storeAnswer(element, userAnswer) {
+async function storeAnswer(element, userAnswer) {
     try {
         element.userAnswer = userAnswer;
-        if (storageAvailable) {
-            // Can throw a "QuotaExceededError" DOMException exception
-            // if the quota has been exceeded.
-            setItem(`element_${element.id}_vote`, JSON.stringify(userAnswer));
-        }
+        await storageWrite(`element_${element.id}_vote`, JSON.stringify(userAnswer));
     }
     catch (err) {
-        if (err instanceof Error) {
-            console.warn(`Can't store user answer: ${err.message}`);
-        }
+        console.warn(`Failed to store user answer: ${getErrorMessage(err)}`);
     }
 }
-function restoreAnswer(element) {
-    if (storageAvailable) {
-        const userAnswer = getItem(`element_${element.id}_vote`);
-        if (userAnswer !== null) {
-            element.userAnswer = Answer.fromJSON(userAnswer);
-        }
+async function restoreAnswer(element) {
+    const userAnswer = await storageRead(`element_${element.id}_vote`);
+    if (userAnswer !== null) {
+        element.userAnswer = Answer.fromJSON(userAnswer);
     }
 }
 
@@ -1773,7 +1749,10 @@ const getElementMemoized = memoizePromise(async (event, id) => {
     return element || null;
 }, (event, id) => id);
 /**
- * Returns an element of a specific event by its id
+ * Returns an Element of a specific Event by its id.
+ *
+ * @param event - The Event that owns the Element
+ * @param id - The Element identifier
  */
 function getElement(event, id) {
     return getElementMemoized(event, id);
@@ -1784,15 +1763,18 @@ function getElement(event, id) {
 const getElementsMemoized = memoizePromise(async (event) => {
     await configureEvent(event);
     return (Array.from(elements.values())
-        // Get elements which belong only to the provided event
+        // Get Elements which belong only to the provided Event
         .filter((element) => element.eventId === event.id)
-        // Sort elements so the most recent event is first, and the oldest is last
+        // Sort Elements so the oldest Element is first, and the most recent is last
         .sort((a, b) => a.publishedAt - b.publishedAt));
 }, (event) => event.id, {
     clearOnResolve: true,
 });
 /**
- * Returns the list of elements published in a specific event
+ * Returns the list of Elements published in a specific Event
+ *
+ * @param event - The Event to fetch Elements for
+ * @returns The published Elements, sorted oldest first.
  */
 function getElements(event) {
     return getElementsMemoized(event);
@@ -1868,29 +1850,41 @@ function isNumbers(value) {
     return value.every((v) => typeof v === 'number');
 }
 /**
- * Adds an observer for when {@link InteractElement.results | element results}
- * are updated
+ * Adds an observer for when
+ * {@link InteractElement | Element results} are updated
+ *
+ * @param element - The Element to observe
+ * @param callback - Called when results are updated
  */
 function onElementResults(element, callback) {
     return subscribe$2(element, 'results', callback);
 }
 /**
- * Adds an observer for when {@link InteractElement.state | element state}
- * changed
+ * Adds an observer for when
+ * {@link InteractElement | Element state} changed
+ *
+ * @param element - The Element to observe
+ * @param callback - Called when the state changes
  */
 function onElementStateChanged(element, callback) {
     return subscribe$2(element, 'state', callback);
 }
 /**
- * Adds an observer for when {@link InteractElement.fields | element's data}
- * is updated
+ * Adds an observer for when
+ * {@link InteractElement | Element fields} are updated
+ *
+ * @param event - The Event containing the Elements
+ * @param callback - Called with the updated Element
  */
 function onElementUpdated(event, callback) {
     configureEvent(event);
     return subscribe$2(event, 'update', callback);
 }
 /**
- * Adds an observer for when a new element is published
+ * Adds an observer for when a new Element is published
+ *
+ * @param event - The Event to observe
+ * @param callback - Called with the published Element
  */
 function onElementPublished(event, callback) {
     configureEvent(event);
@@ -1901,7 +1895,10 @@ function onElementPublished(event, callback) {
     });
 }
 /**
- * Adds an observer for when an element is revoked
+ * Adds an observer for when an Element is revoked
+ *
+ * @param event - The Event to observe
+ * @param callback - Called with the revoked Element
  */
 function onElementRevoked(event, callback) {
     configureEvent(event);
@@ -2058,5 +2055,5 @@ function onPresenceCounterClose(presenceCounter, callback) {
     return () => presenceCounter.off('state', handler);
 }
 
-export { Answer, AnswerError, Channel, ConnectionHealthState, ElementImpl, ElementState, ElementType, EventImpl, EventState, Klass, PresenceCounterState, ProjectImpl, State, answer, fetchListings, getConnect, getConnectionHealth, getElement, getElementMemoized, getElements, getElementsMemoized, getEvent, getEventMemoized, getEvents, getEventsMemoized, getPresenceCounter, getProject, getProjectMemoized, login, onConnectionHealthState, onElementPublished, onElementResults, onElementRevoked, onElementStateChanged, onElementUpdated, onEventAdded, onEventPublished, onEventRemoved, onEventState, onEventUpdated, onPresenceCounterClose, onPresenceCounterOpen, onPresenceCounterUpdate, onProjectFieldsUpdated, onProjectListingsUpdated, validateAnswer };
-//# sourceMappingURL=index.esm.js.map
+export { Answer, AnswerError, Channel, ConnectionHealthState, ElementImpl, ElementState, ElementType, EventImpl, EventState, Klass, PresenceCounterState, ProjectImpl, State, answer, getConnect, getConnectionHealth, getElement, getElementMemoized, getElements, getElementsMemoized, getEvent, getEventMemoized, getEvents, getEventsMemoized, getPresenceCounter, getProject, getProjectMemoized, onConnectionHealthState, onElementPublished, onElementResults, onElementRevoked, onElementStateChanged, onElementUpdated, onEventAdded, onEventRemoved, onEventState, onEventUpdated, onPresenceCounterClose, onPresenceCounterOpen, onPresenceCounterUpdate, onProjectFieldsUpdated, validateAnswer };
+//# sourceMappingURL=index.js.map