@intuned/runtime-dev 1.3.14-ts-runtime-helpers-1 → 1.3.15-ts-helpers

package/dist/runtime/captcha.test.js

@@ -1,6 +1,7 @@
 "use strict";
 
 var _vitest = require("vitest");
+var _intunedExtensionServer = require("../common/extension/intunedExtensionServer");
 var _captcha = require("./captcha");
 _vitest.vi.mock("fastify", () => {
   const fastify = () => ({
@@ -13,48 +14,93 @@ _vitest.vi.mock("fastify", () => {
     default: fastify
   };
 });
-class FakeExtensionServer {
-  captchas = new Map();
-  subscribers = new Set();
-  subscribeCalls = 0;
-  unsubscribeCalls = 0;
-  seed(captchas) {
-    this.captchas.clear();
-    for (const c of captchas) this.captchas.set(c.id, c);
-  }
-  async upsertCaptcha(captcha) {
-    this.captchas.set(captcha.id, captcha);
-    for (const h of this.subscribers) {
-      await h(captcha);
-    }
-  }
-  async getCaptchas(_page, status) {
-    const list = [...this.captchas.values()];
-    return status ? list.filter(c => c.status === status) : list;
-  }
-  async subscribe(_page, handler) {
-    this.subscribeCalls += 1;
-    this.subscribers.add(handler);
-  }
-  async unsubscribe(_page, handler) {
-    this.unsubscribeCalls += 1;
-    this.subscribers.delete(handler);
-  }
-}
 let server;
-_vitest.vi.mock("../common/extension/intunedExtensionServer", () => {
+_vitest.vi.mock("../common/extension/intunedExtensionServer", async importOriginal => {
+  const actual = await importOriginal();
   return {
-    getIntunedExtensionServer: () => server
+    ...actual,
+    getIntunedExtensionServer: () => server,
+    getTabId: _vitest.vi.fn(async () => 0)
   };
 });
 function makeMockPage() {
   return {
-    waitForLoadState: _vitest.vi.fn().mockResolvedValue(undefined)
+    waitForLoadState: _vitest.vi.fn().mockResolvedValue(undefined),
+    waitForFunction: _vitest.vi.fn().mockResolvedValue(undefined),
+    evaluate: _vitest.vi.fn().mockResolvedValue(0)
   };
 }
+async function runCaptchaTestScenario({
+  page,
+  mockStates,
+  timeoutMs = 10000,
+  settleDurationMs = 100,
+  expectErrorCode,
+  expectTimeout = false
+}) {
+  for (const state of mockStates) {
+    await server.handleUpsertCaptcha(state.initial);
+  }
+  const allTransitions = [];
+  for (const state of mockStates) {
+    for (const transition of state.transitions) {
+      allTransitions.push({
+        timeMs: transition.timeMs,
+        captchaId: state.initial.id,
+        type: state.initial.type,
+        status: transition.status,
+        errorCode: transition.errorCode
+      });
+    }
+  }
+  allTransitions.sort((a, b) => a.timeMs - b.timeMs);
+  const p = (0, _captcha.waitForCaptchaSolve)(page, {
+    timeoutInMs: timeoutMs,
+    settleDurationMs
+  });
+  let assertion;
+  if (expectErrorCode) {
+    assertion = (0, _vitest.expect)(p).rejects.toThrow(`CAPTCHA Solve Error: ${expectErrorCode}`);
+  } else if (expectTimeout) {
+    assertion = (0, _vitest.expect)(p).rejects.toThrow("CAPTCHA Solve timed out with pending captchas.");
+  }
+  await _vitest.vi.advanceTimersByTimeAsync(0);
+  let currentTimeMs = 0;
+  for (const transition of allTransitions) {
+    const deltaMs = transition.timeMs - currentTimeMs;
+    if (deltaMs > 0) {
+      await _vitest.vi.advanceTimersByTimeAsync(deltaMs);
+      currentTimeMs = transition.timeMs;
+    }
+    const captcha = transition.status === "error" && transition.errorCode ? {
+      id: transition.captchaId,
+      tabId: 0,
+      type: transition.type,
+      status: "error",
+      error: {
+        code: transition.errorCode
+      }
+    } : {
+      id: transition.captchaId,
+      tabId: 0,
+      type: transition.type,
+      status: transition.status
+    };
+    await server.handleUpsertCaptcha(captcha);
+  }
+  await _vitest.vi.advanceTimersByTimeAsync(settleDurationMs + 10);
+  if (expectTimeout || expectErrorCode) {
+    await _vitest.vi.advanceTimersByTimeAsync(timeoutMs + settleDurationMs);
+  }
+  if (assertion) {
+    await assertion;
+  } else {
+    await (0, _vitest.expect)(p).resolves.toBeUndefined();
+  }
+}
 (0, _vitest.beforeEach)(() => {
   _vitest.vi.useFakeTimers();
-  server = new FakeExtensionServer();
+  server = new _intunedExtensionServer.ExtensionServer();
 });
 (0, _vitest.afterEach)(() => {
   _vitest.vi.useRealTimers();
@@ -65,13 +111,11 @@ function makeMockPage() {
     const page = makeMockPage();
     const p = (0, _captcha.waitForCaptchaSolve)(page, {
       timeoutInMs: 1000,
-      settlePeriodInMs: 10
+      settleDurationMs: 10
     });
     await _vitest.vi.advanceTimersByTimeAsync(10);
     await p;
     (0, _vitest.expect)(page.waitForLoadState).not.toHaveBeenCalled();
-    (0, _vitest.expect)(server.subscribeCalls).toBe(1);
-    (0, _vitest.expect)(server.unsubscribeCalls).toBe(1);
   });
   (0, _vitest.it)("withWaitForCaptchaSolve: preserves return value and waits for networkidle by default", async () => {
     const page = makeMockPage();
@@ -98,19 +142,19 @@ function makeMockPage() {
   });
   (0, _vitest.it)("waitForCaptchaSolve: completes when a solving captcha becomes solved", async () => {
     const page = makeMockPage();
-    server.seed([{
+    await server.handleUpsertCaptcha({
       id: "c1",
       tabId: 0,
       type: "recaptcha",
       status: "solving",
       retryCount: 0
-    }]);
+    });
     const p = (0, _captcha.waitForCaptchaSolve)(page, {
       timeoutInMs: 1000,
-      settlePeriodInMs: 10
+      settleDurationMs: 10
     });
     await Promise.resolve();
-    await server.upsertCaptcha({
+    await server.handleUpsertCaptcha({
       id: "c1",
       tabId: 0,
       type: "recaptcha",
@@ -122,20 +166,20 @@ function makeMockPage() {
   });
   (0, _vitest.it)("waitForCaptchaSolve: throws on captcha error", async () => {
     const page = makeMockPage();
-    server.seed([{
+    await server.handleUpsertCaptcha({
       id: "c1",
       tabId: 0,
       type: "recaptcha",
       status: "solving",
       retryCount: 0
-    }]);
+    });
     const p = (0, _captcha.waitForCaptchaSolve)(page, {
       timeoutInMs: 1000,
-      settlePeriodInMs: 10
+      settleDurationMs: 10
     });
     const assertion = (0, _vitest.expect)(p).rejects.toThrow("CAPTCHA Solve Error: UNEXPECTED_ERROR");
-    await Promise.resolve();
-    await server.upsertCaptcha({
+    await _vitest.vi.advanceTimersByTimeAsync(0);
+    await server.handleUpsertCaptcha({
       id: "c1",
       tabId: 0,
       type: "recaptcha",
@@ -147,49 +191,48 @@ function makeMockPage() {
     });
     await _vitest.vi.advanceTimersByTimeAsync(10);
     await assertion;
-    (0, _vitest.expect)(server.unsubscribeCalls).toBe(1);
   });
   (0, _vitest.it)("waitForCaptchaSolve: times out if captchas are still pending", async () => {
     const page = makeMockPage();
-    server.seed([{
+    await server.handleUpsertCaptcha({
       id: "c1",
       tabId: 0,
       type: "recaptcha",
       status: "solving",
       retryCount: 0
-    }]);
+    });
     const p = (0, _captcha.waitForCaptchaSolve)(page, {
       timeoutInMs: 5,
-      settlePeriodInMs: 1
+      settleDurationMs: 1
     });
     const assertion = (0, _vitest.expect)(p).rejects.toThrow("CAPTCHA Solve timed out with pending captchas.");
     await Promise.resolve();
     await _vitest.vi.advanceTimersByTimeAsync(6);
     await _vitest.vi.advanceTimersByTimeAsync(1);
     await assertion;
-    (0, _vitest.expect)(server.unsubscribeCalls).toBe(1);
   });
   (0, _vitest.it)("waitForCaptchaSolve: waits for all captchas to resolve", async () => {
     const page = makeMockPage();
-    server.seed([{
+    await server.handleUpsertCaptcha({
       id: "c1",
       tabId: 0,
       type: "recaptcha",
       status: "solving",
       retryCount: 0
-    }, {
+    });
+    await server.handleUpsertCaptcha({
       id: "c2",
       tabId: 0,
       type: "hcaptcha",
       status: "solving",
       retryCount: 0
-    }]);
+    });
     const p = (0, _captcha.waitForCaptchaSolve)(page, {
       timeoutInMs: 1000,
-      settlePeriodInMs: 10
+      settleDurationMs: 10
     });
     await Promise.resolve();
-    await server.upsertCaptcha({
+    await server.handleUpsertCaptcha({
       id: "c1",
       tabId: 0,
       type: "recaptcha",
@@ -201,7 +244,7 @@ function makeMockPage() {
     p.then(() => settled = true).catch(() => settled = true);
     await Promise.resolve();
     (0, _vitest.expect)(settled).toBe(false);
-    await server.upsertCaptcha({
+    await server.handleUpsertCaptcha({
       id: "c2",
       tabId: 0,
       type: "hcaptcha",
@@ -211,4 +254,568 @@ function makeMockPage() {
     await _vitest.vi.advanceTimersByTimeAsync(10);
     await (0, _vitest.expect)(p).resolves.toBeUndefined();
   });
+  (0, _vitest.describe)("captchaStateTransitions", () => {
+    (0, _vitest.it)("captcha detached completes successfully", async () => {
+      const page = makeMockPage();
+      await runCaptchaTestScenario({
+        page,
+        mockStates: [{
+          initial: {
+            id: "test1",
+            tabId: 0,
+            type: "recaptcha",
+            status: "solving"
+          },
+          transitions: [{
+            timeMs: 100,
+            status: "detached"
+          }]
+        }],
+        settleDurationMs: 100
+      });
+    });
+    (0, _vitest.it)("attached to solving to solved", async () => {
+      const page = makeMockPage();
+      await runCaptchaTestScenario({
+        page,
+        mockStates: [{
+          initial: {
+            id: "captcha1",
+            tabId: 0,
+            type: "recaptcha",
+            status: "attached"
+          },
+          transitions: [{
+            timeMs: 50,
+            status: "solving"
+          }, {
+            timeMs: 350,
+            status: "solved"
+          }]
+        }],
+        settleDurationMs: 100
+      });
+    });
+    (0, _vitest.it)("attached to detached", async () => {
+      const page = makeMockPage();
+      await runCaptchaTestScenario({
+        page,
+        mockStates: [{
+          initial: {
+            id: "captcha1",
+            tabId: 0,
+            type: "recaptcha",
+            status: "attached"
+          },
+          transitions: [{
+            timeMs: 100,
+            status: "detached"
+          }]
+        }],
+        settleDurationMs: 100
+      });
+    });
+    (0, _vitest.it)("attached to solving to error", async () => {
+      const page = makeMockPage();
+      await runCaptchaTestScenario({
+        page,
+        mockStates: [{
+          initial: {
+            id: "captcha1",
+            tabId: 0,
+            type: "recaptcha",
+            status: "attached"
+          },
+          transitions: [{
+            timeMs: 50,
+            status: "solving"
+          }, {
+            timeMs: 550,
+            status: "error",
+            errorCode: "UNEXPECTED_ERROR"
+          }]
+        }],
+        settleDurationMs: 100,
+        expectErrorCode: "UNEXPECTED_ERROR"
+      });
+    });
+    (0, _vitest.it)("attached to solving to detached", async () => {
+      const page = makeMockPage();
+      await runCaptchaTestScenario({
+        page,
+        mockStates: [{
+          initial: {
+            id: "captcha1",
+            tabId: 0,
+            type: "recaptcha",
+            status: "attached"
+          },
+          transitions: [{
+            timeMs: 50,
+            status: "solving"
+          }, {
+            timeMs: 200,
+            status: "detached"
+          }]
+        }],
+        settleDurationMs: 100
+      });
+    });
+    (0, _vitest.it)("visibility toggle then solved", async () => {
+      const page = makeMockPage();
+      await runCaptchaTestScenario({
+        page,
+        mockStates: [{
+          initial: {
+            id: "captcha1",
+            tabId: 0,
+            type: "recaptcha",
+            status: "attached"
+          },
+          transitions: [{
+            timeMs: 50,
+            status: "solving"
+          }, {
+            timeMs: 100,
+            status: "attached"
+          }, {
+            timeMs: 120,
+            status: "solving"
+          }, {
+            timeMs: 420,
+            status: "solved"
+          }]
+        }],
+        settleDurationMs: 100
+      });
+    });
+    (0, _vitest.it)("visibility toggle then error", async () => {
+      const page = makeMockPage();
+      await runCaptchaTestScenario({
+        page,
+        mockStates: [{
+          initial: {
+            id: "captcha1",
+            tabId: 0,
+            type: "recaptcha",
+            status: "attached"
+          },
+          transitions: [{
+            timeMs: 50,
+            status: "solving"
+          }, {
+            timeMs: 100,
+            status: "attached"
+          }, {
+            timeMs: 120,
+            status: "solving"
+          }, {
+            timeMs: 620,
+            status: "error",
+            errorCode: "MAX_RETRIES"
+          }]
+        }],
+        settleDurationMs: 100,
+        expectErrorCode: "MAX_RETRIES"
+      });
+    });
+    (0, _vitest.it)("visibility toggle then detached", async () => {
+      const page = makeMockPage();
+      await runCaptchaTestScenario({
+        page,
+        mockStates: [{
+          initial: {
+            id: "captcha1",
+            tabId: 0,
+            type: "recaptcha",
+            status: "attached"
+          },
+          transitions: [{
+            timeMs: 50,
+            status: "solving"
+          }, {
+            timeMs: 100,
+            status: "attached"
+          }, {
+            timeMs: 110,
+            status: "detached"
+          }]
+        }],
+        settleDurationMs: 100
+      });
+    });
+    (0, _vitest.it)("visibility toggle solving then detached", async () => {
+      const page = makeMockPage();
+      await runCaptchaTestScenario({
+        page,
+        mockStates: [{
+          initial: {
+            id: "captcha1",
+            tabId: 0,
+            type: "recaptcha",
+            status: "attached"
+          },
+          transitions: [{
+            timeMs: 50,
+            status: "solving"
+          }, {
+            timeMs: 100,
+            status: "attached"
+          }, {
+            timeMs: 120,
+            status: "solving"
+          }, {
+            timeMs: 270,
+            status: "detached"
+          }]
+        }],
+        settleDurationMs: 100
+      });
+    });
+    (0, _vitest.it)("rapid visibility toggle then solved", async () => {
+      const page = makeMockPage();
+      await runCaptchaTestScenario({
+        page,
+        mockStates: [{
+          initial: {
+            id: "captcha1",
+            tabId: 0,
+            type: "recaptcha",
+            status: "attached"
+          },
+          transitions: [{
+            timeMs: 50,
+            status: "solving"
+          }, {
+            timeMs: 60,
+            status: "attached"
+          }, {
+            timeMs: 65,
+            status: "solving"
+          }, {
+            timeMs: 75,
+            status: "attached"
+          }, {
+            timeMs: 80,
+            status: "solving"
+          }, {
+            timeMs: 380,
+            status: "solved"
+          }]
+        }],
+        settleDurationMs: 100
+      });
+    });
+    (0, _vitest.it)("rapid visibility toggle then detached", async () => {
+      const page = makeMockPage();
+      await runCaptchaTestScenario({
+        page,
+        mockStates: [{
+          initial: {
+            id: "captcha1",
+            tabId: 0,
+            type: "recaptcha",
+            status: "attached"
+          },
+          transitions: [{
+            timeMs: 50,
+            status: "solving"
+          }, {
+            timeMs: 60,
+            status: "attached"
+          }, {
+            timeMs: 65,
+            status: "solving"
+          }, {
+            timeMs: 75,
+            status: "attached"
+          }, {
+            timeMs: 80,
+            status: "detached"
+          }]
+        }],
+        settleDurationMs: 100
+      });
+    });
+    (0, _vitest.it)("instant toggles then solved", async () => {
+      const page = makeMockPage();
+      await runCaptchaTestScenario({
+        page,
+        mockStates: [{
+          initial: {
+            id: "captcha1",
+            tabId: 0,
+            type: "recaptcha",
+            status: "attached"
+          },
+          transitions: [{
+            timeMs: 1,
+            status: "solving"
+          }, {
+            timeMs: 2,
+            status: "attached"
+          }, {
+            timeMs: 3,
+            status: "solving"
+          }, {
+            timeMs: 300,
+            status: "solved"
+          }]
+        }],
+        settleDurationMs: 100
+      });
+    });
+    (0, _vitest.it)("long solving timeout", async () => {
+      const page = makeMockPage();
+      await runCaptchaTestScenario({
+        page,
+        mockStates: [{
+          initial: {
+            id: "captcha1",
+            tabId: 0,
+            type: "recaptcha",
+            status: "attached"
+          },
+          transitions: [{
+            timeMs: 10,
+            status: "solving"
+          }, {
+            timeMs: 30000,
+            status: "error",
+            errorCode: "UNEXPECTED_ERROR"
+          }]
+        }],
+        timeoutMs: 10000,
+        settleDurationMs: 3000,
+        expectTimeout: true
+      });
+    });
+    (0, _vitest.it)("multiple captchas both solve", async () => {
+      const page = makeMockPage();
+      await runCaptchaTestScenario({
+        page,
+        mockStates: [{
+          initial: {
+            id: "captcha1",
+            tabId: 0,
+            type: "recaptcha",
+            status: "solving"
+          },
+          transitions: [{
+            timeMs: 100,
+            status: "solved"
+          }]
+        }, {
+          initial: {
+            id: "captcha2",
+            tabId: 0,
+            type: "hcaptcha",
+            status: "solving"
+          },
+          transitions: [{
+            timeMs: 200,
+            status: "solved"
+          }]
+        }],
+        settleDurationMs: 100
+      });
+    });
+    (0, _vitest.it)("multiple captchas one errors", async () => {
+      const page = makeMockPage();
+      await runCaptchaTestScenario({
+        page,
+        mockStates: [{
+          initial: {
+            id: "captcha1",
+            tabId: 0,
+            type: "recaptcha",
+            status: "solving"
+          },
+          transitions: []
+        }, {
+          initial: {
+            id: "captcha2",
+            tabId: 0,
+            type: "hcaptcha",
+            status: "solving"
+          },
+          transitions: [{
+            timeMs: 100,
+            status: "error",
+            errorCode: "HIT_LIMIT"
+          }]
+        }],
+        settleDurationMs: 100,
+        expectErrorCode: "HIT_LIMIT"
+      });
+    });
+    (0, _vitest.it)("staggered captcha resolution", async () => {
+      const page = makeMockPage();
+      await runCaptchaTestScenario({
+        page,
+        mockStates: [{
+          initial: {
+            id: "captcha1",
+            tabId: 0,
+            type: "recaptcha",
+            status: "solving"
+          },
+          transitions: [{
+            timeMs: 100,
+            status: "solved"
+          }]
+        }, {
+          initial: {
+            id: "captcha2",
+            tabId: 0,
+            type: "hcaptcha",
+            status: "solving"
+          },
+          transitions: [{
+            timeMs: 200,
+            status: "detached"
+          }]
+        }, {
+          initial: {
+            id: "captcha3",
+            tabId: 0,
+            type: "funcaptcha",
+            status: "solving"
+          },
+          transitions: [{
+            timeMs: 300,
+            status: "solved"
+          }]
+        }],
+        settleDurationMs: 100
+      });
+    });
+  });
+  (0, _vitest.describe)("onCaptchaEvent", () => {
+    (0, _vitest.it)("calls callback for matching status", async () => {
+      const page = makeMockPage();
+      const receivedCaptchas = [];
+      await (0, _captcha.onCaptchaEvent)(page, "solved", async captcha => {
+        receivedCaptchas.push(captcha);
+      });
+      await server.handleUpsertCaptcha({
+        id: "c1",
+        tabId: 0,
+        type: "recaptcha",
+        status: "solved"
+      });
+      (0, _vitest.expect)(receivedCaptchas).toHaveLength(1);
+      (0, _vitest.expect)(receivedCaptchas[0].id).toBe("c1");
+      (0, _vitest.expect)(receivedCaptchas[0].status).toBe("solved");
+    });
+    (0, _vitest.it)("ignores non-matching status", async () => {
+      const page = makeMockPage();
+      const receivedCaptchas = [];
+      await (0, _captcha.onCaptchaEvent)(page, "solved", async captcha => {
+        receivedCaptchas.push(captcha);
+      });
+      await server.handleUpsertCaptcha({
+        id: "c1",
+        tabId: 0,
+        type: "recaptcha",
+        status: "solving"
+      });
+      (0, _vitest.expect)(receivedCaptchas).toHaveLength(0);
+    });
+    (0, _vitest.it)("calls callback multiple times for multiple matching events", async () => {
+      const page = makeMockPage();
+      const receivedCaptchas = [];
+      await (0, _captcha.onCaptchaEvent)(page, "solved", async captcha => {
+        receivedCaptchas.push(captcha);
+      });
+      await server.handleUpsertCaptcha({
+        id: "c1",
+        tabId: 0,
+        type: "recaptcha",
+        status: "solved"
+      });
+      await server.handleUpsertCaptcha({
+        id: "c2",
+        tabId: 0,
+        type: "hcaptcha",
+        status: "solved"
+      });
+      (0, _vitest.expect)(receivedCaptchas).toHaveLength(2);
+      (0, _vitest.expect)(receivedCaptchas[0].id).toBe("c1");
+      (0, _vitest.expect)(receivedCaptchas[1].id).toBe("c2");
+    });
+  });
+  (0, _vitest.describe)("onceCaptchaEvent", () => {
+    (0, _vitest.it)("calls callback only once for first matching event", async () => {
+      const page = makeMockPage();
+      const receivedCaptchas = [];
+      await (0, _captcha.onceCaptchaEvent)(page, "solved", async captcha => {
+        receivedCaptchas.push(captcha);
+      });
+      await server.handleUpsertCaptcha({
+        id: "c1",
+        tabId: 0,
+        type: "recaptcha",
+        status: "solved"
+      });
+      await server.handleUpsertCaptcha({
+        id: "c2",
+        tabId: 0,
+        type: "hcaptcha",
+        status: "solved"
+      });
+      (0, _vitest.expect)(receivedCaptchas).toHaveLength(1);
+      (0, _vitest.expect)(receivedCaptchas[0].id).toBe("c1");
+    });
+    (0, _vitest.it)("receives all events until first match, then unsubscribes", async () => {
+      const page = makeMockPage();
+      const receivedCaptchas = [];
+      await (0, _captcha.onceCaptchaEvent)(page, "solved", async captcha => {
+        receivedCaptchas.push(captcha);
+      });
+      await server.handleUpsertCaptcha({
+        id: "c1",
+        tabId: 0,
+        type: "recaptcha",
+        status: "solving"
+      });
+      (0, _vitest.expect)(receivedCaptchas).toHaveLength(0);
+      await server.handleUpsertCaptcha({
+        id: "c2",
+        tabId: 0,
+        type: "recaptcha",
+        status: "solved"
+      });
+      (0, _vitest.expect)(receivedCaptchas).toHaveLength(1);
+      (0, _vitest.expect)(receivedCaptchas[0].id).toBe("c2");
+      await server.handleUpsertCaptcha({
+        id: "c3",
+        tabId: 0,
+        type: "recaptcha",
+        status: "solved"
+      });
+      (0, _vitest.expect)(receivedCaptchas).toHaveLength(1);
+    });
+    (0, _vitest.it)("unsubscribes after first matching event", async () => {
+      const page = makeMockPage();
+      let callCount = 0;
+      await (0, _captcha.onceCaptchaEvent)(page, "solved", async () => {
+        callCount++;
+      });
+      await server.handleUpsertCaptcha({
+        id: "c1",
+        tabId: 0,
+        type: "recaptcha",
+        status: "solved"
+      });
+      (0, _vitest.expect)(callCount).toBe(1);
+      await server.handleUpsertCaptcha({
+        id: "c2",
+        tabId: 0,
+        type: "recaptcha",
+        status: "solved"
+      });
+      (0, _vitest.expect)(callCount).toBe(1);
+    });
+  });
 });