npm - @mcp-b/global - Versions diffs - 1.2.1 → 1.3.0 - Mend

@mcp-b/global 1.2.1 → 1.3.0

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 (7) hide show

package/README.md CHANGED Viewed

@@ -127,6 +127,316 @@ window.navigator.modelContext.provideContext({
 });
 ```
+## 📜 Traditional Web Standard Usage
+The Web Model Context API follows the same patterns as other browser APIs. Here's how to use it as a traditional web standard:
+### Basic Pattern (Vanilla JavaScript)
+```html
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Web Model Context API Example</title>
+  <script src="https://unpkg.com/@mcp-b/global@latest/dist/index.iife.js"></script>
+</head>
+<body>
+  <h1>Counter App</h1>
+  <p>Count: <span id="count">0</span></p>
+  <button id="increment">+</button>
+  <button id="decrement">-</button>
+  <script>
+    // State
+    let count = 0;
+    // DOM elements
+    const countEl = document.getElementById('count');
+    const incrementBtn = document.getElementById('increment');
+    const decrementBtn = document.getElementById('decrement');
+    // Update UI
+    function updateUI() {
+      countEl.textContent = count;
+    }
+    // Button handlers
+    incrementBtn.addEventListener('click', () => { count++; updateUI(); });
+    decrementBtn.addEventListener('click', () => { count--; updateUI(); });
+    // Feature detection (like navigator.geolocation)
+    if ('modelContext' in navigator) {
+      // Register tools with the Web Model Context API
+      navigator.modelContext.provideContext({
+        tools: [
+          {
+            name: 'counter_get',
+            description: 'Get the current counter value',
+            inputSchema: { type: 'object', properties: {} },
+            execute: async () => ({
+              content: [{ type: 'text', text: String(count) }]
+            })
+          },
+          {
+            name: 'counter_set',
+            description: 'Set the counter to a specific value',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                value: { type: 'number', description: 'The new counter value' }
+              },
+              required: ['value']
+            },
+            execute: async ({ value }) => {
+              count = value;
+              updateUI();
+              return {
+                content: [{ type: 'text', text: `Counter set to ${count}` }]
+              };
+            }
+          },
+          {
+            name: 'counter_increment',
+            description: 'Increment the counter by a specified amount',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                amount: { type: 'number', description: 'Amount to increment by', default: 1 }
+              }
+            },
+            execute: async ({ amount = 1 }) => {
+              count += amount;
+              updateUI();
+              return {
+                content: [{ type: 'text', text: `Counter incremented to ${count}` }]
+              };
+            }
+          }
+        ]
+      });
+      console.log('Web Model Context API: Tools registered');
+    } else {
+      console.warn('Web Model Context API not supported');
+    }
+  </script>
+</body>
+</html>
+```
+### Single Tool Registration Pattern
+Like `navigator.permissions.query()`, you can register tools one at a time:
+```javascript
+// Feature detection
+if ('modelContext' in navigator) {
+  // Register a single tool (returns an object with unregister method)
+  const registration = navigator.modelContext.registerTool({
+    name: 'get_page_info',
+    description: 'Get information about the current page',
+    inputSchema: { type: 'object', properties: {} },
+    execute: async () => ({
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          title: document.title,
+          url: location.href,
+          timestamp: new Date().toISOString()
+        }, null, 2)
+      }]
+    })
+  });
+  // Later, unregister if needed (e.g., when component unmounts)
+  // registration.unregister();
+}
+```
+### Event-Driven Pattern
+Similar to other DOM events, you can listen for tool calls:
+```javascript
+if ('modelContext' in navigator) {
+  // Listen for tool calls (like 'message' or 'click' events)
+  navigator.modelContext.addEventListener('toolcall', (event) => {
+    console.log(`Tool "${event.name}" called with:`, event.arguments);
+    // Optionally intercept and provide custom response
+    if (event.name === 'custom_handler') {
+      event.preventDefault();
+      event.respondWith({
+        content: [{ type: 'text', text: 'Custom response' }]
+      });
+    }
+  });
+}
+```
+### Complete Standalone Example
+Save this as `index.html` and open in a browser:
+```html
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>WebMCP Demo</title>
+  <script src="https://unpkg.com/@mcp-b/global@latest/dist/index.iife.js"></script>
+  <style>
+    body { font-family: system-ui; max-width: 600px; margin: 2rem auto; padding: 0 1rem; }
+    .card { border: 1px solid #ddd; border-radius: 8px; padding: 1rem; margin: 1rem 0; }
+    button { padding: 0.5rem 1rem; margin: 0.25rem; cursor: pointer; }
+    #log { font-family: monospace; font-size: 0.85rem; background: #f5f5f5; padding: 1rem; max-height: 200px; overflow-y: auto; }
+  </style>
+</head>
+<body>
+  <h1>🤖 WebMCP Demo</h1>
+  <div class="card">
+    <h2>Notes App</h2>
+    <input type="text" id="noteInput" placeholder="Enter a note..." style="width: 100%; padding: 0.5rem; box-sizing: border-box;">
+    <button id="addNote">Add Note</button>
+    <ul id="notesList"></ul>
+  </div>
+  <div class="card">
+    <h3>Tool Call Log</h3>
+    <div id="log">Waiting for AI tool calls...</div>
+  </div>
+  <script>
+    // Application state
+    const notes = [];
+    // DOM elements
+    const noteInput = document.getElementById('noteInput');
+    const addNoteBtn = document.getElementById('addNote');
+    const notesList = document.getElementById('notesList');
+    const logEl = document.getElementById('log');
+    // UI functions
+    function renderNotes() {
+      notesList.innerHTML = notes.map((note, i) =>
+        `<li>${note} <button onclick="deleteNote(${i})">×</button></li>`
+      ).join('');
+    }
+    function log(message) {
+      const time = new Date().toLocaleTimeString();
+      logEl.innerHTML = `[${time}] ${message}\n` + logEl.innerHTML;
+    }
+    // User interactions
+    addNoteBtn.addEventListener('click', () => {
+      if (noteInput.value.trim()) {
+        notes.push(noteInput.value.trim());
+        noteInput.value = '';
+        renderNotes();
+      }
+    });
+    window.deleteNote = (index) => {
+      notes.splice(index, 1);
+      renderNotes();
+    };
+    // Web Model Context API - Register tools for AI agents
+    if ('modelContext' in navigator) {
+      navigator.modelContext.provideContext({
+        tools: [
+          {
+            name: 'notes_list',
+            description: 'Get all notes',
+            inputSchema: { type: 'object', properties: {} },
+            execute: async () => {
+              log('🔧 notes_list called');
+              return {
+                content: [{
+                  type: 'text',
+                  text: notes.length ? notes.map((n, i) => `${i + 1}. ${n}`).join('\n') : 'No notes yet'
+                }]
+              };
+            }
+          },
+          {
+            name: 'notes_add',
+            description: 'Add a new note',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                text: { type: 'string', description: 'The note text' }
+              },
+              required: ['text']
+            },
+            execute: async ({ text }) => {
+              log(`🔧 notes_add called: "${text}"`);
+              notes.push(text);
+              renderNotes();
+              return {
+                content: [{ type: 'text', text: `Added note: "${text}"` }]
+              };
+            }
+          },
+          {
+            name: 'notes_delete',
+            description: 'Delete a note by index (1-based)',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                index: { type: 'number', description: 'Note index (1-based)' }
+              },
+              required: ['index']
+            },
+            execute: async ({ index }) => {
+              log(`🔧 notes_delete called: index ${index}`);
+              if (index < 1 || index > notes.length) {
+                return { content: [{ type: 'text', text: 'Invalid index' }], isError: true };
+              }
+              const deleted = notes.splice(index - 1, 1)[0];
+              renderNotes();
+              return {
+                content: [{ type: 'text', text: `Deleted: "${deleted}"` }]
+              };
+            }
+          },
+          {
+            name: 'notes_clear',
+            description: 'Delete all notes',
+            inputSchema: { type: 'object', properties: {} },
+            execute: async () => {
+              log('🔧 notes_clear called');
+              const count = notes.length;
+              notes.length = 0;
+              renderNotes();
+              return {
+                content: [{ type: 'text', text: `Cleared ${count} notes` }]
+              };
+            }
+          }
+        ]
+      });
+      log('✅ Web Model Context API initialized');
+      log('📋 Tools: notes_list, notes_add, notes_delete, notes_clear');
+    } else {
+      log('❌ Web Model Context API not available');
+    }
+  </script>
+</body>
+</html>
+```
+This example demonstrates:
+- **Feature detection** using `'modelContext' in navigator`
+- **Tool registration** via `navigator.modelContext.provideContext()`
+- **Standard input schemas** following JSON Schema specification
+- **Async execute functions** returning MCP-compatible responses
+- **Real-time UI updates** when AI agents call tools
 ## ⚙️ Configuration
 The polyfill exposes `initializeWebModelContext(options?: WebModelContextInitOptions)` to let you control transport behaviour. When you import `@mcp-b/global` as a module it auto-initializes by default, but you can customise or defer initialization:
@@ -1011,6 +1321,43 @@ if ("modelContext" in navigator) {
 ## 🐛 Debugging
+### Enable Debug Logging
+The @mcp-b/global library includes a lightweight logging system that can be enabled in the browser console. By default, the console is kept clean (only errors and warnings are shown). You can enable detailed debug logging when troubleshooting:
+```javascript
+// Enable all debug logging
+localStorage.setItem('WEBMCP_DEBUG', '*');
+// Enable specific namespaces
+localStorage.setItem('WEBMCP_DEBUG', 'WebModelContext');
+localStorage.setItem('WEBMCP_DEBUG', 'NativeAdapter,MCPBridge');
+// Refresh the page to apply changes
+location.reload();
+```
+To disable debug logging:
+```javascript
+localStorage.removeItem('WEBMCP_DEBUG');
+location.reload();
+```
+**Available Namespaces:**
+- `WebModelContext` - Main polyfill implementation
+- `NativeAdapter` - Native Chromium API adapter
+- `MCPBridge` - MCP server and transport setup
+- `ModelContextTesting` - Testing API operations
+**Log Levels:**
+- **Error** (always shown): Critical failures and exceptions
+- **Warn** (always shown): Compatibility warnings and potential issues
+- **Info** (debug mode only): Initialization and setup progress
+- **Debug** (debug mode only): Detailed operation traces
+### Access Internal Bridge
 In development mode, access the internal bridge:
 ```javascript
@@ -1248,6 +1595,49 @@ test('todo tool creates correct response', async () => {
 The polyfill automatically detects and defers to the native implementation when available, ensuring forward compatibility as browsers adopt this standard.
+## Zod Version Compatibility
+This package supports **Zod 3.25+** and **Zod 4.x**. Simply use the standard import:
+```typescript
+import { z } from 'zod';
+window.navigator.modelContext.provideContext({
+  tools: [{
+    name: "my-tool",
+    inputSchema: {
+      name: z.string().describe('User name'),
+      age: z.number().min(0)
+    },
+    async execute({ name, age }) {
+      return { content: [{ type: "text", text: `Hello, ${name}!` }] };
+    }
+  }]
+});
+```
+### JSON Schema Alternative
+JSON Schema is also supported if you prefer not to use Zod:
+```javascript
+window.navigator.modelContext.provideContext({
+  tools: [{
+    name: "my-tool",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string" }
+      },
+      required: ["name"]
+    },
+    async execute({ name }) {
+      return { content: [{ type: "text", text: `Hello, ${name}!` }] };
+    }
+  }]
+});
+```
 ## 📦 What's Included
 - **Web Model Context API** - Standard `window.navigator.modelContext` interface

package/dist/index.d.ts CHANGED Viewed

@@ -65,6 +65,146 @@ type ZodSchemaObject = Record<string, z.ZodTypeAny>;
  * @see {@link CallToolResult}
  */
 type ToolResponse = CallToolResult;
+/**
+ * Metadata for tools that trigger page navigation.
+ *
+ * When a tool needs to navigate the page (e.g., to a different URL), it must include
+ * this metadata in its response to signal the navigation intent to the client. This
+ * allows the client to distinguish between successful navigation and interrupted execution.
+ *
+ * **CRITICAL PATTERN**: Tools MUST return their response BEFORE triggering navigation.
+ * Use `setTimeout()` with a minimum 100ms delay to ensure the response is transmitted
+ * via `postMessage` and received by the client before the page unloads.
+ *
+ * **Why the pattern is necessary**: During page navigation, the JavaScript context
+ * is destroyed. If navigation occurs before the response is sent, the client will
+ * never receive the tool's result and cannot distinguish success from failure.
+ *
+ * @example Correct pattern - Response before navigation
+ * ```typescript
+ * navigator.modelContext.registerTool({
+ *   name: 'navigate_to_docs',
+ *   description: 'Navigate to documentation page',
+ *   inputSchema: { section: z.string() },
+ *   async execute(args) {
+ *     const url = `https://docs.example.com/${args.section}`;
+ *
+ *     // 1. Prepare response with navigation metadata
+ *     const response = {
+ *       content: [{ type: 'text', text: `Navigating to ${url}` }],
+ *       metadata: {
+ *         willNavigate: true,
+ *         navigationUrl: url,
+ *         navigationTiming: 'immediate',
+ *       },
+ *     };
+ *
+ *     // 2. Schedule navigation AFTER response is returned (100ms minimum)
+ *     setTimeout(() => {
+ *       window.location.href = url;
+ *     }, 100);
+ *
+ *     // 3. Return response BEFORE navigation occurs
+ *     return response;
+ *   },
+ * });
+ * ```
+ *
+ * @example Anti-pattern - Navigation before response (DO NOT DO THIS)
+ * ```typescript
+ * // ❌ WRONG - Response will be lost during navigation
+ * async execute(args) {
+ *   window.location.href = computeUrl(args); // Navigation happens first
+ *   return { content: [...] }; // This response is never received!
+ * }
+ * ```
+ *
+ * @see {@link InterruptionMetadata} for metadata added when navigation interrupts execution
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage} for postMessage timing
+ */
+interface NavigationMetadata {
+  /**
+   * Indicates this tool will trigger page navigation.
+   * This flag signals to the client that the tool succeeded and navigation is expected.
+   */
+  willNavigate: true;
+  /**
+   * The URL the page will navigate to (if known).
+   * Helps clients track navigation targets.
+   */
+  navigationUrl?: string;
+  /**
+   * When navigation will occur relative to the response.
+   * - 'immediate': Navigation scheduled immediately after return (within ~100ms)
+   * - 'delayed': Navigation will occur after some delay (see navigationDelayMs)
+   * @default 'immediate'
+   */
+  navigationTiming?: 'immediate' | 'delayed';
+  /**
+   * Expected delay in milliseconds before navigation (if timing='delayed').
+   * Only meaningful when navigationTiming is 'delayed'.
+   */
+  navigationDelayMs?: number;
+}
+/**
+ * Metadata indicating a tool call was interrupted by page navigation.
+ *
+ * This metadata is automatically added by the transport layer (`TabServerTransport`)
+ * when a page navigation occurs while a tool is executing. The transport layer's
+ * `beforeunload` event handler detects the navigation and sends an interrupted
+ * response for any pending tool calls.
+ *
+ * **When this occurs**:
+ * - User clicks browser back/forward buttons during tool execution
+ * - User manually navigates to a different URL
+ * - Tool triggers immediate navigation without following the response-first pattern
+ * - Page is reloaded or closed during tool execution
+ *
+ * **How to distinguish from successful navigation**:
+ * - Tool succeeded and navigated: Response includes `NavigationMetadata` with `willNavigate: true`
+ * - Tool was interrupted: Response includes `InterruptionMetadata` with `navigationInterrupted: true`
+ *
+ * **Client handling**:
+ * ```typescript
+ * const response = await client.callTool('my_tool', args);
+ *
+ * if (response.metadata?.willNavigate) {
+ *   // Tool succeeded and will navigate - expected behavior
+ *   console.log('Tool navigated successfully');
+ * } else if (response.metadata?.navigationInterrupted) {
+ *   // Tool was interrupted - may not have completed
+ *   console.warn('Tool execution interrupted by navigation');
+ * } else {
+ *   // Normal tool response - no navigation
+ *   console.log('Tool completed normally');
+ * }
+ * ```
+ *
+ * @see {@link NavigationMetadata} for metadata indicating intentional navigation
+ * @see {@link TabServerTransport._handleBeforeUnload} for the implementation
+ * @internal This metadata is added automatically by the transport layer
+ */
+interface InterruptionMetadata {
+  /**
+   * Indicates the tool execution was interrupted by page navigation.
+   * When `true`, the tool may not have completed its operation successfully.
+   */
+  navigationInterrupted: true;
+  /**
+   * The original JSON-RPC method that was interrupted.
+   * Typically `'tools/call'` for tool invocations, but could be other MCP methods.
+   *
+   * @example 'tools/call' | 'resources/read' | 'prompts/get'
+   */
+  originalMethod: string;
+  /**
+   * Unix timestamp (milliseconds since epoch) when the interruption was detected.
+   * Useful for logging, debugging, and understanding the timeline of events.
+   *
+   * @example 1704067200000 (January 1, 2024, 00:00:00 UTC)
+   */
+  timestamp: number;
+}
 /**
  * Transport configuration for initializing the Web Model Context polyfill.
  *
@@ -712,9 +852,15 @@ interface ModelContext {
 interface InternalModelContext extends ModelContext {
   /**
    * Execute a tool (internal use only by MCP bridge)
+   * @param toolName - Name of the tool to execute
+   * @param args - Arguments to pass to the tool
+   * @param options - Optional execution options
+   * @param options.skipValidation - Skip input validation (used when SDK already validated)
    * @internal
    */
-  executeTool(toolName: string, args: Record<string, unknown>): Promise<ToolResponse>;
+  executeTool(toolName: string, args: Record<string, unknown>, options?: {
+    skipValidation?: boolean;
+  }): Promise<ToolResponse>;
   /**
    * Read a resource by URI (internal use only by MCP bridge)
    * @internal
@@ -907,15 +1053,50 @@ declare function initializeWebModelContext(options?: WebModelContextInitOptions)
  */
 declare function cleanupWebModelContext(): void;
 //#endregion
-//#region src/validation.d.ts
+//#region src/logger.d.ts
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
 /**
- * Convert Zod schema object to JSON Schema
- * Uses zod-to-json-schema package for comprehensive conversion
+ * Logger interface with standard log levels
  *
- * @param schema - Record of Zod type definitions (e.g., { name: z.string(), age: z.number() })
- * @returns JSON Schema object compatible with MCP InputSchema
+ * All methods accept the same argument patterns as their console.* equivalents,
+ * supporting format strings, object inspection, and multiple arguments.
  */
-declare function zodToJsonSchema(schema: Record<string, z.ZodTypeAny>): InputSchema;
+interface Logger {
+  /** Debug-level logging (disabled by default, enable via WEBMCP_DEBUG) */
+  debug(message?: unknown, ...optionalParams: unknown[]): void;
+  /** Info-level logging (disabled by default, enable via WEBMCP_DEBUG) */
+  info(message?: unknown, ...optionalParams: unknown[]): void;
+  /** Warning-level logging (enabled by default, not gated by WEBMCP_DEBUG) */
+  warn(message?: unknown, ...optionalParams: unknown[]): void;
+  /** Error-level logging (enabled by default, not gated by WEBMCP_DEBUG) */
+  error(message?: unknown, ...optionalParams: unknown[]): void;
+}
+/**
+ * Create a namespaced logger
+ *
+ * Uses .bind() to prepend namespace prefixes to console methods without manual
+ * string concatenation. Debug enablement is determined at logger creation time
+ * for performance - changes to localStorage after creation won't affect existing
+ * loggers. Refresh the page to apply new WEBMCP_DEBUG settings.
+ *
+ * @param namespace - Namespace for the logger (e.g., 'WebModelContext', 'NativeAdapter')
+ * @returns Logger instance with debug, info, warn, error methods
+ *
+ * @example
+ * ```typescript
+ * const logger = createLogger('WebModelContext');
+ * logger.debug('Tool registered:', toolName); // Only shown if WEBMCP_DEBUG includes 'WebModelContext'
+ * logger.error('Execution failed:', error); // Always enabled
+ * ```
+ */
+declare function createLogger(namespace: string): Logger;
+//#endregion
+//#region src/validation.d.ts
+declare function zodToJsonSchema(schema: ZodSchemaObject): InputSchema;
 //#endregion
-export { type CallToolResult, type CreateMessageRequest, type CreateMessageResult, type ElicitRequest, type ElicitResult, ElicitationFormParams, ElicitationParams, ElicitationResult, ElicitationUrlParams, InputSchema, InternalModelContext, MCPBridge, ModelContext, ModelContextInput, ModelContextTesting, type Prompt, PromptDescriptor, type PromptMessage, RegistrationHandle, type Resource, type ResourceContents, ResourceDescriptor, type ResourceTemplate, ResourceTemplateInfo, SamplingRequestParams, SamplingResult, type ToolAnnotations, ToolCallEvent, ToolDescriptor, ToolInfo, ToolListItem, ToolResponse, TransportConfiguration, ValidatedPromptDescriptor, ValidatedResourceDescriptor, ValidatedToolDescriptor, WebModelContextInitOptions, ZodSchemaObject, cleanupWebModelContext, initializeWebModelContext, zodToJsonSchema };
+export { type CallToolResult, type CreateMessageRequest, type CreateMessageResult, type ElicitRequest, type ElicitResult, ElicitationFormParams, ElicitationParams, ElicitationResult, ElicitationUrlParams, InputSchema, InternalModelContext, InterruptionMetadata, MCPBridge, ModelContext, ModelContextInput, ModelContextTesting, NavigationMetadata, type Prompt, PromptDescriptor, type PromptMessage, RegistrationHandle, type Resource, type ResourceContents, ResourceDescriptor, type ResourceTemplate, ResourceTemplateInfo, SamplingRequestParams, SamplingResult, type ToolAnnotations, ToolCallEvent, ToolDescriptor, ToolInfo, ToolListItem, ToolResponse, TransportConfiguration, ValidatedPromptDescriptor, ValidatedResourceDescriptor, ValidatedToolDescriptor, WebModelContextInitOptions, ZodSchemaObject, cleanupWebModelContext, createLogger, initializeWebModelContext, zodToJsonSchema };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"index.d.ts","names":[],"sources":["../src/types.ts","../src/global.ts","../src/validation.ts"],"sourcesContent":[],"mappings":"~~;;;;;;AA2eA~~;;;;;;;;;;;;;;AAoCA~~;;;;;;;AAkBiB~~,~~UAjbA~~,WAAA,~~CAibY~~;~~EAMd~~;~~EAEE~~,IAAA,EAAA,MAAA;~~EAED~~;~~EAAe~~,UAAA,CAAA,~~EAvbhB~~,~~MAubgB~~,CAAA,MAAA,EAAA;~~IAOd~~;~~IAeA~~,IAAA,EAAA,MAAA;~~IAaA~~;~~IAOT~~,WAAA,CAAA,EAAA,~~MAAA~~;~~IALI~~;~~IAkBI~~,CAAA,GAAA,EAAA,MAAA,CAAA,EAAA,OAAA;~~EASH~~,CAAA,CAAA;~~EAAM~~;~~EAOF~~,QAAA,CAAA,EAAA,~~MAAc~~,EAAA;~~EAcd~~;~~EA+BA~~,CAAA,GAAA,EAAA,MAAA,CAAA,EAAA,~~OAAA~~;~~AAejB~~;AAKA;AAeA;;;;;AAuBA;;;;;AAqBA~~;;;;;AAiB4C~~,~~KA1mBhC~~,eAAA,GAAkB,~~MA0mBc~~,CAAA,MAAA,~~EA1mBC~~,CAAA,CAAE,~~UA0mBH~~,CAAA;;;;;;~~AA0FI~~,~~KA/qBpC~~,YAAA,GAAe,~~cA+qBqB;;;;;;;;;;;;~~AA+~~DhD~~;;;;;;;;;;;~~AAyBA~~;~~AAEa~~,~~UA5uBI,sBAAA,CA4uBJ~~;~~EAEI~~;;;;~~EAIJ~~,~~MAAA~~,~~CAAA,~~EAAA,~~GAAA,GA7uBI,SA6uBJ~~;~~EAEU;;;;;EAiBN~~,~~SAAA~~,~~CAAA,EAzvBH,OAyvBW,CAzvBH,yBAyvBG,CAAA,GAAA,KAAA;EAqBR~~;;;;;~~EA0CiC~~,~~YAAA~~,~~CAAA~~,~~EAjzBjC,OAizBiC,CAjzBzB,2BAizByB,CAAA,GAAA,KAAA;;;;AA0BjD;;;;;;;;;;;UA3zBgB,~~0BAAA~~;EC9LG;;;EAKqC,SAAA,CAAA,ED6L3C,sBC7L2C;EAAA;AA4mEzD;AAyHA~~;;;;~~ACvuEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UFqPiB~~,oCACM,kBAAkB,6CACjB,kBAAkB;;;;;;;;;;;;;;;;eAmB3B,cAAc;;;;;;iBAOZ,cAAc;;;;gBAKf;;;;;;;kBASN,qBAAqB,wBACvB,0BACA,CAAA,CAAE,MAAM,CAAA,CAAE,UAAU,mBACrB,QAAQ;;;;;;;;UASE,uBAAA;;;eAGF;iBACE;gBACD;kBACE,4BAA4B,QAAQ;;kBAGpC,CAAA,CAAE;;oBAEA,CAAA,CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAwCL,kBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;cA8BH,cAAc,2BAA2B;cAAoB;;;;;;;UAO1D,2BAAA;;;;;cAKH,cAAc,2BAA2B;cAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAoD1D,qCAAqC,kBAAkB;;;;;;;;;;;;;;;eAiBzD,cAAc;;;;;;;cASnB,oBAAoB,wBACtB,0BACA,CAAA,CAAE,MAAM,CAAA,CAAE,UAAU,kBACrB;cAAoB;;;;;;;UAOV,yBAAA;;;cAGH;cACA,4BAA4B;cAAoB;;;iBAG7C,CAAA,CAAE;;;;;;UAWF,YAAA;;;;;;eAMF;;iBAEE;;gBAED;;;;;;UAOC,oBAAA;;;;;;;;;;;;;;UAeA,kBAAA;;;;;;;;UAaA,qBAAA;;YAEL;;;;;;;;;QAKJ;;;;;;;;;;;;;;;;;;;YAaQ;;;;;;;;;;aASH;;;;;;UAOI,cAAA;;;;;;;;;;;;;;;;;;;;UAcA,qBAAA;;;;;;;;gBAQD;;;;;;;;;aAWD;;;;;;;;;;UAYE,oBAAA;;;;;;;;;;;;;;KAeL,iBAAA,GAAoB,wBAAwB;;;;UAKvC,iBAAA;;;;YAIL;;;;;;UAWK,iBAAA;;;;;UAKP;;;;;cAMI;;;;;YAMF;;;;;UAMK,aAAA,SAAsB;;;;;;;;aAS1B;;;;0BAKa;;;;;;UAOT,YAAA;;;;;;0BAMS;;;;;;oCAUD,kBAAkB,6CACjB,kBAAkB,6BAClC,eAAe,cAAc,iBAAiB;;;;;;;;;;eAYzC;;;;;6BAQc,qBAAqB;;;;;;;;;mBAW/B;;;;;2BAMQ;;;;;;qCASU,kBAAkB,+BAC3C,iBAAiB,eACxB;;;;;;;;;iBAWY;;;;;;;;;;;;;;;;;;;;;;;;wBA8BO,wBAAwB,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;sBA4BlC,oBAAoB,QAAQ;;;;uDAO5B,yBAAyB,mCACvB;;;;0DAQF,yBAAyB,mCACvB;;;;uBAMD;;;;;;;UAYN,oBAAA,SAA6B~~;;;;;sCAKR~~,~~0BAA0B,~~QAAQ;;;;;~~6BAM3C~~;cAAoB;;;;;;iCAMhB,0BAA0B;cAAoB;;;;;;;;UAQ9D,SAAA;;aAEJ;;iBAEI;;SAER,YAAY;;aAER,YAAY;;WAEd,YAAY;;gBAEP;;wBAEQ;;;;;;;;UAaP,QAAA;;;;;;;;;;;;;;;;;;;;UAqBA,mBAAA;;;;;;;wDAOuC;;;;;eAMzC;;;;;;;;;;kBAYG;;eAEH;;;;;;;;;;;;;kDAemC;;;;;;;;;;;;;;;;wBAmB1B,WAAW;;;;;;;;;;;;;kBAejB;;;;;;;;;;;;0BAaQ;;;;;;kBAOR;;;;;;;;+~~BChhCa~~;;~~AD+D~~/B;AAqCA;AAqBA;~~AA6BA~~;;;;;;;AAmCA;AA0DA~~;;;;;;;;;;AA0CU,iBC~~+~~0DM~~,yBAAA,~~CD/0DN~~,OAAA,CAAA,~~EC+0D0C~~,~~0BD/0D1C~~,CAAA,EAAA,IAAA~~;;;;;;;;;AAYV;;;;AAMkB~~,~~iBCs7DF~~,sBAAA,CAAA,~~CDt7DE~~,EAAA,IAAA~~;;;;;;AAtHlB~~;~~AA0DA;;;AAEwB~~,~~iBEvPR~~,~~eAAA~~,~~CFuPQ~~,~~MAAA~~,~~EEvPgB~~,~~MFuPhB~~,CAAA,~~MAAA~~,~~EEvP+B~~,CAAA,~~CAAE~~,~~UFuPjC~~,CAAA,CAAA,~~EEvP+C~~,~~WFuP/C~~"}
1	+ {"version":3,"file":"index.d.ts","names":[],"sources":["../src/types.ts","../src/global.ts","../src/logger.ts","../src/validation.ts"],"sourcesContent":[],"mappings":"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"}