socket-function 1.2.1 → 1.2.4

package/SocketFunction.d.ts

@@ -1,6 +1,6 @@
+/// <reference path="require/RequireController.d.ts" />
 /// <reference types="node" />
 /// <reference types="node" />
-/// <reference types="socket-function/require/requirecontroller" />
 import { SocketExposedInterface, SocketFunctionHook, SocketFunctionClientHook, SocketExposedShape, SocketRegistered, CallerContext, FullCallType, SocketRegisterType } from "./SocketFunctionTypes";
 import { SocketServerConfig } from "./src/webSocketServer";
 import { Args, MaybePromise } from "./src/types";

package/SocketFunctionTypes.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="socket-function/require/requirecontroller" />
+/// <reference path="require/RequireController.d.ts" />
 import { getCallObj } from "./src/nodeProxy";
 import { Args, MaybePromise } from "./src/types";
 export declare const socket: unique symbol;

package/hot/HotReloadController.d.ts

@@ -1,5 +1,5 @@
-/// <reference types="typenode" />
-/// <reference types="socket-function/require/requirecontroller" />
+/// <reference path="../../typenode/index.d.ts" />
+/// <reference path="../require/RequireController.d.ts" />
 /** Enables some hot reload functionality.
  *      - Triggers a refresh clientside
  *      - Triggers a reload server, for modules marked with `module.hotreload`
@@ -28,7 +28,7 @@ export declare function isHotReloading(): boolean;
 export declare function hotReloadingGuard(): true;
 export declare function setExternalHotReloading(value: boolean): void;
 export declare function onHotReload(callback: (modules: NodeJS.Module[]) => void): void;
-export declare const HotReloadController: import("socket-function/SocketFunctionTypes").SocketRegistered<{
+export declare const HotReloadController: import("../SocketFunctionTypes").SocketRegistered<{
     watchFiles: () => Promise<void>;
     fileUpdated: (files: string[], changeTime: number) => Promise<void>;
 }>;

package/index.d.ts

@@ -7,9 +7,9 @@ declare module "socket-function/SetProcessVariables" {
 }
 
 declare module "socket-function/SocketFunction" {
+    /// <reference path="require/RequireController.d.ts" />
     /// <reference types="node" />
     /// <reference types="node" />
-    /// <reference types="socket-function/require/requirecontroller" />
     import { SocketExposedInterface, SocketFunctionHook, SocketFunctionClientHook, SocketExposedShape, SocketRegistered, CallerContext, FullCallType, SocketRegisterType } from "socket-function/SocketFunctionTypes";
     import { SocketServerConfig } from "socket-function/src/webSocketServer";
     import { Args, MaybePromise } from "socket-function/src/types";
@@ -128,7 +128,7 @@ declare module "socket-function/SocketFunction" {
 }
 
 declare module "socket-function/SocketFunctionTypes" {
-    /// <reference types="socket-function/require/requirecontroller" />
+    /// <reference path="require/RequireController.d.ts" />
     import { getCallObj } from "socket-function/src/nodeProxy";
     import { Args, MaybePromise } from "socket-function/src/types";
     export declare const socket: unique symbol;
@@ -218,8 +218,8 @@ declare module "socket-function/SocketFunctionTypes" {
 }
 
 declare module "socket-function/hot/HotReloadController" {
-    /// <reference types="typenode" />
-    /// <reference types="socket-function/require/requirecontroller" />
+    /// <reference path="../../typenode/index.d.ts" />
+    /// <reference path="../require/RequireController.d.ts" />
     /** Enables some hot reload functionality.
      *      - Triggers a refresh clientside
      *      - Triggers a reload server, for modules marked with `module.hotreload`
@@ -307,15 +307,15 @@ declare module "socket-function/mobx/promiseToObservable" {
 }
 
 declare module "socket-function/require/CSSShim" {
-    /// <reference types="socket-function/require/requirecontroller" />
+    /// <reference path="RequireController.d.ts" />
     export {};
 
 }
 
 declare module "socket-function/require/RequireController" {
+    /// <reference path="../../typenode/index.d.ts" />
     /// <reference types="node" />
     /// <reference types="node" />
-    /// <reference types="typenode" />
     declare global {
         namespace NodeJS {
             interface Module {
@@ -430,8 +430,8 @@ declare module "socket-function/require/RequireController" {
 }
 
 declare module "socket-function/require/compileFlags" {
+    /// <reference path="RequireController.d.ts" />
     /// <reference types="node" />
-    /// <reference types="socket-function/require/requirecontroller" />
     /**
      *      Adds a global function setFlag(require, "typescript", flag) which sets a flag on the client
      *          - Ex, setFlag(require, "typescript", "allowclient") so allowclient = true on the typescript module.
@@ -453,7 +453,7 @@ declare module "socket-function/require/extMapper" {
 }
 
 declare module "socket-function/require/require" {
-    /// <reference types="socket-function/src/src" />
+    /// <reference path="../src/src.d.ts" />
     declare global {
         var onProgressHandler: undefined | ((progress: {
             type: string;
@@ -789,7 +789,7 @@ declare module "socket-function/src/callHTTPHandler" {
 }
 
 declare module "socket-function/src/callManager" {
-    /// <reference types="socket-function/hot/hotreloadcontroller" />
+    /// <reference path="../hot/HotReloadController.d.ts" />
     import { CallerContext, CallType, ClientHookContext, FullCallType, FunctionFlags, HookContext, SocketExposedInterface, SocketExposedShape, SocketFunctionClientHook, SocketFunctionHook, SocketRegistered } from "socket-function/SocketFunctionTypes";
     export declare function getCallFlags(call: CallType): FunctionFlags | undefined;
     export declare function shouldCompressCall(call: CallType): boolean | "LZ4" | undefined;
@@ -1560,13 +1560,28 @@ declare module "socket-function/time/trueTimeShim" {
         fromTime: number;
         toTime: number;
     };
+    export declare function computeTweenedOffset(components: {
+        systemTime: number;
+        fromOffset: number;
+        toOffset: number;
+        fromTime: number;
+    }): number;
     export declare function getTimeComponents(): {
         systemTime: number;
         offset: number;
     };
     export declare function getTrueTime(): number;
     export declare function getTrueTimeOffset(): number;
-    export declare function getTrueTimeProof(): TimeOffsetProof | undefined;
+    export type TrueTimeProof = {
+        systemTime: number;
+        fromOffset: number;
+        toOffset: number;
+        fromTime: number;
+        toTime: number;
+        offset: number;
+        measurement?: TimeOffsetProof;
+    };
+    export declare function getTrueTimeProof(): TrueTimeProof | undefined;
     export declare function waitForFirstTimeSync(): Promise<void> | undefined;
     declare global {
         var TRUE_TIME_ALREADY_SHIMMED: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "socket-function",
-	"version": "1.2.1",
+	"version": "1.2.4",
 	"main": "index.js",
 	"license": "MIT",
 	"dependencies": {

package/require/CSSShim.d.ts

@@ -1,2 +1,2 @@
-/// <reference types="socket-function/require/requirecontroller" />
+/// <reference path="RequireController.d.ts" />
 export {};

package/require/RequireController.d.ts

@@ -1,6 +1,6 @@
+/// <reference path="../../typenode/index.d.ts" />
 /// <reference types="node" />
 /// <reference types="node" />
-/// <reference types="typenode" />
 declare global {
     namespace NodeJS {
         interface Module {
@@ -85,7 +85,7 @@ declare global {
 /** @deprecated, not needed, as this defaults to ".", which is a lot easier to reason about anyways. */
 export declare function setRequireBootRequire(dir: string): void;
 export declare function allowAllNodeModules(): void;
-export declare const RequireController: import("socket-function/SocketFunctionTypes").SocketRegistered<{
+export declare const RequireController: import("../SocketFunctionTypes").SocketRegistered<{
     rootResolvePath: "Function has implementation but is not exposed in the SocketFunction.register call";
     requireHTML: (config?: {
         requireCalls?: string[];

package/require/compileFlags.d.ts

@@ -1,5 +1,5 @@
+/// <reference path="RequireController.d.ts" />
 /// <reference types="node" />
-/// <reference types="socket-function/require/requirecontroller" />
 /**
  *      Adds a global function setFlag(require, "typescript", flag) which sets a flag on the client
  *          - Ex, setFlag(require, "typescript", "allowclient") so allowclient = true on the typescript module.

package/require/require.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="socket-function/src/src" />
+/// <reference path="../src/src.d.ts" />
 declare global {
     var onProgressHandler: undefined | ((progress: {
         type: string;

package/src/callManager.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="socket-function/hot/hotreloadcontroller" />
+/// <reference path="../hot/HotReloadController.d.ts" />
 import { CallerContext, CallType, ClientHookContext, FullCallType, FunctionFlags, HookContext, SocketExposedInterface, SocketExposedShape, SocketFunctionClientHook, SocketFunctionHook, SocketRegistered } from "../SocketFunctionTypes";
 export declare function getCallFlags(call: CallType): FunctionFlags | undefined;
 export declare function shouldCompressCall(call: CallType): boolean | "LZ4" | undefined;

package/test.ts

@@ -1,4 +1,4 @@
-import { getTimeComponentsDetailed, waitForFirstTimeSync } from "./time/trueTimeShim";
+import { computeTweenedOffset, getTimeComponentsDetailed, waitForFirstTimeSync } from "./time/trueTimeShim";
 import * as fs from "fs";
 import * as path from "path";
 
@@ -19,7 +19,6 @@ async function sampleMode() {
         toOffset: number;
         fromTime: number;
         toTime: number;
-        fraction: number;
     };
 
     const samples: Sample[] = [];
@@ -28,11 +27,8 @@ async function sampleMode() {
     for (let i = 0; i < SAMPLE_COUNT; i++) {
         const detailed = getTimeComponentsDetailed();
 
-        // Calculate smearing using the same systemTime
-        const elapsed = detailed.systemTime - detailed.fromTime;
-        const duration = detailed.toTime - detailed.fromTime;
-        const fraction = duration > 0 ? Math.min(1, elapsed / duration) : 0;
-        const offset = detailed.fromOffset + (detailed.toOffset - detailed.fromOffset) * fraction;
+        // Calculate the tween using the same systemTime
+        const offset = computeTweenedOffset(detailed);
 
         samples.push({
             id: TEST_RUN_ID,
@@ -42,7 +38,6 @@ async function sampleMode() {
             toOffset: detailed.toOffset,
             fromTime: detailed.fromTime,
             toTime: detailed.toTime,
-            fraction,
         });
 
         if (SAMPLE_INTERVAL_MS > 0) {
@@ -88,7 +83,6 @@ async function verifyMode() {
         toOffset: number;
         fromTime: number;
         toTime: number;
-        fraction: number;
         file: string;
     };
 
@@ -126,13 +120,13 @@ async function verifyMode() {
             console.error(`    systemTime: ${prev.systemTime}`);
             console.error(`    offset: ${prev.offset}`);
             console.error(`    trueTime: ${prevTrueTime}`);
-            console.error(`    smearing: ${prev.fromOffset} -> ${prev.toOffset} (${(prev.fraction * 100).toFixed(2)}%)`);
+            console.error(`    tween: ${prev.fromOffset} -> ${prev.toOffset}`);
             console.error(`    timeWindow: ${prev.fromTime} -> ${prev.toTime}`);
             console.error(`  Current [ID: ${sample.id}, file: ${sample.file}]:`);
             console.error(`    systemTime: ${sample.systemTime}`);
             console.error(`    offset: ${sample.offset}`);
             console.error(`    trueTime: ${trueTime}`);
-            console.error(`    smearing: ${sample.fromOffset} -> ${sample.toOffset} (${(sample.fraction * 100).toFixed(2)}%)`);
+            console.error(`    tween: ${sample.fromOffset} -> ${sample.toOffset}`);
             console.error(`    timeWindow: ${sample.fromTime} -> ${sample.toTime}`);
             console.error(`  Difference: ${trueTime - lastTrueTime}ms`);
         }

package/time/trueTimeShim.d.ts

@@ -15,13 +15,28 @@ export declare function getTimeComponentsDetailed(): {
     fromTime: number;
     toTime: number;
 };
+export declare function computeTweenedOffset(components: {
+    systemTime: number;
+    fromOffset: number;
+    toOffset: number;
+    fromTime: number;
+}): number;
 export declare function getTimeComponents(): {
     systemTime: number;
     offset: number;
 };
 export declare function getTrueTime(): number;
 export declare function getTrueTimeOffset(): number;
-export declare function getTrueTimeProof(): TimeOffsetProof | undefined;
+export type TrueTimeProof = {
+    systemTime: number;
+    fromOffset: number;
+    toOffset: number;
+    fromTime: number;
+    toTime: number;
+    offset: number;
+    measurement?: TimeOffsetProof;
+};
+export declare function getTrueTimeProof(): TrueTimeProof | undefined;
 export declare function waitForFirstTimeSync(): Promise<void> | undefined;
 declare global {
     var TRUE_TIME_ALREADY_SHIMMED: boolean;

package/time/trueTimeShim.ts

@@ -18,10 +18,18 @@ const FETCH_RETRY_MAX_DELAY = 1000 * 30;
 const FETCH_MAX_FAILURES = 8;
 const NTP_TIMEOUT = 1000 * 10;
 
+// The on-disk LMDB database can become corrupt (ex, a process killed mid-write). After this many
+//  consecutive failed operations we stop just reopening the handle and delete the files to start
+//  fresh - the data is only a cached time offset, so wiping it merely forces a re-measurement.
+const LMDB_MAX_CORRUPTION_FAILURES = 3;
+
 // Time can never go backwards, but we can run at a slower rate until the output time allows
 //      the real time to catch up with it.
 const MINIMUM_TIME_RATE = 0.5;
 
+// The offset tweens toward its target at this fraction of elapsed real time, then plateaus once it gets there. Must stay below 1 so output time keeps moving forward even while the offset is shrinking. Tweening across the whole transition window instead would mean a badly-off clock (many seconds) takes the entire window to converge, which breaks transactional consistency with other machines.
+const OFFSET_TWEEN_RATE = 0.5;
+
 const THROW_ON_ERROR = false;
 
 // Hugely important as if we don't synchronize between processes, it means our logs are going to be confusing and out of order.
@@ -138,13 +146,24 @@ export function getTimeComponentsDetailed(): {
     }
 }
 
+export function computeTweenedOffset(components: {
+    systemTime: number;
+    fromOffset: number;
+    toOffset: number;
+    fromTime: number;
+}): number {
+    const elapsed = Math.max(0, components.systemTime - components.fromTime);
+    const delta = components.toOffset - components.fromOffset;
+    const maxChange = elapsed * OFFSET_TWEEN_RATE;
+    if (Math.abs(delta) <= maxChange) {
+        return components.toOffset;
+    }
+    return components.fromOffset + Math.sign(delta) * maxChange;
+}
+
 export function getTimeComponents(): { systemTime: number; offset: number } {
     const detailed = getTimeComponentsDetailed();
-    const elapsed = detailed.systemTime - detailed.fromTime;
-    const duration = detailed.toTime - detailed.fromTime;
-    const fraction = duration > 0 ? Math.min(1, elapsed / duration) : 0;
-    const offset = detailed.fromOffset + (detailed.toOffset - detailed.fromOffset) * fraction;
-    return { systemTime: detailed.systemTime, offset };
+    return { systemTime: detailed.systemTime, offset: computeTweenedOffset(detailed) };
 }
 
 export function getTrueTime() {
@@ -174,8 +193,30 @@ export function getTrueTimeOffset() {
     const { offset } = getTimeComponents();
     return offset;
 }
-export function getTrueTimeProof(): TimeOffsetProof | undefined {
-    return cachedTimeOffsetData?.proof;
+export type TrueTimeProof = {
+    systemTime: number;
+    // The tween endpoints the current offset is moving between. When offset !== toOffset we are still converging.
+    fromOffset: number;
+    toOffset: number;
+    fromTime: number;
+    toTime: number;
+    offset: number;
+    // The raw measurement that produced the newest offset. Undefined if the offset came from a caller-provided base that only returns numbers.
+    measurement?: TimeOffsetProof;
+};
+export function getTrueTimeProof(): TrueTimeProof | undefined {
+    const data = cachedTimeOffsetData;
+    if (!data) return undefined;
+    const detailed = getTimeComponentsDetailed();
+    return {
+        systemTime: detailed.systemTime,
+        fromOffset: detailed.fromOffset,
+        toOffset: detailed.toOffset,
+        fromTime: detailed.fromTime,
+        toTime: detailed.toTime,
+        offset: computeTweenedOffset(detailed),
+        measurement: data.proof,
+    };
 }
 export function waitForFirstTimeSync(): Promise<void> | undefined {
     if (didFirstTimeSync) return undefined;
@@ -283,67 +324,113 @@ type TimeOffsetStore = {
     putInitial(data: TimeOffsetData): Promise<boolean>;
 };
 
-let timeOffsetDb: import("lmdb").RootDatabase<TimeOffsetData, string> | undefined = undefined;
-async function getTimeOffsetDb() {
-    if (!USE_LMDB_PROCESS_SYNC) return undefined;
-    if (timeOffsetDb) return timeOffsetDb;
-    if (!isNode()) return undefined;
+type TimeOffsetDb = import("lmdb").RootDatabase<TimeOffsetData, string>;
+let timeOffsetDb: TimeOffsetDb | undefined = undefined;
+let timeOffsetDbPath: string | undefined = undefined;
 
+async function openTimeOffsetDb(): Promise<TimeOffsetDb | undefined> {
     try {
         const lmdb = await import("lmdb");
         const path = await import("path");
         const os = await import("os");
 
-        const dbPath = path.join(os.tmpdir(), "socket-function-time-offset-2");
-        timeOffsetDb = lmdb.open<TimeOffsetData, string>({
-            path: dbPath,
+        timeOffsetDbPath = path.join(os.tmpdir(), "socket-function-time-offset-2");
+        return lmdb.open<TimeOffsetData, string>({
+            path: timeOffsetDbPath,
             // Enable versioning for conditional writes
             useVersions: true,
         });
-        return timeOffsetDb;
     } catch (e) {
-        console.error("Error opening LMDB database:", e);
+        console.error("Error opening LMDB database:", (e as Error).stack ?? e);
         return undefined;
     }
 }
 
-function getLmdbStore(db: import("lmdb").RootDatabase<TimeOffsetData, string>): TimeOffsetStore {
+async function getTimeOffsetDb() {
+    if (!USE_LMDB_PROCESS_SYNC) return undefined;
+    if (!isNode()) return undefined;
+    if (timeOffsetDb) return timeOffsetDb;
+    timeOffsetDb = await openTimeOffsetDb();
+    return timeOffsetDb;
+}
+
+// Closes the current handle (so the next op reopens a fresh one) and, when wipe is set, deletes the
+//  on-disk files so a corrupt database is replaced with an empty one. lmdb writes the main file at
+//  the path plus a sibling lock file, so we clear the path and its lock variants.
+async function recreateTimeOffsetDb(config: { wipe: boolean }) {
+    let db = timeOffsetDb;
+    timeOffsetDb = undefined;
+    if (db) {
+        try {
+            await db.close();
+        } catch (e) {
+            console.error("Error closing LMDB database:", (e as Error).stack ?? e);
+        }
+    }
+    if (config.wipe && timeOffsetDbPath) {
+        try {
+            const fs = await import("fs");
+            for (let suffix of ["", "-lock", ".lock"]) {
+                await fs.promises.rm(timeOffsetDbPath + suffix, { recursive: true, force: true });
+            }
+            console.log(yellow(`Wiped corrupt time-offset LMDB database at ${timeOffsetDbPath}`));
+        } catch (e) {
+            console.error("Error wiping corrupt LMDB database:", (e as Error).stack ?? e);
+        }
+    }
+}
+
+// A corrupt database throws on every read and on the read-back inside every write, and we can't
+//  repair it. So we run each op through here: on success we reset the failure count, and on error
+//  we reopen the handle (wiping the files once we've hit the threshold) and return the fallback so
+//  callers degrade to running unsynced instead of throwing. Ops are serialized by updatingOffset,
+//  so there is no concurrent access to worry about.
+let lmdbCorruptionFailures = 0;
+async function runLmdbOp<T>(name: string, op: (db: TimeOffsetDb) => Promise<T>, fallback: T): Promise<T> {
+    const db = await getTimeOffsetDb();
+    if (!db) return fallback;
+    try {
+        const result = await op(db);
+        lmdbCorruptionFailures = 0;
+        return result;
+    } catch (e) {
+        lmdbCorruptionFailures++;
+        console.error(`Error during LMDB ${name} (failure ${lmdbCorruptionFailures}/${LMDB_MAX_CORRUPTION_FAILURES}):`, (e as Error).stack ?? e);
+        let wipe = lmdbCorruptionFailures >= LMDB_MAX_CORRUPTION_FAILURES;
+        await recreateTimeOffsetDb({ wipe });
+        if (wipe) lmdbCorruptionFailures = 0;
+        return fallback;
+    }
+}
+
+function getLmdbStore(): TimeOffsetStore {
     return {
         async getEntry() {
-            try {
+            return runLmdbOp("getEntry", async (db) => {
                 const entry = await db.getEntry("timeOffset"); // Gets {value, version} atomically
                 if (!entry) return undefined;
                 if (typeof entry.version !== "number" || !isValidTimeOffsetData(entry.value)) return undefined;
                 return { data: entry.value, version: entry.version };
-            } catch (e) {
-                console.error("Error reading from LMDB database:", e);
-                return undefined;
-            }
+            }, undefined);
         },
         async putIfVersion(data, expectedVersion) {
-            try {
+            return runLmdbOp("putIfVersion", async (db) => {
                 // Use random version to minimize collision probability on retries
                 const newVersion = Math.random();
                 const success = await db.ifVersion("timeOffset", expectedVersion, () => {
                     return db.put("timeOffset", data, newVersion);
                 });
                 return success !== undefined;
-            } catch (e) {
-                console.error("Error writing to LMDB database:", e);
-                return false;
-            }
+            }, false);
         },
         async putInitial(data) {
-            try {
+            return runLmdbOp("putInitial", async (db) => {
                 const newVersion = Math.random();
                 await db.put("timeOffset", data, newVersion);
                 // Read back to see what actually got written
                 const actualEntry = await db.getEntry("timeOffset");
                 return actualEntry?.version === newVersion;
-            } catch (e) {
-                console.error("Error writing to LMDB database:", e);
-                return false;
-            }
+            }, false);
         },
     };
 }
@@ -407,7 +494,7 @@ async function getTimeOffsetStore(): Promise<TimeOffsetStore | undefined> {
     if (isNode()) {
         const db = await getTimeOffsetDb();
         if (db) {
-            timeOffsetStore = getLmdbStore(db);
+            timeOffsetStore = getLmdbStore();
         }
     } else {
         timeOffsetStore = getLocalStorageStore();

package/dist/SetProcessVariables.ts.cache

@@ -1,9 +0,0 @@
-"use strict"; var console = (function shimConsole() {             let baseConsole = globalThis.console;             if (typeof window !== "undefined")                 return baseConsole;             let name = __filename.replaceAll("\\", "/").split("/").pop();             let dirName = __dirname.replaceAll("\\", "/").split("/").pop();             let context = {                 __FILE__: __filename,                 __DIR__: __dirname,                 __NAME__: name,                 __DIRNAME__: dirName             };             let newConsole = {                 ...baseConsole             };             for (let shim of ["log", "info", "warn", "error"]) {                 newConsole[shim] = (...args) => {                     args.push(context);                     baseConsole[shim](...args);                 };             }             newConsole.__context = context;             return newConsole;         })(); "use strict";
-Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
-module.allowclient = true;
-const misc_1 = require("./src/misc");
-if (!(0, misc_1.isNode)()) {
-    process.env.CBOR_NATIVE_ACCELERATION_DISABLED = "true";
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU2V0UHJvY2Vzc1ZhcmlhYmxlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIlNldFByb2Nlc3NWYXJpYWJsZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSxNQUFNLENBQUMsV0FBVyxHQUFHLElBQUksQ0FBQztBQUMxQixxQ0FBb0M7QUFFcEMsSUFBSSxDQUFDLElBQUEsYUFBTSxHQUFFLEVBQUUsQ0FBQztJQUNaLE9BQU8sQ0FBQyxHQUFHLENBQUMsaUNBQWlDLEdBQUcsTUFBTSxDQUFDO0FBQzNELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJtb2R1bGUuYWxsb3djbGllbnQgPSB0cnVlO1xuaW1wb3J0IHsgaXNOb2RlIH0gZnJvbSBcIi4vc3JjL21pc2NcIjtcblxuaWYgKCFpc05vZGUoKSkge1xuICAgIHByb2Nlc3MuZW52LkNCT1JfTkFUSVZFX0FDQ0VMRVJBVElPTl9ESVNBQkxFRCA9IFwidHJ1ZVwiO1xufSJdfQ=//=
- /* _JS_SOURCE_HASH = "249631df8c5cbb77a37aa988d0d9d058d467b254000e31ac2a58f9161b5a8626"; */