@rnsk/toolkits 0.0.7 → 0.0.8

package/dist/toolkits/google-tasks/tools/list-task-lists.js

@@ -0,0 +1,30 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { tasksApiRequest } from './utils.js';
+export const listTaskLists = tool({
+    description: 'Lists all task lists owned by the authenticated user. Use to discover available task lists before reading or managing tasks.',
+    inputSchema: z.object({
+        googleTasksToken: z.string().describe('The Google Tasks access token'),
+        maxResults: z.number().optional().describe('Maximum number of task lists to return (max 100)'),
+        pageToken: z.string().optional().describe('Token for fetching the next page of results'),
+    }),
+    execute: async ({ googleTasksToken, maxResults, pageToken }) => {
+        try {
+            const result = await tasksApiRequest(googleTasksToken, '/users/@me/lists', {
+                searchParams: { maxResults, pageToken },
+            });
+            if (!result.ok) {
+                return { error: 'Failed to list task lists', details: result.error };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error listing task lists',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=list-task-lists.js.map

package/dist/toolkits/google-tasks/tools/list-tasks.d.ts

@@ -0,0 +1,15 @@
+export declare const listTasks: import("ai").Tool<{
+    googleTasksToken: string;
+    taskListId: string;
+    maxResults?: number | undefined;
+    pageToken?: string | undefined;
+    showCompleted?: boolean | undefined;
+    showDeleted?: boolean | undefined;
+    showHidden?: boolean | undefined;
+    updatedMin?: string | undefined;
+    dueMin?: string | undefined;
+    dueMax?: string | undefined;
+    completedMin?: string | undefined;
+    completedMax?: string | undefined;
+}, any>;
+//# sourceMappingURL=list-tasks.d.ts.map

package/dist/toolkits/google-tasks/tools/list-tasks.js

@@ -0,0 +1,50 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { tasksApiRequest } from './utils.js';
+export const listTasks = tool({
+    description: 'Lists tasks in a task list with optional filters. Use to view open tasks, completed tasks, or tasks due within a range. Defaults to hiding completed and deleted tasks.',
+    inputSchema: z.object({
+        googleTasksToken: z.string().describe('The Google Tasks access token'),
+        taskListId: z.string().describe('The ID of the task list to list tasks from'),
+        showCompleted: z.boolean().optional().describe('Include completed tasks (default false)'),
+        showDeleted: z.boolean().optional().describe('Include deleted tasks (default false)'),
+        showHidden: z.boolean().optional().describe('Include hidden tasks (default false)'),
+        maxResults: z.number().optional().describe('Maximum number of tasks to return (max 100)'),
+        pageToken: z.string().optional().describe('Token for fetching the next page of results'),
+        updatedMin: z.string().optional().describe('Only return tasks updated after this RFC 3339 timestamp'),
+        dueMin: z.string().optional().describe('Only return tasks due after this RFC 3339 timestamp'),
+        dueMax: z.string().optional().describe('Only return tasks due before this RFC 3339 timestamp'),
+        completedMin: z.string().optional().describe('Only return tasks completed after this RFC 3339 timestamp (requires showCompleted true)'),
+        completedMax: z.string().optional().describe('Only return tasks completed before this RFC 3339 timestamp (requires showCompleted true)'),
+    }),
+    execute: async ({ googleTasksToken, taskListId, showCompleted, showDeleted, showHidden, maxResults, pageToken, updatedMin, dueMin, dueMax, completedMin, completedMax, }) => {
+        try {
+            const result = await tasksApiRequest(googleTasksToken, `/lists/${taskListId}/tasks`, {
+                searchParams: {
+                    showCompleted,
+                    showDeleted,
+                    showHidden,
+                    maxResults,
+                    pageToken,
+                    updatedMin,
+                    dueMin,
+                    dueMax,
+                    completedMin,
+                    completedMax,
+                },
+            });
+            if (!result.ok) {
+                return { error: 'Failed to list tasks', details: result.error };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error listing tasks',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=list-tasks.js.map

package/dist/toolkits/google-tasks/tools/move-task.d.ts

@@ -0,0 +1,9 @@
+export declare const moveTask: import("ai").Tool<{
+    googleTasksToken: string;
+    taskListId: string;
+    taskId: string;
+    parent?: string | undefined;
+    previous?: string | undefined;
+    destinationTaskListId?: string | undefined;
+}, any>;
+//# sourceMappingURL=move-task.d.ts.map

package/dist/toolkits/google-tasks/tools/move-task.js

@@ -0,0 +1,37 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { tasksApiRequest } from './utils.js';
+export const moveTask = tool({
+    description: 'Moves a task to a new position, optionally under a different parent or to a different task list. Use to reorder tasks, convert a task into a subtask, or move across lists (set destinationTaskListId).',
+    inputSchema: z.object({
+        googleTasksToken: z.string().describe('The Google Tasks access token'),
+        taskListId: z.string().describe('The ID of the task list containing the task'),
+        taskId: z.string().describe('The ID of the task to move'),
+        parent: z.string().optional().describe('New parent task ID to nest under (omit for top level)'),
+        previous: z.string().optional().describe('Sibling task ID to place this task after'),
+        destinationTaskListId: z
+            .string()
+            .optional()
+            .describe('Destination task list ID to move across lists (omit to reorder within the same list)'),
+    }),
+    execute: async ({ googleTasksToken, taskListId, taskId, parent, previous, destinationTaskListId }) => {
+        try {
+            const result = await tasksApiRequest(googleTasksToken, `/lists/${taskListId}/tasks/${taskId}/move`, {
+                method: 'POST',
+                searchParams: { parent, previous, destinationTasklist: destinationTaskListId },
+            });
+            if (!result.ok) {
+                return { error: 'Failed to move task', details: result.error };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error moving task',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=move-task.js.map

package/dist/toolkits/google-tasks/tools/update-task-full.d.ts

@@ -0,0 +1,14 @@
+export declare const updateTaskFull: import("ai").Tool<{
+    title: string;
+    id: string;
+    googleTasksToken: string;
+    taskListId: string;
+    taskId: string;
+    status?: "completed" | "needsAction" | undefined;
+    completed?: string | undefined;
+    deleted?: boolean | undefined;
+    notes?: string | undefined;
+    due?: string | undefined;
+    etag?: string | undefined;
+}, any>;
+//# sourceMappingURL=update-task-full.d.ts.map

package/dist/toolkits/google-tasks/tools/update-task-full.js

@@ -0,0 +1,55 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { tasksApiRequest } from './utils.js';
+export const updateTaskFull = tool({
+    description: 'Fully replaces a task via PUT. Use when you need to rewrite the entire task resource, not just patch fields. Requires id (must match taskId) and title; unlike PATCH, omitted optional fields are cleared to defaults.',
+    inputSchema: z.object({
+        googleTasksToken: z.string().describe('The Google Tasks access token'),
+        taskListId: z.string().describe('The ID of the task list containing the task'),
+        taskId: z.string().describe('The ID of the task to fully replace'),
+        id: z.string().describe('Task identifier for the request body (REQUIRED, must match taskId)'),
+        title: z.string().min(1).max(1024).describe('Title of the task (REQUIRED)'),
+        notes: z.string().max(8192).optional().describe('Notes for the task (plain text)'),
+        due: z.string().optional().describe('Due date in RFC 3339 format, e.g. 2026-09-20T00:00:00Z'),
+        completed: z.string().optional().describe('Completion timestamp in RFC 3339 format (only with status completed)'),
+        status: z.enum(['needsAction', 'completed']).optional().describe('Task status'),
+        deleted: z.boolean().optional().describe('Whether the task is marked deleted'),
+        etag: z.string().optional().describe('ETag for optimistic concurrency control'),
+    }),
+    execute: async ({ googleTasksToken, taskListId, taskId, id, title, notes, due, completed, status, deleted, etag }) => {
+        try {
+            if (id !== taskId) {
+                return { error: `Body id '${id}' must match taskId '${taskId}' for full replacement` };
+            }
+            const body = { id, title };
+            if (notes !== undefined)
+                body.notes = notes;
+            if (due !== undefined)
+                body.due = due;
+            if (completed !== undefined)
+                body.completed = completed;
+            if (status !== undefined)
+                body.status = status;
+            if (deleted !== undefined)
+                body.deleted = deleted;
+            if (etag !== undefined)
+                body.etag = etag;
+            const result = await tasksApiRequest(googleTasksToken, `/lists/${taskListId}/tasks/${taskId}`, {
+                method: 'PUT',
+                body,
+            });
+            if (!result.ok) {
+                return { error: 'Failed to fully update task', details: result.error };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error fully updating task',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=update-task-full.js.map

package/dist/toolkits/google-tasks/tools/update-task-list.d.ts

@@ -0,0 +1,6 @@
+export declare const updateTaskList: import("ai").Tool<{
+    title: string;
+    googleTasksToken: string;
+    taskListId: string;
+}, any>;
+//# sourceMappingURL=update-task-list.d.ts.map

package/dist/toolkits/google-tasks/tools/update-task-list.js

@@ -0,0 +1,31 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { tasksApiRequest } from './utils.js';
+export const updateTaskList = tool({
+    description: 'Renames an existing task list. Use PATCH semantics — only the title is updated.',
+    inputSchema: z.object({
+        googleTasksToken: z.string().describe('The Google Tasks access token'),
+        taskListId: z.string().describe('The ID of the task list to update'),
+        title: z.string().describe('New title for the task list'),
+    }),
+    execute: async ({ googleTasksToken, taskListId, title }) => {
+        try {
+            const result = await tasksApiRequest(googleTasksToken, `/users/@me/lists/${taskListId}`, {
+                method: 'PATCH',
+                body: { title },
+            });
+            if (!result.ok) {
+                return { error: 'Failed to update task list', details: result.error };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error updating task list',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=update-task-list.js.map

package/dist/toolkits/google-tasks/tools/update-task.d.ts

@@ -0,0 +1,11 @@
+export declare const updateTask: import("ai").Tool<{
+    googleTasksToken: string;
+    taskListId: string;
+    taskId: string;
+    status?: "completed" | "needsAction" | undefined;
+    title?: string | undefined;
+    completed?: string | undefined;
+    notes?: string | undefined;
+    due?: string | undefined;
+}, any>;
+//# sourceMappingURL=update-task.d.ts.map

package/dist/toolkits/google-tasks/tools/update-task.js

@@ -0,0 +1,47 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { tasksApiRequest } from './utils.js';
+export const updateTask = tool({
+    description: 'Updates a task title, notes, due date, or status. Use to rename, reschedule, complete (status completed), or reopen (status needsAction) a task. Only provided fields are changed.',
+    inputSchema: z.object({
+        googleTasksToken: z.string().describe('The Google Tasks access token'),
+        taskListId: z.string().describe('The ID of the task list containing the task'),
+        taskId: z.string().describe('The ID of the task to update'),
+        title: z.string().optional().describe('New title for the task'),
+        notes: z.string().optional().describe('New notes for the task'),
+        due: z.string().optional().describe('New due date in RFC 3339 format, e.g. 2026-09-20T00:00:00Z'),
+        completed: z.string().optional().describe('Completion timestamp in RFC 3339 format (only with status completed)'),
+        status: z.enum(['needsAction', 'completed']).optional().describe('Set completed to finish, needsAction to reopen'),
+    }),
+    execute: async ({ googleTasksToken, taskListId, taskId, title, notes, due, completed, status }) => {
+        try {
+            const body = {};
+            if (title !== undefined)
+                body.title = title;
+            if (notes !== undefined)
+                body.notes = notes;
+            if (due !== undefined)
+                body.due = due;
+            if (completed !== undefined)
+                body.completed = completed;
+            if (status !== undefined)
+                body.status = status;
+            const result = await tasksApiRequest(googleTasksToken, `/lists/${taskListId}/tasks/${taskId}`, {
+                method: 'PATCH',
+                body,
+            });
+            if (!result.ok) {
+                return { error: 'Failed to update task', details: result.error };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error updating task',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=update-task.js.map

package/dist/toolkits/google-tasks/tools/utils.d.ts

@@ -0,0 +1,15 @@
+export declare const TASKS_API_BASE = "https://tasks.googleapis.com/tasks/v1";
+export declare function tasksApiRequest(googleTasksToken: string, path: string, options?: {
+    method?: string;
+    body?: Record<string, unknown>;
+    searchParams?: Record<string, string | number | boolean | undefined>;
+}): Promise<{
+    ok: false;
+    error: any;
+    data?: undefined;
+} | {
+    ok: true;
+    data: any;
+    error?: undefined;
+}>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/toolkits/google-tasks/tools/utils.js

@@ -0,0 +1,33 @@
+// @ts-nocheck
+export const TASKS_API_BASE = 'https://tasks.googleapis.com/tasks/v1';
+export async function tasksApiRequest(googleTasksToken, path, options) {
+    const url = new URL(`${TASKS_API_BASE}${path}`);
+    if (options?.searchParams) {
+        for (const [key, value] of Object.entries(options.searchParams)) {
+            if (value !== undefined) {
+                url.searchParams.set(key, String(value));
+            }
+        }
+    }
+    const fetchOptions = {
+        method: options?.method ?? 'GET',
+        headers: {
+            Authorization: `Bearer ${googleTasksToken}`,
+            ...(options?.body ? { 'Content-Type': 'application/json' } : {}),
+        },
+    };
+    if (options?.body) {
+        fetchOptions.body = JSON.stringify(options.body);
+    }
+    const response = await fetch(url.toString(), fetchOptions);
+    if (!response.ok) {
+        const error = await response.json().catch(() => ({}));
+        return { ok: false, error };
+    }
+    if (response.status === 204) {
+        return { ok: true, data: { success: true } };
+    }
+    const data = await response.json();
+    return { ok: true, data };
+}
+//# sourceMappingURL=utils.js.map

package/dist/toolkits/groww/icon.d.ts

@@ -0,0 +1,5 @@
+export declare const GROWW_ICON: {
+    kind: "svg";
+    dataUri: string;
+};
+//# sourceMappingURL=icon.d.ts.map

package/dist/toolkits/groww/icon.js

@@ -0,0 +1,21 @@
+const SVG = `<svg id="Layer_1" xmlns="http://www.w3.org/2000/svg" version="1.1" viewBox="0 0 150 150">
+  
+  <defs>
+    <style>
+      .st0 {
+        fill: #4e68ff;
+      }
+
+      .st1 {
+        fill: #00f6b6;
+      }
+    </style>
+  </defs>
+  <path class="st0" d="M92.23,147.97c40.31-9.52,65.27-49.9,55.75-90.2C138.46,17.47,98.07-7.49,57.77,2.02,17.47,11.54-7.49,51.93,2.02,92.23c9.52,40.3,49.91,65.26,90.2,55.74Z"/>
+  <path class="st1" d="M147.98,57.77c-1.36-5.77-3.35-11.21-5.88-16.3l-.02.02-47.22,43.65c-2.95,2.73-7.34,3.2-10.81,1.17l-20.07-11.75c-3.25-1.89-7.32-1.61-10.26.72-12.43,9.84-44.26,35.01-44.71,35.38,15.7,29.11,49.48,45.29,83.22,37.31,40.31-9.52,65.27-49.9,55.75-90.2Z"/>
+</svg>`;
+export const GROWW_ICON = {
+    kind: 'svg',
+    dataUri: `data:image/svg+xml;base64,${Buffer.from(SVG).toString('base64')}`,
+};
+//# sourceMappingURL=icon.js.map

package/dist/toolkits/groww/manifest.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("../../index.js").ToolkitManifest;
+export default _default;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/toolkits/groww/manifest.js

@@ -0,0 +1,32 @@
+import { defineToolkit, defineTool } from '../../core/define.js';
+import { GROWW_ICON } from './icon.js';
+import { growwTools } from './tools/index.js';
+export default defineToolkit({
+    id: 'groww',
+    displayName: 'Groww',
+    shortDescription: 'Trade equities and F&O, manage orders and smart orders, and fetch live market data.',
+    category: 'Finance & Accounting',
+    icon: GROWW_ICON,
+    auth: {
+        type: 'bearer_token',
+        tokenField: 'growwAccessToken',
+        provider: {
+            connectDescription: 'Connect Groww with a Trading API access token. Generate one from Groww Profile > Settings > Trading APIs > Generate API keys > Access Token (expires daily at 6:00 AM). Alternatively generate it via your API key + secret checksum or TOTP flow, then paste the access token here. All trading calls send it as Authorization: Bearer <token> with X-API-VERSION: 1.0.',
+        },
+    },
+    allowedHosts: ['api.groww.in', 'growwapi-assets.groww.in'],
+    tools: growwTools.map((entry) => defineTool({
+        name: entry.name,
+        description: entry.description,
+        tool: entry.tool,
+        requiredAuth: entry.requiredAuth,
+        scope: entry.scope,
+    })),
+    meta: {
+        since: '0.0.7',
+        homepage: 'https://groww.in',
+        docsUrl: 'https://groww.in/trade-api/docs/curl',
+        apiDocsUrl: 'https://groww.in/trade-api/docs/curl',
+    },
+});
+//# sourceMappingURL=manifest.js.map

package/dist/toolkits/groww/tools/historical.d.ts

@@ -0,0 +1,32 @@
+export declare const growwGetHistoricalCandles: import("ai").Tool<{
+    exchange: string;
+    segment: string;
+    groww_symbol: string;
+    start_time: string;
+    end_time: string;
+    candle_interval: string;
+    growwAccessToken?: string | undefined;
+}, unknown>;
+export declare const growwGetHistoricalCandleRange: import("ai").Tool<{
+    trading_symbol: string;
+    exchange: string;
+    segment: string;
+    start_time: string;
+    end_time: string;
+    growwAccessToken?: string | undefined;
+    interval_in_minutes?: string | undefined;
+}, unknown>;
+export declare const growwGetExpiries: import("ai").Tool<{
+    exchange: string;
+    underlying_symbol: string;
+    year?: number | undefined;
+    month?: number | undefined;
+    growwAccessToken?: string | undefined;
+}, unknown>;
+export declare const growwGetContracts: import("ai").Tool<{
+    exchange: string;
+    expiry_date: string;
+    underlying_symbol: string;
+    growwAccessToken?: string | undefined;
+}, unknown>;
+//# sourceMappingURL=historical.d.ts.map

package/dist/toolkits/groww/tools/historical.js

@@ -0,0 +1,85 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { growwRequest, handleGrowwResult } from './utils.js';
+const tokenField = z.string().optional().describe('Groww API access token (injected by system)');
+export const growwGetHistoricalCandles = tool({
+    description: 'Get historical OHLCV candles (+OI for FNO) for backtesting using a Groww symbol like NSE-WIPRO or NSE-NIFTY-30Sep25-24650-CE. Data available from 2020. Limits: <=5min intervals 30 days/req, 10-30min 90 days, >=1h 180 days.',
+    inputSchema: z.object({
+        growwAccessToken: tokenField,
+        exchange: z.string().describe('NSE or BSE'),
+        segment: z.string().describe('CASH or FNO'),
+        groww_symbol: z.string().describe('Groww symbol, e.g. NSE-WIPRO, NSE-NIFTY-30Sep25-24650-CE'),
+        start_time: z.string().describe('Start time yyyy-MM-dd HH:mm:ss or epoch seconds'),
+        end_time: z.string().describe('End time yyyy-MM-dd HH:mm:ss or epoch seconds'),
+        candle_interval: z.string().describe('1minute, 2minute, 3minute, 5minute, 10minute, 15minute, 30minute, hour, 4hour, day, week or month'),
+    }),
+    execute: async ({ growwAccessToken, ...query }) => {
+        try {
+            const result = await growwRequest(growwAccessToken, '/v1/historical/candles', { query });
+            return handleGrowwResult(result, 'get historical candles');
+        }
+        catch (error) {
+            return { error: 'Error getting historical candles', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const growwGetHistoricalCandleRange = tool({
+    description: 'DEPRECATED by Groww (use growwGetHistoricalCandles instead). Get historical candles by trading symbol for a time range.',
+    inputSchema: z.object({
+        growwAccessToken: tokenField,
+        exchange: z.string().describe('NSE or BSE'),
+        segment: z.string().describe('CASH or FNO'),
+        trading_symbol: z.string().describe('Trading symbol, e.g. WIPRO'),
+        start_time: z.string().describe('Start time yyyy-MM-dd HH:mm:ss or epoch seconds'),
+        end_time: z.string().describe('End time yyyy-MM-dd HH:mm:ss or epoch seconds'),
+        interval_in_minutes: z.string().optional().describe('Candle interval in minutes, e.g. 1, 5, 60, 1440'),
+    }),
+    execute: async ({ growwAccessToken, ...query }) => {
+        try {
+            const result = await growwRequest(growwAccessToken, '/v1/historical/candle/range', { query });
+            return handleGrowwResult(result, 'get historical candle range');
+        }
+        catch (error) {
+            return { error: 'Error getting historical data', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const growwGetExpiries = tool({
+    description: 'List available FNO expiry dates for an underlying. Combine with contracts + historical candles for backtesting. Data from 2020.',
+    inputSchema: z.object({
+        growwAccessToken: tokenField,
+        exchange: z.string().describe('NSE or BSE'),
+        underlying_symbol: z.string().describe('Underlying symbol, e.g. NIFTY, BANKNIFTY'),
+        year: z.number().int().min(2020).optional().describe('Year 2020-current, defaults to current year'),
+        month: z.number().int().min(1).max(12).optional().describe('Month 1-12, omit for whole year'),
+    }),
+    execute: async ({ growwAccessToken, ...query }) => {
+        try {
+            const result = await growwRequest(growwAccessToken, '/v1/historical/expiries', { query });
+            return handleGrowwResult(result, 'get expiries');
+        }
+        catch (error) {
+            return { error: 'Error getting expiries', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const growwGetContracts = tool({
+    description: 'List Groww symbols of FNO contracts for an underlying and expiry date.',
+    inputSchema: z.object({
+        growwAccessToken: tokenField,
+        exchange: z.string().describe('NSE or BSE'),
+        underlying_symbol: z.string().describe('Underlying symbol 1-20 chars, e.g. NIFTY'),
+        expiry_date: z.string().describe('Expiry date YYYY-MM-DD'),
+    }),
+    execute: async ({ growwAccessToken, ...query }) => {
+        try {
+            const result = await growwRequest(growwAccessToken, '/v1/historical/contracts', { query });
+            return handleGrowwResult(result, 'get contracts');
+        }
+        catch (error) {
+            return { error: 'Error getting contracts', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=historical.js.map