@workflow/web-shared 5.0.0-beta.2 → 5.0.0-beta.20

package/dist/lib/utils.js

@@ -3,9 +3,6 @@ import { twMerge } from 'tailwind-merge';
 export function cn(...inputs) {
     return twMerge(clsx(inputs));
 }
-const durationFormatter = new Intl.NumberFormat(undefined, {
-    maximumFractionDigits: 2,
-});
 const MS_IN_SECOND = 1000;
 const MS_IN_MINUTE = 60 * MS_IN_SECOND;
 const MS_IN_HOUR = 60 * MS_IN_MINUTE;
@@ -14,48 +11,48 @@ const MS_IN_DAY = 24 * MS_IN_HOUR;
  * Formats a duration in milliseconds to a human-readable string.
  *
  * @param ms - Duration in milliseconds
- * @param compact - If true, returns a single-unit format (e.g., "45s", "2.5m").
- *                  If false (default), returns multi-part format (e.g., "1h 30m", "2d 5h").
+ * @param compact - If true, returns a compact format (e.g., "380ms", "2m 30s").
+ *                  If false (default), returns multi-part format (e.g., "1m 13s", "2d 5h 3m 12s").
  *
- * Compact format:
- * - < 1s: shows milliseconds (e.g., "500ms")
+ * Compact format (timeline markers):
+ * - < 1s: shows milliseconds (e.g., "380ms")
  * - < 1m: shows seconds (e.g., "45s")
- * - < 1h: shows minutes (e.g., "45m")
- * - >= 1h: shows hours (e.g., "2.5h")
+ * - < 1h: shows minutes and seconds (e.g., "2m 30s")
+ * - >= 1h: shows hours and minutes (e.g., "2h 30m")
  *
  * Full format:
- * - < 1s: shows milliseconds (e.g., "500ms")
- * - < 1m: shows seconds (e.g., "45.5s")
- * - >= 1m: shows human-readable format (e.g., "1h 30m", "2d 5h")
+ * - < 1s: shows milliseconds (e.g., "380ms")
+ * - < 1m: shows seconds (e.g., "45s")
+ * - >= 1m: shows decomposed format with whole seconds (e.g., "1m 13s", "2m 13s")
  */
 export function formatDuration(ms, compact = false) {
     if (ms === 0) {
-        return '0';
+        return '0s';
     }
-    // For durations less than 1 second, show milliseconds
     if (ms < MS_IN_SECOND) {
-        return `${durationFormatter.format(ms)}ms`;
+        const roundedMs = Math.round(ms);
+        return roundedMs < MS_IN_SECOND ? `${roundedMs}ms` : '1s';
     }
-    // For durations less than 1 minute, show seconds
-    if (ms < MS_IN_MINUTE) {
-        return `${durationFormatter.format(ms / MS_IN_SECOND)}s`;
+    const roundedMs = Math.round(ms / MS_IN_SECOND) * MS_IN_SECOND;
+    if (roundedMs < MS_IN_MINUTE) {
+        return `${Math.floor(roundedMs / MS_IN_SECOND)}s`;
     }
     // Compact format: multi-unit without decimals (e.g. "8m 20s", "2h 30m")
     if (compact) {
-        if (ms < MS_IN_HOUR) {
-            const m = Math.floor(ms / MS_IN_MINUTE);
-            const s = Math.floor((ms % MS_IN_MINUTE) / MS_IN_SECOND);
+        if (roundedMs < MS_IN_HOUR) {
+            const m = Math.floor(roundedMs / MS_IN_MINUTE);
+            const s = Math.floor((roundedMs % MS_IN_MINUTE) / MS_IN_SECOND);
             return s > 0 ? `${m}m ${s}s` : `${m}m`;
         }
-        const h = Math.floor(ms / MS_IN_HOUR);
-        const m = Math.floor((ms % MS_IN_HOUR) / MS_IN_MINUTE);
+        const h = Math.floor(roundedMs / MS_IN_HOUR);
+        const m = Math.floor((roundedMs % MS_IN_HOUR) / MS_IN_MINUTE);
         return m > 0 ? `${h}h ${m}m` : `${h}h`;
     }
-    // Full format: human-readable multi-part
-    const days = Math.floor(ms / MS_IN_DAY);
-    const hours = Math.floor((ms % MS_IN_DAY) / MS_IN_HOUR);
-    const minutes = Math.floor((ms % MS_IN_HOUR) / MS_IN_MINUTE);
-    const seconds = Math.floor((ms % MS_IN_MINUTE) / MS_IN_SECOND);
+    // Full format: decompose into larger units + whole seconds.
+    const days = Math.floor(roundedMs / MS_IN_DAY);
+    const hours = Math.floor((roundedMs % MS_IN_DAY) / MS_IN_HOUR);
+    const minutes = Math.floor((roundedMs % MS_IN_HOUR) / MS_IN_MINUTE);
+    const seconds = Math.floor((roundedMs % MS_IN_MINUTE) / MS_IN_SECOND);
     const parts = [];
     if (days > 0) {
         parts.push(`${days}d`);
@@ -66,9 +63,55 @@ export function formatDuration(ms, compact = false) {
     if (minutes > 0) {
         parts.push(`${minutes}m`);
     }
-    if (hours <= 1 && (seconds > 0 || parts.length === 0)) {
-        parts.push(`${seconds}s`);
+    parts.push(`${seconds}s`);
+    return parts.join(' ');
+}
+// Locale-aware formatter that always renders exactly two fraction digits.
+// Used for the seconds component of precise durations so values are never
+// snapped to a whole second (and thousands separators stay correct).
+const preciseSecondsFormatter = new Intl.NumberFormat(undefined, {
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2,
+});
+/**
+ * Formats a duration in milliseconds without snapping to whole seconds.
+ *
+ * Unlike {@link formatDuration}, this never rounds a sub-minute value up to
+ * the next whole second (e.g. 1626ms renders as "1.63s", not "2s").
+ *
+ * - < 1s: shows whole milliseconds (e.g. "626ms")
+ * - 1s – 1m: shows seconds with two decimals (e.g. "1.63s", "45.20s")
+ * - >= 1m: decomposes into d/h/m with two-decimal seconds (e.g. "1m 13.45s")
+ */
+export function formatDurationPrecise(ms) {
+    if (ms === 0) {
+        return '0s';
+    }
+    if (ms < MS_IN_SECOND) {
+        const roundedMs = Math.round(ms);
+        if (roundedMs < MS_IN_SECOND) {
+            return `${roundedMs}ms`;
+        }
+    }
+    const normalizedMs = Math.round(ms / 10) * 10;
+    if (normalizedMs < MS_IN_MINUTE) {
+        return `${preciseSecondsFormatter.format(normalizedMs / MS_IN_SECOND)}s`;
+    }
+    const days = Math.floor(normalizedMs / MS_IN_DAY);
+    const hours = Math.floor((normalizedMs % MS_IN_DAY) / MS_IN_HOUR);
+    const minutes = Math.floor((normalizedMs % MS_IN_HOUR) / MS_IN_MINUTE);
+    const seconds = (normalizedMs % MS_IN_MINUTE) / MS_IN_SECOND;
+    const parts = [];
+    if (days > 0) {
+        parts.push(`${days}d`);
+    }
+    if (hours > 0) {
+        parts.push(`${hours}h`);
+    }
+    if (minutes > 0) {
+        parts.push(`${minutes}m`);
     }
+    parts.push(`${preciseSecondsFormatter.format(seconds)}s`);
     return parts.join(' ');
 }
 /**
@@ -129,4 +172,4 @@ export function identifyStreamSteps(steps) {
         };
     });
 }
-//# sourceMappingURL=utils.js.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/lib/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Step } from '@workflow/world';\nimport type { ModelMessage } from 'ai';\nimport { type ClassValue, clsx } from 'clsx';\nimport { twMerge } from 'tailwind-merge';\n\nexport function cn(...inputs: ClassValue[]) {\n  return twMerge(clsx(inputs));\n}\n\nconst MS_IN_SECOND = 1000;\nconst MS_IN_MINUTE = 60 * MS_IN_SECOND;\nconst MS_IN_HOUR = 60 * MS_IN_MINUTE;\nconst MS_IN_DAY = 24 * MS_IN_HOUR;\n\n/**\n * Formats a duration in milliseconds to a human-readable string.\n *\n * @param ms - Duration in milliseconds\n * @param compact - If true, returns a compact format (e.g., \"380ms\", \"2m 30s\").\n *                  If false (default), returns multi-part format (e.g., \"1m 13s\", \"2d 5h 3m 12s\").\n *\n * Compact format (timeline markers):\n * - < 1s: shows milliseconds (e.g., \"380ms\")\n * - < 1m: shows seconds (e.g., \"45s\")\n * - < 1h: shows minutes and seconds (e.g., \"2m 30s\")\n * - >= 1h: shows hours and minutes (e.g., \"2h 30m\")\n *\n * Full format:\n * - < 1s: shows milliseconds (e.g., \"380ms\")\n * - < 1m: shows seconds (e.g., \"45s\")\n * - >= 1m: shows decomposed format with whole seconds (e.g., \"1m 13s\", \"2m 13s\")\n */\nexport function formatDuration(ms: number, compact = false): string {\n  if (ms === 0) {\n    return '0s';\n  }\n\n  if (ms < MS_IN_SECOND) {\n    const roundedMs = Math.round(ms);\n    return roundedMs < MS_IN_SECOND ? `${roundedMs}ms` : '1s';\n  }\n\n  const roundedMs = Math.round(ms / MS_IN_SECOND) * MS_IN_SECOND;\n\n  if (roundedMs < MS_IN_MINUTE) {\n    return `${Math.floor(roundedMs / MS_IN_SECOND)}s`;\n  }\n\n  // Compact format: multi-unit without decimals (e.g. \"8m 20s\", \"2h 30m\")\n  if (compact) {\n    if (roundedMs < MS_IN_HOUR) {\n      const m = Math.floor(roundedMs / MS_IN_MINUTE);\n      const s = Math.floor((roundedMs % MS_IN_MINUTE) / MS_IN_SECOND);\n      return s > 0 ? `${m}m ${s}s` : `${m}m`;\n    }\n    const h = Math.floor(roundedMs / MS_IN_HOUR);\n    const m = Math.floor((roundedMs % MS_IN_HOUR) / MS_IN_MINUTE);\n    return m > 0 ? `${h}h ${m}m` : `${h}h`;\n  }\n\n  // Full format: decompose into larger units + whole seconds.\n  const days = Math.floor(roundedMs / MS_IN_DAY);\n  const hours = Math.floor((roundedMs % MS_IN_DAY) / MS_IN_HOUR);\n  const minutes = Math.floor((roundedMs % MS_IN_HOUR) / MS_IN_MINUTE);\n  const seconds = Math.floor((roundedMs % MS_IN_MINUTE) / MS_IN_SECOND);\n\n  const parts: string[] = [];\n\n  if (days > 0) {\n    parts.push(`${days}d`);\n  }\n  if (hours > 0) {\n    parts.push(`${hours}h`);\n  }\n  if (minutes > 0) {\n    parts.push(`${minutes}m`);\n  }\n  parts.push(`${seconds}s`);\n\n  return parts.join(' ');\n}\n\n// Locale-aware formatter that always renders exactly two fraction digits.\n// Used for the seconds component of precise durations so values are never\n// snapped to a whole second (and thousands separators stay correct).\nconst preciseSecondsFormatter = new Intl.NumberFormat(undefined, {\n  minimumFractionDigits: 2,\n  maximumFractionDigits: 2,\n});\n\n/**\n * Formats a duration in milliseconds without snapping to whole seconds.\n *\n * Unlike {@link formatDuration}, this never rounds a sub-minute value up to\n * the next whole second (e.g. 1626ms renders as \"1.63s\", not \"2s\").\n *\n * - < 1s: shows whole milliseconds (e.g. \"626ms\")\n * - 1s – 1m: shows seconds with two decimals (e.g. \"1.63s\", \"45.20s\")\n * - >= 1m: decomposes into d/h/m with two-decimal seconds (e.g. \"1m 13.45s\")\n */\nexport function formatDurationPrecise(ms: number): string {\n  if (ms === 0) {\n    return '0s';\n  }\n\n  if (ms < MS_IN_SECOND) {\n    const roundedMs = Math.round(ms);\n    if (roundedMs < MS_IN_SECOND) {\n      return `${roundedMs}ms`;\n    }\n  }\n\n  const normalizedMs = Math.round(ms / 10) * 10;\n\n  if (normalizedMs < MS_IN_MINUTE) {\n    return `${preciseSecondsFormatter.format(normalizedMs / MS_IN_SECOND)}s`;\n  }\n\n  const days = Math.floor(normalizedMs / MS_IN_DAY);\n  const hours = Math.floor((normalizedMs % MS_IN_DAY) / MS_IN_HOUR);\n  const minutes = Math.floor((normalizedMs % MS_IN_HOUR) / MS_IN_MINUTE);\n  const seconds = (normalizedMs % MS_IN_MINUTE) / MS_IN_SECOND;\n\n  const parts: string[] = [];\n\n  if (days > 0) {\n    parts.push(`${days}d`);\n  }\n  if (hours > 0) {\n    parts.push(`${hours}h`);\n  }\n  if (minutes > 0) {\n    parts.push(`${minutes}m`);\n  }\n  parts.push(`${preciseSecondsFormatter.format(seconds)}s`);\n\n  return parts.join(' ');\n}\n\n/**\n * Returns a formatted pagination display string\n * @param currentPage - The current page number\n * @param totalPages - The total number of pages visited so far\n * @param hasMore - Whether there are more pages available\n * @returns Formatted string like \"Page 1 of 3+\" or \"Page 2 of 2\"\n */\nexport function getPaginationDisplay(\n  currentPage: number,\n  totalPages: number,\n  hasMore: boolean\n): string {\n  if (hasMore) {\n    return `Page ${currentPage} of ${totalPages}+`;\n  }\n  return `Page ${currentPage} of ${totalPages}`;\n}\n\n// ============================================================================\n// Durable Agent Utilities\n// ============================================================================\n\n/**\n * Check if a step is a doStreamStep (LLM call with conversation input)\n */\nexport function isDoStreamStep(stepName: string): boolean {\n  return stepName.endsWith('//doStreamStep');\n}\n\n/**\n * Extract the conversation from a hydrated doStreamStep input.\n * doStreamStep signature: (conversationPrompt, model, writable, tools, options)\n * So input[0] is the conversation.\n */\nexport function extractConversation(stepInput: unknown): ModelMessage[] | null {\n  if (!Array.isArray(stepInput) || stepInput.length === 0) {\n    return null;\n  }\n\n  const firstArg = stepInput[0];\n\n  if (!Array.isArray(firstArg)) {\n    return null;\n  }\n\n  // Validate it looks like ModelMessage[]\n  if (\n    !firstArg.every((msg) => msg && typeof msg === 'object' && 'role' in msg)\n  ) {\n    return null;\n  }\n\n  return firstArg as ModelMessage[];\n}\n\n/**\n * A doStreamStep with its conversation input extracted\n */\nexport interface StreamStep {\n  stepId: string;\n  stepName: string;\n  displayName: string;\n  conversation: ModelMessage[];\n}\n\n/**\n * Identifies all stream steps (doStreamStep) in a run and extracts their conversations.\n */\nexport function identifyStreamSteps(steps: Step[]): StreamStep[] {\n  return steps\n    .filter((step) => isDoStreamStep(step.stepName))\n    .map((step) => {\n      const functionName = step.stepName.split('//').pop() ?? 'unknown';\n      const conversation = extractConversation(step.input) ?? [];\n\n      return {\n        stepId: step.stepId,\n        stepName: step.stepName,\n        displayName: functionName,\n        conversation,\n      };\n    });\n}\n"]}

package/dist/lib/zstd-browser-decoder.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Register the browser zstd decoder with `@workflow/core` (idempotent).
+ * Call this before hydrating payloads that may be zstd-compressed; the
+ * actual WASM compile + decode happens lazily on first use.
+ */
+export declare function ensureZstdDecoderRegistered(): void;
+//# sourceMappingURL=zstd-browser-decoder.d.ts.map

package/dist/lib/zstd-browser-decoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zstd-browser-decoder.d.ts","sourceRoot":"","sources":["../../src/lib/zstd-browser-decoder.ts"],"names":[],"mappings":"AA4BA;;;;GAIG;AACH,wBAAgB,2BAA2B,IAAI,IAAI,CAQlD"}

package/dist/lib/zstd-browser-decoder.js

@@ -0,0 +1,41 @@
+/**
+ * Browser zstd decoder for the o11y read path.
+ *
+ * The Web `DecompressionStream` has no zstd support, so `@workflow/core`'s
+ * `hydrateDataWithKey` delegates zstd inflation to a decoder registered via
+ * `registerZstdDecoder`. This module supplies that decoder, backed by the
+ * `@tootallnate/zstd-wasm` single-file WASM decoder.
+ *
+ * The package leaves WASM sourcing to the caller; we resolve the shipped
+ * `zstd.wasm` as a bundler asset (`new URL(..., import.meta.url)`, the same
+ * pattern the trace-viewer Worker uses) and compile it once, lazily — the
+ * WASM is fetched only the first time a zstd payload is actually decoded.
+ */
+import { registerZstdDecoder } from '@workflow/core/serialization-format';
+let registered = false;
+let modulePromise;
+function loadWasmModule() {
+    if (!modulePromise) {
+        const url = new URL('@tootallnate/zstd-wasm/zstd.wasm', import.meta.url);
+        modulePromise = fetch(url)
+            .then((res) => res.arrayBuffer())
+            .then((bytes) => WebAssembly.compile(bytes));
+    }
+    return modulePromise;
+}
+/**
+ * Register the browser zstd decoder with `@workflow/core` (idempotent).
+ * Call this before hydrating payloads that may be zstd-compressed; the
+ * actual WASM compile + decode happens lazily on first use.
+ */
+export function ensureZstdDecoderRegistered() {
+    if (registered)
+        return;
+    registered = true;
+    registerZstdDecoder(async (payload) => {
+        const { decompressBytes } = await import('@tootallnate/zstd-wasm');
+        const wasmModule = await loadWasmModule();
+        return decompressBytes(wasmModule, payload);
+    });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoienN0ZC1icm93c2VyLWRlY29kZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbGliL3pzdGQtYnJvd3Nlci1kZWNvZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7R0FZRztBQUNILE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLHFDQUFxQyxDQUFDO0FBRTFFLElBQUksVUFBVSxHQUFHLEtBQUssQ0FBQztBQUN2QixJQUFJLGFBQXNELENBQUM7QUFFM0QsU0FBUyxjQUFjO0lBQ3JCLElBQUksQ0FBQyxhQUFhLEVBQUUsQ0FBQztRQUNuQixNQUFNLEdBQUcsR0FBRyxJQUFJLEdBQUcsQ0FBQyxrQ0FBa0MsRUFBRSxNQUFNLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBQ3pFLGFBQWEsR0FBRyxLQUFLLENBQUMsR0FBRyxDQUFDO2FBQ3ZCLElBQUksQ0FBQyxDQUFDLEdBQUcsRUFBRSxFQUFFLENBQUMsR0FBRyxDQUFDLFdBQVcsRUFBRSxDQUFDO2FBQ2hDLElBQUksQ0FBQyxDQUFDLEtBQUssRUFBRSxFQUFFLENBQUMsV0FBVyxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDO0lBQ2pELENBQUM7SUFDRCxPQUFPLGFBQWEsQ0FBQztBQUN2QixDQUFDO0FBRUQ7Ozs7R0FJRztBQUNILE1BQU0sVUFBVSwyQkFBMkI7SUFDekMsSUFBSSxVQUFVO1FBQUUsT0FBTztJQUN2QixVQUFVLEdBQUcsSUFBSSxDQUFDO0lBQ2xCLG1CQUFtQixDQUFDLEtBQUssRUFBRSxPQUFPLEVBQUUsRUFBRTtRQUNwQyxNQUFNLEVBQUUsZUFBZSxFQUFFLEdBQUcsTUFBTSxNQUFNLENBQUMsd0JBQXdCLENBQUMsQ0FBQztRQUNuRSxNQUFNLFVBQVUsR0FBRyxNQUFNLGNBQWMsRUFBRSxDQUFDO1FBQzFDLE9BQU8sZUFBZSxDQUFDLFVBQVUsRUFBRSxPQUFPLENBQUMsQ0FBQztJQUM5QyxDQUFDLENBQUMsQ0FBQztBQUNMLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEJyb3dzZXIgenN0ZCBkZWNvZGVyIGZvciB0aGUgbzExeSByZWFkIHBhdGguXG4gKlxuICogVGhlIFdlYiBgRGVjb21wcmVzc2lvblN0cmVhbWAgaGFzIG5vIHpzdGQgc3VwcG9ydCwgc28gYEB3b3JrZmxvdy9jb3JlYCdzXG4gKiBgaHlkcmF0ZURhdGFXaXRoS2V5YCBkZWxlZ2F0ZXMgenN0ZCBpbmZsYXRpb24gdG8gYSBkZWNvZGVyIHJlZ2lzdGVyZWQgdmlhXG4gKiBgcmVnaXN0ZXJac3RkRGVjb2RlcmAuIFRoaXMgbW9kdWxlIHN1cHBsaWVzIHRoYXQgZGVjb2RlciwgYmFja2VkIGJ5IHRoZVxuICogYEB0b290YWxsbmF0ZS96c3RkLXdhc21gIHNpbmdsZS1maWxlIFdBU00gZGVjb2Rlci5cbiAqXG4gKiBUaGUgcGFja2FnZSBsZWF2ZXMgV0FTTSBzb3VyY2luZyB0byB0aGUgY2FsbGVyOyB3ZSByZXNvbHZlIHRoZSBzaGlwcGVkXG4gKiBgenN0ZC53YXNtYCBhcyBhIGJ1bmRsZXIgYXNzZXQgKGBuZXcgVVJMKC4uLiwgaW1wb3J0Lm1ldGEudXJsKWAsIHRoZSBzYW1lXG4gKiBwYXR0ZXJuIHRoZSB0cmFjZS12aWV3ZXIgV29ya2VyIHVzZXMpIGFuZCBjb21waWxlIGl0IG9uY2UsIGxhemlseSDigJQgdGhlXG4gKiBXQVNNIGlzIGZldGNoZWQgb25seSB0aGUgZmlyc3QgdGltZSBhIHpzdGQgcGF5bG9hZCBpcyBhY3R1YWxseSBkZWNvZGVkLlxuICovXG5pbXBvcnQgeyByZWdpc3RlclpzdGREZWNvZGVyIH0gZnJvbSAnQHdvcmtmbG93L2NvcmUvc2VyaWFsaXphdGlvbi1mb3JtYXQnO1xuXG5sZXQgcmVnaXN0ZXJlZCA9IGZhbHNlO1xubGV0IG1vZHVsZVByb21pc2U6IFByb21pc2U8V2ViQXNzZW1ibHkuTW9kdWxlPiB8IHVuZGVmaW5lZDtcblxuZnVuY3Rpb24gbG9hZFdhc21Nb2R1bGUoKTogUHJvbWlzZTxXZWJBc3NlbWJseS5Nb2R1bGU+IHtcbiAgaWYgKCFtb2R1bGVQcm9taXNlKSB7XG4gICAgY29uc3QgdXJsID0gbmV3IFVSTCgnQHRvb3RhbGxuYXRlL3pzdGQtd2FzbS96c3RkLndhc20nLCBpbXBvcnQubWV0YS51cmwpO1xuICAgIG1vZHVsZVByb21pc2UgPSBmZXRjaCh1cmwpXG4gICAgICAudGhlbigocmVzKSA9PiByZXMuYXJyYXlCdWZmZXIoKSlcbiAgICAgIC50aGVuKChieXRlcykgPT4gV2ViQXNzZW1ibHkuY29tcGlsZShieXRlcykpO1xuICB9XG4gIHJldHVybiBtb2R1bGVQcm9taXNlO1xufVxuXG4vKipcbiAqIFJlZ2lzdGVyIHRoZSBicm93c2VyIHpzdGQgZGVjb2RlciB3aXRoIGBAd29ya2Zsb3cvY29yZWAgKGlkZW1wb3RlbnQpLlxuICogQ2FsbCB0aGlzIGJlZm9yZSBoeWRyYXRpbmcgcGF5bG9hZHMgdGhhdCBtYXkgYmUgenN0ZC1jb21wcmVzc2VkOyB0aGVcbiAqIGFjdHVhbCBXQVNNIGNvbXBpbGUgKyBkZWNvZGUgaGFwcGVucyBsYXppbHkgb24gZmlyc3QgdXNlLlxuICovXG5leHBvcnQgZnVuY3Rpb24gZW5zdXJlWnN0ZERlY29kZXJSZWdpc3RlcmVkKCk6IHZvaWQge1xuICBpZiAocmVnaXN0ZXJlZCkgcmV0dXJuO1xuICByZWdpc3RlcmVkID0gdHJ1ZTtcbiAgcmVnaXN0ZXJac3RkRGVjb2Rlcihhc3luYyAocGF5bG9hZCkgPT4ge1xuICAgIGNvbnN0IHsgZGVjb21wcmVzc0J5dGVzIH0gPSBhd2FpdCBpbXBvcnQoJ0B0b290YWxsbmF0ZS96c3RkLXdhc20nKTtcbiAgICBjb25zdCB3YXNtTW9kdWxlID0gYXdhaXQgbG9hZFdhc21Nb2R1bGUoKTtcbiAgICByZXR1cm4gZGVjb21wcmVzc0J5dGVzKHdhc21Nb2R1bGUsIHBheWxvYWQpO1xuICB9KTtcbn1cbiJdfQ==