npm - llm-testrunner-components - Versions diffs - 1.0.0 → 1.0.2 - Mend

llm-testrunner-components 1.0.0 → 1.0.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (103) hide show

package/README.md CHANGED Viewed

@@ -1,108 +1,93 @@
 # LLM TestRunner Web Components
-A Stencil web component library that provides reusable components for displaying greetings and current time.
+A Stencil web component library that provides a comprehensive LLM testing solution with automated evaluation capabilities.
+## Overview
+The LLM TestRunner is a tool for testing Large Language Model (LLM) responses against expected criteria. It provides a complete interface for:
+- **Question Management**: Add, edit, and organize test questions
+- **AI Integration**: Direct integration with Google's Gemini AI API
+- **Automated Evaluation**: Built-in evaluation engine that checks responses against expected keywords and source links
+- **Batch Testing**: Run multiple tests sequentially
+- **Real-time Results**: Live evaluation results with pass/fail indicators
 ## Components
-### `<my-component>`
-A greeting component that displays a personalized message with the current time.
+### `<llm-test-runner>`
+The main component that provides a complete LLM testing interface.
-**Props:**
-- `first` (string): First name
-- `middle` (string, optional): Middle name
-- `last` (string): Last name
+**Features:**
+- Question input with expected keywords and source links
+- Real-time AI response generation via Gemini API
+- Test case management (add, delete, run individual or all tests)
+- Built-in evaluation engine with keyword and source link matching
+- Error handling and loading states
+- Rate limiting for batch operations
-**Example:**
+**Usage:**
 ```html
-<my-component first="John" middle="William" last="Doe"></my-component>
+<llm-test-runner api-key="your-gemini-api-key-here"></llm-test-runner>
 ```
-### `<current-time>`
-A component that displays the current time and updates every second.
+## 🎯 Usage Modes
-**Example:**
+### 1. Direct HTML Usage
+Simply include the component in your HTML:
 ```html
-<current-time></current-time>
+<!DOCTYPE html>
+<html>
+<head>
+  <script type="module" src="/build/llm-testrunner.esm.js"></script>
+  <script nomodule src="/build/llm-testrunner.js"></script>
+</head>
+<body>
+  <llm-test-runner api-key="your-gemini-api-key-here"></llm-test-runner>
+</body>
+</html>
 ```
-## Publishing to NPM
-1. **Login to NPM:**
-   ```bash
-   npm adduser
-   ```
-2. **Build the components:**
-   ```bash
-   npm run build
-   ```
-3. **Publish to NPM:**
-   ```bash
-   npm publish --access public
-   ```
-## Using in React Applications
-### Installation
+### 2. Library Integration
+Import as a module in your application:
+```javascript
+import { LLMTestRunner } from 'llm-testrunner-components';
-```bash
-npm install @arupmishra/llm-testrunner-components
+// The component is automatically registered and ready to use
 ```
-### Integration
+## Configuration
-1. **Import and define custom elements in your React component:**
+### API Key Prop
+The component accepts the Gemini API key as a prop.
-```tsx
-import React, { useEffect } from 'react';
-import { defineCustomElements } from '@arupmishra/llm-testrunner-components/loader';
-// Define TypeScript types for the custom elements
-declare global {
-  namespace JSX {
-    interface IntrinsicElements {
-      'my-component': any;
-      'current-time': any;
-    }
-  }
-}
+```html
+<llm-test-runner api-key="your-gemini-api-key-here"></llm-test-runner>
+```
+### React/JSX Usage
+```jsx
 function App() {
-  useEffect(() => {
-    // Define the custom elements when the component mounts
-    defineCustomElements();
-  }, []);
   return (
     <div>
-      <my-component first="John" middle="William" last="Doe"></my-component>
-      <current-time></current-time>
+      <llm-test-runner apiKey="your-gemini-api-key-here" />
     </div>
   );
 }
 ```
-2. **For better TypeScript support, create type definitions:**
+## Evaluation Engine
-```tsx
-// types/stencil-components.d.ts
-import { JSX as LocalJSX } from '@arupmishra/llm-testrunner-components';
-import { HTMLAttributes } from 'react';
+The built-in evaluation engine provides:
-type StencilToReact<T> = {
-  [P in keyof T]?: T[P] & Omit<HTMLAttributes<Element>, 'className'> & {
-    class?: string;
-  };
-};
+- **Keyword Matching**: Case-insensitive matching of expected keywords in AI responses
+- **Source Link Validation**: Checks for presence of expected URLs in responses
+- **Pass/Fail Logic**: Tests pass only when ALL expected items are found
+- **Detailed Results**: Shows which keywords and links were found/missing
-declare global {
-  export namespace JSX {
-    interface IntrinsicElements
-      extends StencilToReact<LocalJSX.IntrinsicElements> {}
-  }
-}
-```
+### Evaluation Criteria
+- **Keywords**: Must be present in the AI response (case-insensitive)
+- **Source Links**: Must be present as exact URL matches
+- **Pass Condition**: ALL expected keywords AND source links must be found
 ## Development
@@ -121,16 +106,89 @@ npm test
 npm start
 ```
-## Demo
+### Project Structure
+```
+src/
+├── components/
+│   └── llm-test-runner/          # Main component
+│       ├── llm-test-runner.tsx   # Component logic
+│       ├── llm-test-runner.css   # Styling
+│       └── readme.md             # Component documentation
+├── lib/
+│   └── evaluation/               # Evaluation engine
+│       ├── evaluation-engine.ts  # Core evaluation logic
+│       ├── types.ts              # TypeScript interfaces
+│       └── index.ts              # Exports
+└── index.ts                      # Main library exports
+```
-A complete React demo application is available in the `../react-web-component-demo` directory showing how to integrate these web components into a React application.
+## Using in React Applications
-To run the demo:
+### Installation
 ```bash
-cd ../react-web-component-demo
-npm start
+npm install llm-testrunner-components
+```
+### Integration
+```tsx
+import React, { useEffect } from 'react';
+import { defineCustomElements } from 'llm-testrunner-components/loader';
+function App() {
+  useEffect(() => {
+    defineCustomElements();
+  }, []);
+  return (
+    <div>
+      <h1>LLM Test Runner</h1>
+      <llm-test-runner api-key="your-gemini-api-key-here"></llm-test-runner>
+    </div>
+  );
+}
 ```
-## License
+### TypeScript Support
+```tsx
+declare global {
+  namespace JSX {
+    interface IntrinsicElements {
+      'llm-test-runner': any;
+    }
+  }
+}
+```
-MIT
+## API Reference
+### Component Props
+```typescript
+interface LLMTestRunnerProps {
+  apiKey: string; // Required: Your Gemini API key
+}
+```
+### TestCase Interface
+```typescript
+interface TestCase {
+  id: string;
+  question: string;
+  expectedKeywords: string[];
+  expectedSourceLinks: string[];
+  output?: string;
+  isRunning?: boolean;
+  error?: string;
+  evaluationResult?: EvaluationResult;
+}
+```
+### EvaluationResult Interface
+```typescript
+interface EvaluationResult {
+  testCaseId: string;
+  passed: boolean;
+  keywordMatches: KeywordMatch[];
+  sourceLinkMatches: SourceLinkMatch[];
+  timestamp?: string;
+}
+```

package/dist/cjs/{index-CCrH7f-W.js → index-CY2lQip_.js} RENAMED Viewed

@@ -1,10 +1,10 @@
 'use strict';
-const NAMESPACE = 'llm-testrunner-components';
-const BUILD = /* llm-testrunner-components */ { hydratedSelectorName: "hydrated", lazyLoad: true, updatable: true, watchCallback: false };
+const NAMESPACE = 'llm-testrunner';
+const BUILD = /* llm-testrunner */ { hydratedSelectorName: "hydrated", lazyLoad: true, propChangeCallback: false, updatable: true};
 /*
- Stencil Client Platform v4.36.1 | MIT Licensed | https://stenciljs.com
+ Stencil Client Platform v4.38.1 | MIT Licensed | https://stenciljs.com
  */
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
@@ -20,21 +20,31 @@ var reWireGetterSetter = (instance, hostRef) => {
   members.map(([memberName, [memberFlags]]) => {
     if ((memberFlags & 31 /* Prop */ || memberFlags & 32 /* State */)) {
       const ogValue = instance[memberName];
-      const ogDescriptor = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(instance), memberName);
-      Object.defineProperty(instance, memberName, {
-        get() {
-          return ogDescriptor.get.call(this);
-        },
-        set(newValue) {
-          ogDescriptor.set.call(this, newValue);
-        },
-        configurable: true,
-        enumerable: true
-      });
+      const ogDescriptor = getPropertyDescriptor(Object.getPrototypeOf(instance), memberName) || Object.getOwnPropertyDescriptor(instance, memberName);
+      if (ogDescriptor) {
+        Object.defineProperty(instance, memberName, {
+          get() {
+            return ogDescriptor.get.call(this);
+          },
+          set(newValue) {
+            ogDescriptor.set.call(this, newValue);
+          },
+          configurable: true,
+          enumerable: true
+        });
+      }
       instance[memberName] = hostRef.$instanceValues$.has(memberName) ? hostRef.$instanceValues$.get(memberName) : ogValue;
     }
   });
 };
+function getPropertyDescriptor(obj, memberName) {
+  while (obj) {
+    const desc = Object.getOwnPropertyDescriptor(obj, memberName);
+    if (desc == null ? void 0 : desc.get) return desc;
+    obj = Object.getPrototypeOf(obj);
+  }
+  return void 0;
+}
 // src/client/client-host-ref.ts
 var getHostRef = (ref) => {
@@ -44,6 +54,7 @@ var getHostRef = (ref) => {
   return void 0;
 };
 var registerInstance = (lazyInstance, hostRef) => {
+  if (!hostRef) return;
   lazyInstance.__stencil__getHostRef = () => hostRef;
   hostRef.$lazyInstance$ = lazyInstance;
   {
@@ -55,17 +66,22 @@ var registerHost = (hostElement, cmpMeta) => {
     $flags$: 0,
     $hostElement$: hostElement,
     $cmpMeta$: cmpMeta,
-    $instanceValues$: /* @__PURE__ */ new Map()
+    $instanceValues$: /* @__PURE__ */ new Map(),
+    $serializerValues$: /* @__PURE__ */ new Map()
   };
   {
     hostRef.$onReadyPromise$ = new Promise((r) => hostRef.$onReadyResolve$ = r);
     hostElement["s-p"] = [];
     hostElement["s-rc"] = [];
   }
+  {
+    hostRef.$fetchedCbList$ = [];
+  }
   const ref = hostRef;
   hostElement.__stencil__getHostRef = () => ref;
   return ref;
 };
+var isMemberInElement = (elm, memberName) => memberName in elm;
 var consoleError = (e, el) => (0, console.error)(e, el);
 // src/client/client-load-module.ts
@@ -390,6 +406,19 @@ var h = (nodeName, vnodeData, ...children) => {
     if (vnodeData.key) {
       key = vnodeData.key;
     }
+    {
+      const classData = vnodeData.className || vnodeData.class;
+      if (classData) {
+        vnodeData.class = typeof classData !== "object" ? classData : Object.keys(classData).filter((k) => classData[k]).join(" ");
+      }
+    }
+  }
+  if (typeof nodeName === "function") {
+    return nodeName(
+      vnodeData === null ? {} : vnodeData,
+      vNodeChildren,
+      vdomFnUtils
+    );
   }
   const vnode = newVNode(nodeName, null);
   vnode.$attrs$ = vnodeData;
@@ -419,6 +448,36 @@ var newVNode = (tag, text) => {
 };
 var Host = {};
 var isHost = (node) => node && node.$tag$ === Host;
+var vdomFnUtils = {
+  forEach: (children, cb) => children.map(convertToPublic).forEach(cb),
+  map: (children, cb) => children.map(convertToPublic).map(cb).map(convertToPrivate)
+};
+var convertToPublic = (node) => ({
+  vattrs: node.$attrs$,
+  vchildren: node.$children$,
+  vkey: node.$key$,
+  vname: node.$name$,
+  vtag: node.$tag$,
+  vtext: node.$text$
+});
+var convertToPrivate = (node) => {
+  if (typeof node.vtag === "function") {
+    const vnodeData = { ...node.vattrs };
+    if (node.vkey) {
+      vnodeData.key = node.vkey;
+    }
+    if (node.vname) {
+      vnodeData.name = node.vname;
+    }
+    return h(node.vtag, vnodeData, ...node.vchildren || []);
+  }
+  const vnode = newVNode(node.vtag, node.vtext);
+  vnode.$attrs$ = node.vattrs;
+  vnode.$children$ = node.vchildren;
+  vnode.$key$ = node.vkey;
+  vnode.$name$ = node.vname;
+  return vnode;
+};
 var createSupportsRuleRe = (selector) => {
   const safeSelector2 = escapeRegExpSpecialCharacters(selector);
   return new RegExp(
@@ -449,8 +508,85 @@ var setAccessor = (elm, memberName, oldValue, newValue, isSvg, flags, initialRen
   if (oldValue === newValue) {
     return;
   }
-  memberName.toLowerCase();
+  let isProp = isMemberInElement(elm, memberName);
+  let ln = memberName.toLowerCase();
+  if (memberName === "class") {
+    const classList = elm.classList;
+    const oldClasses = parseClassList(oldValue);
+    let newClasses = parseClassList(newValue);
+    {
+      classList.remove(...oldClasses.filter((c) => c && !newClasses.includes(c)));
+      classList.add(...newClasses.filter((c) => c && !oldClasses.includes(c)));
+    }
+  } else if (memberName === "key") ; else if (memberName === "ref") {
+    if (newValue) {
+      newValue(elm);
+    }
+  } else if ((!isProp ) && memberName[0] === "o" && memberName[1] === "n") {
+    if (memberName[2] === "-") {
+      memberName = memberName.slice(3);
+    } else if (isMemberInElement(win, ln)) {
+      memberName = ln.slice(2);
+    } else {
+      memberName = ln[2] + memberName.slice(3);
+    }
+    if (oldValue || newValue) {
+      const capture = memberName.endsWith(CAPTURE_EVENT_SUFFIX);
+      memberName = memberName.replace(CAPTURE_EVENT_REGEX, "");
+      if (oldValue) {
+        plt.rel(elm, memberName, oldValue, capture);
+      }
+      if (newValue) {
+        plt.ael(elm, memberName, newValue, capture);
+      }
+    }
+  } else {
+    const isComplex = isComplexType(newValue);
+    if ((isProp || isComplex && newValue !== null) && true) {
+      try {
+        if (!elm.tagName.includes("-")) {
+          const n = newValue == null ? "" : newValue;
+          if (memberName === "list") {
+            isProp = false;
+          } else if (oldValue == null || elm[memberName] != n) {
+            if (typeof elm.__lookupSetter__(memberName) === "function") {
+              elm[memberName] = n;
+            } else {
+              elm.setAttribute(memberName, n);
+            }
+          }
+        } else if (elm[memberName] !== newValue) {
+          elm[memberName] = newValue;
+        }
+      } catch (e) {
+      }
+    }
+    if (newValue == null || newValue === false) {
+      if (newValue !== false || elm.getAttribute(memberName) === "") {
+        {
+          elm.removeAttribute(memberName);
+        }
+      }
+    } else if ((!isProp || flags & 4 /* isHost */ || isSvg) && !isComplex && elm.nodeType === 1 /* ElementNode */) {
+      newValue = newValue === true ? "" : newValue;
+      {
+        elm.setAttribute(memberName, newValue);
+      }
+    }
+  }
+};
+var parseClassListRegex = /\s/;
+var parseClassList = (value) => {
+  if (typeof value === "object" && value && "baseVal" in value) {
+    value = value.baseVal;
+  }
+  if (!value || typeof value !== "string") {
+    return [];
+  }
+  return value.split(parseClassListRegex);
 };
+var CAPTURE_EVENT_SUFFIX = "Capture";
+var CAPTURE_EVENT_REGEX = new RegExp(CAPTURE_EVENT_SUFFIX + "$");
 // src/runtime/vdom/update-element.ts
 var updateElement = (oldVnode, newVnode, isSvgMode2, isInitialRender) => {
@@ -464,7 +600,9 @@ var updateElement = (oldVnode, newVnode, isSvgMode2, isInitialRender) => {
           elm,
           memberName,
           oldVnodeAttrs[memberName],
-          void 0);
+          void 0,
+          isSvgMode2,
+          newVnode.$flags$);
       }
     }
   }
@@ -473,7 +611,9 @@ var updateElement = (oldVnode, newVnode, isSvgMode2, isInitialRender) => {
       elm,
       memberName,
       oldVnodeAttrs[memberName],
-      newVnodeAttrs[memberName]);
+      newVnodeAttrs[memberName],
+      isSvgMode2,
+      newVnode.$flags$);
   }
 };
 function sortedAttrNames(attrNames) {
@@ -486,6 +626,7 @@ function sortedAttrNames(attrNames) {
   );
 }
 var hostTagName;
+var isSvgMode = false;
 var createElm = (oldParentVNode, newParentVNode, childIndex) => {
   const newVNode2 = newParentVNode.$children$[childIndex];
   let i2 = 0;
@@ -503,7 +644,7 @@ var createElm = (oldParentVNode, newParentVNode, childIndex) => {
       newVNode2.$tag$
     );
     {
-      updateElement(null, newVNode2);
+      updateElement(null, newVNode2, isSvgMode);
     }
     if (newVNode2.$children$) {
       for (i2 = 0; i2 < newVNode2.$children$.length; ++i2) {
@@ -538,6 +679,7 @@ var removeVnodes = (vnodes, startIdx, endIdx) => {
     const vnode = vnodes[index];
     if (vnode) {
       const elm = vnode.$elm$;
+      nullifyVNodeRefs(vnode);
       if (elm) {
         elm.remove();
       }
@@ -647,7 +789,7 @@ var patch = (oldVNode, newVNode2, isInitialRender = false) => {
   const text = newVNode2.$text$;
   if (text === null) {
     {
-      updateElement(oldVNode, newVNode2);
+      updateElement(oldVNode, newVNode2, isSvgMode);
     }
     if (oldChildren !== null && newChildren !== null) {
       updateChildren(elm, oldChildren, newVNode2, newChildren, isInitialRender);
@@ -666,6 +808,12 @@ var patch = (oldVNode, newVNode2, isInitialRender = false) => {
     elm.data = text;
   }
 };
+var nullifyVNodeRefs = (vNode) => {
+  {
+    vNode.$attrs$ && vNode.$attrs$.ref && vNode.$attrs$.ref(null);
+    vNode.$children$ && vNode.$children$.map(nullifyVNodeRefs);
+  }
+};
 var insertBefore = (parent, newNode, reference) => {
   {
     return parent == null ? void 0 : parent.insertBefore(newNode, reference);
@@ -733,6 +881,11 @@ var dispatchHooks = (hostRef, isInitialLoad) => {
   }
   let maybePromise;
   if (isInitialLoad) {
+    {
+      if (hostRef.$fetchedCbList$.length) {
+        hostRef.$fetchedCbList$.forEach((cb) => cb(elm));
+      }
+    }
     maybePromise = safeCall(instance, "componentWillLoad", void 0, elm);
   } else {
     maybePromise = safeCall(instance, "componentWillUpdate", void 0, elm);
@@ -889,7 +1042,7 @@ var setValue = (ref, propName, newVal, cmpMeta) => {
 var proxyComponent = (Cstr, cmpMeta, flags) => {
   var _a, _b;
   const prototype = Cstr.prototype;
-  if (cmpMeta.$members$ || BUILD.watchCallback) {
+  if (cmpMeta.$members$ || BUILD.propChangeCallback) {
     const members = Object.entries((_a = cmpMeta.$members$) != null ? _a : {});
     members.map(([memberName, [memberFlags]]) => {
       if ((memberFlags & 31 /* Prop */ || (flags & 2 /* proxyState */) && memberFlags & 32 /* State */)) {
@@ -923,8 +1076,6 @@ var proxyComponent = (Cstr, cmpMeta, flags) => {
               const currentValue = memberFlags & 32 /* State */ ? this[memberName] : ref.$hostElement$[memberName];
               if (typeof currentValue === "undefined" && ref.$instanceValues$.get(memberName)) {
                 newValue = ref.$instanceValues$.get(memberName);
-              } else if (!ref.$instanceValues$.get(memberName) && currentValue) {
-                ref.$instanceValues$.set(memberName, currentValue);
               }
               origSetter.apply(this, [
                 parsePropertyValue(
@@ -939,7 +1090,7 @@ var proxyComponent = (Cstr, cmpMeta, flags) => {
               if ((flags & 1 /* isElementConstructor */) === 0 || (cmpMeta.$members$[memberName][0] & 4096 /* Setter */) === 0) {
                 setValue(this, memberName, newValue, cmpMeta);
                 if (flags & 1 /* isElementConstructor */ && !ref.$lazyInstance$) {
-                  ref.$onReadyPromise$.then(() => {
+                  ref.$fetchedCbList$.push(() => {
                     if (cmpMeta.$members$[memberName][0] & 4096 /* Setter */ && ref.$lazyInstance$[memberName] !== ref.$instanceValues$.get(memberName)) {
                       ref.$lazyInstance$[memberName] = newValue;
                     }
@@ -960,7 +1111,9 @@ var proxyComponent = (Cstr, cmpMeta, flags) => {
               if (ref.$lazyInstance$) {
                 setterSetVal();
               } else {
-                ref.$onReadyPromise$.then(() => setterSetVal());
+                ref.$fetchedCbList$.push(() => {
+                  setterSetVal();
+                });
               }
             }
           }
@@ -973,14 +1126,15 @@ var proxyComponent = (Cstr, cmpMeta, flags) => {
         plt.jmp(() => {
           var _a2;
           const propName = attrNameToPropName.get(attrName);
+          const hostRef = getHostRef(this);
           if (this.hasOwnProperty(propName) && BUILD.lazyLoad) {
             newValue = this[propName];
             delete this[propName];
-          } else if (prototype.hasOwnProperty(propName) && typeof this[propName] === "number" && // cast type to number to avoid TS compiler issues
+          }
+          if (prototype.hasOwnProperty(propName) && typeof this[propName] === "number" && // cast type to number to avoid TS compiler issues
           this[propName] == newValue) {
             return;
           } else if (propName == null) {
-            const hostRef = getHostRef(this);
             const flags2 = hostRef == null ? void 0 : hostRef.$flags$;
             if (hostRef && flags2 && !(flags2 & 8 /* isConstructingInstance */) && flags2 & 128 /* isWatchReady */ && newValue !== oldValue) {
               const instance = hostRef.$lazyInstance$ ;
@@ -993,9 +1147,12 @@ var proxyComponent = (Cstr, cmpMeta, flags) => {
             }
             return;
           }
+          const propFlags = members.find(([m]) => m === propName);
+          if (propFlags && propFlags[1][0] & 4 /* Boolean */) {
+            newValue = newValue === null || newValue === "false" ? false : true;
+          }
           const propDesc = Object.getOwnPropertyDescriptor(prototype, propName);
-          newValue = newValue === null && typeof this[propName] === "boolean" ? false : newValue;
-          if (newValue !== this[propName] && (!propDesc.get || !!propDesc.set)) {
+          if (newValue != this[propName] && (!propDesc.get || !!propDesc.set)) {
             this[propName] = newValue;
           }
         });
@@ -1003,7 +1160,7 @@ var proxyComponent = (Cstr, cmpMeta, flags) => {
       Cstr.observedAttributes = Array.from(
         /* @__PURE__ */ new Set([
           ...Object.keys((_b = cmpMeta.$watchers$) != null ? _b : {}),
-          ...members.filter(([_, m]) => m[0] & 15 /* HasAttribute */).map(([propName, m]) => {
+          ...members.filter(([_, m]) => m[0] & 31 /* HasAttribute */).map(([propName, m]) => {
             const attrName = m[1] || propName;
             attrNameToPropName.set(attrName, propName);
             return attrName;
@@ -1105,7 +1262,7 @@ var connectedCallback = (elm) => {
       }
       if (cmpMeta.$members$) {
         Object.entries(cmpMeta.$members$).map(([memberName, [memberFlags]]) => {
-          if (memberFlags & 31 /* Prop */ && elm.hasOwnProperty(memberName)) {
+          if (memberFlags & 31 /* Prop */ && memberName in elm && elm[memberName] !== Object.prototype[memberName]) {
             const value = elm[memberName];
             delete elm[memberName];
             elm[memberName] = value;
@@ -1288,6 +1445,6 @@ exports.h = h;
 exports.promiseResolve = promiseResolve;
 exports.registerInstance = registerInstance;
 exports.setNonce = setNonce;
-//# sourceMappingURL=index-CCrH7f-W.js.map
+//# sourceMappingURL=index-CY2lQip_.js.map
-//# sourceMappingURL=index-CCrH7f-W.js.map
+//# sourceMappingURL=index-CY2lQip_.js.map