@llmindset/hf-mcp 0.2.52 → 0.2.54

package/src/space/{space-tool.ts → dynamic-space-tool.ts}

@@ -9,6 +9,8 @@ import {
 	isDynamicSpaceMode,
 	getOperationNames,
 	getSpaceArgsSchema,
+	VIEW_PARAMETERS,
+	FILE_HANDLING_TEXT,
 } from './types.js';
 import { findSpaces } from './commands/dynamic-find.js';
 import { discoverSpaces } from './commands/discover.js';
@@ -24,11 +26,6 @@ export * from './types.js';
 const USAGE_INSTRUCTIONS = `# Gradio Space Interaction
 
 Dynamically interact with any Gradio MCP Space. Find spaces, view space parameter schemas, and invoke spaces.
-
-## Supported Schema Types
-
-✅ **Simple types** (supported):
-- Strings, numbers, booleans
 - Enums (predefined value sets)
 - Arrays of primitives
 - Shallow objects (one level deep)
@@ -50,13 +47,13 @@ Find MCP-enabled Spaces for available for invocation based on task-focused or se
 }
 \`\`\`
 
-### view_parameters
+### ${VIEW_PARAMETERS}
 Display the parameter schema for a space's first tool.
 
 **Example:**
 \`\`\`json
 {
-  "operation": "view_parameters",
+  "operation": "${VIEW_PARAMETERS}",
   "space_name": "evalstate/FLUX1_schnell"
 }
 \`\`\`
@@ -76,32 +73,31 @@ Execute a space's first tool with provided parameters.
 ## Workflow
 
 1. **Find Spaces** - Use \`find\` to find MCP-enabled spaces for your task
-2. **Inspect Parameters** - Use \`view_parameters\` to see what a space accepts
+2. **Inspect Parameters** - Use \`${VIEW_PARAMETERS}\` to see what a space accepts
 3. **Invoke the Space** - Use \`invoke\` with the required parameters
-
-## File Handling
-
 For parameters that accept files (FileData types):
 - Provide a publicly accessible URL (http:// or https://)
 - Example: \`{"image": "https://example.com/photo.jpg"}\`
-- Outputs from one tool may be used as inputs to another
-
-## Tips
-
-- Focus searches on specific tasks (e.g., "video generation", "object detection")
 - The tool automatically applies default values for optional parameters
 - Unknown parameters generate warnings but are still passed through (permissive inputs)
-- Enum parameters show all allowed values in view_parameters
+- Enum parameters show all allowed values in ${VIEW_PARAMETERS} output
 - Required parameters are clearly marked and validated
 `;
 
 /**
  * Usage instructions for dynamic mode (when DYNAMIC_SPACE_DATA is set)
- * Simplified instructions focusing on discover/view_parameters/invoke workflow
  */
-const DYNAMIC_USAGE_INSTRUCTIONS = `# Gradio Space Interaction
+const DYNAMIC_USAGE_INSTRUCTIONS = `# Hugging Face Space Dynamic Use
+
+Perform Tasks using Hugging Face Spaces. 
+
+## Workflow
+
+1. **Discover Taks and Spaces** - Use \`discover\` operation to see available spaces
+2. **View Parameters** - Use \`${VIEW_PARAMETERS}\` operation to inspect parameter schema
+3. **Invoke the Space** - Use \`invoke\` operation with the necessary parameters
 
-Dynamically use Gradio MCP Spaces. Discover available spaces, view their parameter schemas, and invoke them. Use "discover" to find recommended spaces for tasks.
+${FILE_HANDLING_TEXT}
 
 ## Available Operations
 
@@ -115,19 +111,19 @@ List recommended spaces and their categories.
 }
 \`\`\`
 
-### view_parameters
-Display the parameter schema for a space's first tool.
+### ${VIEW_PARAMETERS}
+Display the parameter schema for the Space.
 
 **Example:**
 \`\`\`json
 {
-  "operation": "view_parameters",
+  "operation": "${VIEW_PARAMETERS}",
   "space_name": "evalstate/FLUX1_schnell"
 }
 \`\`\`
 
 ### invoke
-Execute a space's first tool with provided parameters.
+Execute a Task on a Space.
 
 **Example:**
 \`\`\`json
@@ -138,18 +134,7 @@ Execute a space's first tool with provided parameters.
 }
 \`\`\`
 
-## Workflow
-
-1. **Discover Spaces** - Use \`discover\` to see available spaces
-2. **Inspect Parameters** - Use \`view_parameters\` to see what a space accepts
-3. **Invoke the Space** - Use \`invoke\` with the required parameters
 
-## File Handling
-
-For parameters that accept files (FileData types):
-- Provide a publicly accessible URL (http:// or https://)
-- Example: \`{"image": "https://example.com/photo.jpg"}\`
-- Output url's from one tool may be used as inputs to another.
 `;
 
 /**
@@ -173,13 +158,13 @@ export function getDynamicSpaceToolConfig(): {
 	return {
 		name: 'dynamic_space',
 		description: dynamicMode
-			? 'Discover, inspect (view parameter schema) and dynamically invoke Gradio MCP Spaces to conduct ML Tasks including Image Generation, Background Removal, Text to Speech and more ' +
-				'Call with no operation for full usage instructions.'
-			: 'Find (semantic/task search), inspect (view parameter schema) and dynamically invoke Gradio MCP Spaces. ' +
-				'Call with no operation for full usage instructions.',
+			? 'Perform Tasks with Hugging Face Spaces. Use "discover" to view available Tasks. Examples are Image Generation/Editing, Background Removal, Text to Speech, OCR and many more. ' +
+				'Call with no arguments for full usage instructions.'
+			: 'Find (semantic/task search), inspect (view parameter schema) and dynamically invoke Hugging Face Spaces. ' +
+				'Call with no arguments for full usage instructions.',
 		schema: getSpaceArgsSchema(),
 		annotations: {
-			title: 'Dynamically use Gradio Applications',
+			title: 'Dynamically use Hugging Face Spaces',
 			readOnlyHint: false,
 			openWorldHint: true,
 		},
@@ -192,11 +177,11 @@ export function getDynamicSpaceToolConfig(): {
 export const DYNAMIC_SPACE_TOOL_CONFIG = {
 	name: 'dynamic_space',
 	description:
-		'Find (semantic/task search), inspect (view parameter schema) and dynamically invoke Gradio MCP Spaces. ' +
+		'Find (semantic/task search), inspect (view parameter schema) and dynamically invoke Hugging Face Spaces. ' +
 		'Call with no operation for full usage instructions.',
 	schema: spaceArgsSchema,
 	annotations: {
-		title: 'Dynamically use Gradio Applications',
+		title: 'Dynamically use Hugging Face Spaces',
 		readOnlyHint: false,
 		openWorldHint: true,
 	},
@@ -306,7 +291,7 @@ Call this tool with no operation for full usage instructions.`,
 Example:
 \`\`\`json
 {
-  "operation": "view_parameters",
+  "operation": "${VIEW_PARAMETERS}",
   "space_name": "username/space-name"
 }
 \`\`\``,
@@ -361,7 +346,7 @@ Example:
 }
 \`\`\`
 
-Use "view_parameters" to see what parameters this space accepts.`,
+Use "${VIEW_PARAMETERS}" to see what parameters this space accepts.`,
 				totalResults: 0,
 				resultsShared: 0,
 				isError: true,

package/src/space/types.ts

@@ -5,11 +5,28 @@ import { z } from 'zod';
  * Standard mode: find, view_parameters, invoke
  * Dynamic mode (DYNAMIC_SPACE_DATA): discover, view_parameters, invoke
  */
-export const OPERATION_NAMES = ['find', 'view_parameters', 'invoke'] as const;
-export const DYNAMIC_OPERATION_NAMES = ['discover', 'view_parameters', 'invoke'] as const;
+
+export const VIEW_PARAMETERS = 'view_parameters';
+export const OPERATION_NAMES = ['find', VIEW_PARAMETERS, 'invoke'] as const;
+export const DYNAMIC_OPERATION_NAMES = ['discover', VIEW_PARAMETERS, 'invoke'] as const;
 export type OperationName = (typeof OPERATION_NAMES)[number];
 export type DynamicOperationName = (typeof DYNAMIC_OPERATION_NAMES)[number];
 
+/**
+ * File input help message constant
+ */
+export const FILE_INPUT_HELP_MESSAGE =
+	'Provide a publicly accessible URL (http:// or https://) for the file input. ' +
+	"Previously generated URL's are usable. ";
+
+/**
+ * File handling instructions for user-facing documentation
+ */
+export const FILE_HANDLING_TEXT = `For parameters that accept files (FileData, Images, file URL types):
+- Provide a publicly accessible URL (http:// or https://)
+- Example: \`{"image": "https://example.com/photo.jpg"}\`
+- URL's generated by one Space can be used as inputs to another Space.`;
+
 /**
  * Check if dynamic space mode is enabled
  */
@@ -32,10 +49,8 @@ export const spaceArgsSchema = z.object({
 	space_name: z
 		.string()
 		.optional()
-		.describe(
-			'The Hugging Face space ID (format: "username/space-name"). Required for view_parameters and invoke operations.'
-		),
-	parameters: z.string().optional().describe('For invoke operation: JSON object string of parameters'),
+		.describe(`Space ID (format: "username/space-name"). Required for operation = ${VIEW_PARAMETERS} or invoke.`),
+	parameters: z.string().optional().describe('Required for invoke operation: JSON object string of parameters'),
 	search_query: z
 		.string()
 		.optional()
@@ -49,14 +64,12 @@ export const spaceArgsSchema = z.object({
  * Zod schema for operation arguments (dynamic mode with DYNAMIC_SPACE_DATA)
  */
 export const dynamicSpaceArgsSchema = z.object({
-	operation: z.enum(DYNAMIC_OPERATION_NAMES).optional().describe('Operation to execute.'),
+	operation: z.enum(DYNAMIC_OPERATION_NAMES).optional().describe('Operation to perform.'),
 	space_name: z
 		.string()
 		.optional()
-		.describe(
-			'The Hugging Face space ID (format: "username/space-name"). Required for view_parameters and invoke operations.'
-		),
-	parameters: z.string().optional().describe('For invoke operation: JSON object string of parameters'),
+		.describe(`Space ID (format: "username/space-name"). Required for "${VIEW_PARAMETERS}" and "invoke" operations.`),
+	parameters: z.string().optional().describe('JSON object string of parameters. Only used for "invoke" operation.'),
 });
 
 /**
@@ -130,13 +143,6 @@ export interface JsonSchema {
 	[key: string]: unknown;
 }
 
-/**
- * File input help message constant
- */
-export const FILE_INPUT_HELP_MESSAGE =
-	'Provide a publicly accessible URL (http:// or https://) for the Gradio file input. ' +
-	"Content previously generated by 'invoke' is usable, as well as Hub Repository URLs. ";
-
 /**
  * Check if a property is a FileData type
  */

package/src/space/utils/gradio-caller.ts

@@ -0,0 +1,204 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { SSEClientTransport, type SSEClientTransportOptions } from '@modelcontextprotocol/sdk/client/sse.js';
+import { CallToolResultSchema, type ServerNotification, type ServerRequest } from '@modelcontextprotocol/sdk/types.js';
+import type { RequestHandlerExtra, RequestOptions } from '@modelcontextprotocol/sdk/shared/protocol.js';
+
+export interface GradioCallResult {
+	result: typeof CallToolResultSchema._type;
+	capturedHeaders: Record<string, string>;
+}
+
+export interface GradioCallOptions {
+	/** Called for every response to capture custom headers */
+	onHeaders?: (headers: Headers) => void;
+	/** Log the X-Proxied-Replica header to stderr once */
+	logProxiedReplica?: boolean;
+}
+
+/**
+ * Extract the replica ID from the X-Proxied-Replica header.
+ * Example: "oyerizs4-dspr4" => "dspr4"
+ */
+export function extractReplicaId(headerValue: string | undefined): string | null {
+	if (!headerValue) return null;
+	const parts = headerValue.split('-');
+	if (parts.length < 2) return null;
+	const replicaId = parts[parts.length - 1];
+	if (!replicaId || replicaId.trim() === '') return null;
+	return replicaId;
+}
+
+/**
+ * Rewrites any Gradio API URLs in text content to include the replica path segment.
+ * Example: https://mcp-tools-qwen-image-fast.hf.space/gradio_api =>
+ *          https://mcp-tools-qwen-image-fast.hf.space/--replicas/<replica_id>/gradio_api
+ */
+export function rewriteReplicaUrlsInResult(
+	result: typeof CallToolResultSchema._type,
+	proxiedReplicaHeader: string | undefined
+): typeof CallToolResultSchema._type {
+	if (process.env.NO_REPLICA_REWRITE) return result;
+	const replicaId = extractReplicaId(proxiedReplicaHeader);
+	if (!replicaId) return result;
+
+	const urlPattern = /https:\/\/([^\s"']+)\/gradio_api(\S*)?/g;
+
+	const rewriteText = (text: string): string =>
+		text.replace(urlPattern, (_match, host, rest = '') => {
+			return `https://${host}/--replicas/${replicaId}/gradio_api${rest}`;
+		});
+
+	let changed = false;
+	const newContent = result.content.map((item) => {
+		if (typeof item === 'string') {
+			const rewritten = rewriteText(item);
+			if (rewritten !== item) {
+				changed = true;
+				return { type: 'text', text: rewritten } as (typeof result.content)[number];
+			}
+			return { type: 'text', text: item } as (typeof result.content)[number];
+		}
+
+		if (item && typeof item === 'object' && 'text' in item && typeof item.text === 'string') {
+			const rewritten = rewriteText(item.text);
+			if (rewritten !== item.text) {
+				changed = true;
+				return { ...item, text: rewritten };
+			}
+		}
+
+		return item;
+	});
+
+	if (!changed) return result;
+	return {
+		...result,
+		content: newContent,
+	};
+}
+
+/**
+ * Shared helper to call a Gradio MCP tool over SSE, capturing response headers (including X-Proxied-Replica).
+ * This handles SSE setup, optional progress relay, and cleans up the client connection.
+ */
+export async function callGradioToolWithHeaders(
+	sseUrl: string,
+	toolName: string,
+	parameters: Record<string, unknown>,
+	hfToken: string | undefined,
+	extra: RequestHandlerExtra<ServerRequest, ServerNotification> | undefined,
+	options: GradioCallOptions = {}
+): Promise<GradioCallResult> {
+	const capturedHeaders: Record<string, string> = {};
+	let loggedHeader = false;
+
+	const handleHeaders = (headers: Headers): void => {
+		const proxiedReplica = headers.get('x-proxied-replica') ?? '';
+		if (proxiedReplica) {
+			capturedHeaders['x-proxied-replica'] = proxiedReplica;
+		}
+		if (options.logProxiedReplica && !loggedHeader) {
+			loggedHeader = true;
+		}
+		options.onHeaders?.(headers);
+	};
+
+	const captureHeadersFetch: SSEClientTransportOptions['fetch'] = async (url, init) => {
+		const response = await fetch(url, init);
+		handleHeaders(response.headers);
+		return response;
+	};
+
+	type EventSourceFetch = NonNullable<SSEClientTransportOptions['eventSourceInit']>['fetch'];
+	const buildEventSourceFetch =
+		(extraHeaders?: Record<string, string>): EventSourceFetch =>
+		(url, init) => {
+			const headers = new Headers(init?.headers);
+			if (extraHeaders) {
+				Object.entries(extraHeaders).forEach(([key, value]) => headers.set(key, value));
+			}
+			const requestInit: RequestInit = { ...(init as RequestInit), headers };
+			return captureHeadersFetch(url.toString(), requestInit);
+		};
+
+	// Create MCP client
+	const remoteClient = new Client(
+		{
+			name: 'hf-mcp-gradio-client',
+			version: '1.0.0',
+		},
+		{
+			capabilities: {},
+		}
+	);
+
+	// Create SSE transport with HF token if available
+	const transportOptions: SSEClientTransportOptions = {
+		fetch: captureHeadersFetch,
+	};
+	if (hfToken) {
+		const headerName = 'X-HF-Authorization';
+		const customHeaders = {
+			[headerName]: `Bearer ${hfToken}`,
+		};
+
+		// Headers for POST requests
+		transportOptions.requestInit = {
+			headers: customHeaders,
+		};
+
+		// Headers for SSE connection
+		transportOptions.eventSourceInit = {
+			fetch: buildEventSourceFetch(customHeaders),
+		};
+	} else {
+		transportOptions.eventSourceInit = {
+			fetch: buildEventSourceFetch(),
+		};
+	}
+
+	const transport = new SSEClientTransport(new URL(sseUrl), transportOptions);
+	await remoteClient.connect(transport);
+
+	try {
+		// Check if the client is requesting progress notifications
+		const progressToken = extra?._meta?.progressToken;
+		const requestOptions: RequestOptions = {};
+
+		if (progressToken !== undefined && extra) {
+			// Fire-and-forget; best-effort relay
+			requestOptions.onprogress = (progress) => {
+				void extra.sendNotification({
+					method: 'notifications/progress',
+					params: {
+						progressToken,
+						progress: progress.progress,
+						total: progress.total,
+						message: progress.message,
+					},
+				});
+			};
+			requestOptions.resetTimeoutOnProgress = true;
+		}
+
+		const result = await remoteClient.request(
+			{
+				method: 'tools/call',
+				params: {
+					name: toolName,
+					arguments: parameters,
+					_meta: progressToken !== undefined ? { progressToken } : undefined,
+				},
+			},
+			CallToolResultSchema,
+			requestOptions
+		);
+
+		const proxiedReplica = capturedHeaders['x-proxied-replica'];
+		const rewritten = rewriteReplicaUrlsInResult(result, proxiedReplica);
+
+		return { result: rewritten, capturedHeaders };
+	} finally {
+		await remoteClient.close();
+	}
+}

package/src/space/utils/gradio-schema.ts

@@ -0,0 +1,74 @@
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+
+export type ParsedSchemaFormat = 'array' | 'object';
+
+export interface ParsedGradioSchema {
+	format: ParsedSchemaFormat;
+	tools: Array<{ name: string; description?: string; inputSchema: unknown }>;
+}
+
+/**
+ * Parse a Gradio MCP schema that may be returned as either:
+ * - Array format: [{ name, description?, inputSchema }, ...]
+ * - Object format: { toolName: { properties, required, description?, ... }, ... }
+ *
+ * Returns a normalized list of tools and the detected format.
+ * Throws if the schema is invalid or empty.
+ */
+export function parseGradioSchemaResponse(schemaResponse: unknown): ParsedGradioSchema {
+	// Array format
+	if (Array.isArray(schemaResponse)) {
+		const tools = (schemaResponse as Array<unknown>).filter((tool): tool is { name: string; description?: string; inputSchema: unknown } => {
+			return (
+				typeof tool === 'object' &&
+				tool !== null &&
+				'name' in tool &&
+				typeof (tool as { name?: unknown }).name === 'string' &&
+				'inputSchema' in tool
+			);
+		});
+
+		if (tools.length === 0) {
+			throw new Error('Invalid schema: no tools found in array schema');
+		}
+
+		return {
+			format: 'array',
+			tools,
+		};
+	}
+
+	// Object format
+	if (typeof schemaResponse === 'object' && schemaResponse !== null) {
+		const entries = Object.entries(schemaResponse as Record<string, unknown>);
+		const tools: ParsedGradioSchema['tools'] = entries.map(([name, toolSchema]) => ({
+			name,
+			description: typeof (toolSchema as { description?: unknown }).description === 'string' ? (toolSchema as { description?: string }).description : undefined,
+			inputSchema: toolSchema,
+		}));
+
+		if (tools.length === 0) {
+			throw new Error('Invalid schema: no tools found in object schema');
+		}
+
+		return {
+			format: 'object',
+			tools,
+		};
+	}
+
+	throw new Error('Invalid schema format: expected array or object');
+}
+
+/**
+ * Convert ParsedGradioSchema.tools into SDK Tool[] shape, filtering out <lambda tools.
+ */
+export function normalizeParsedTools(parsed: ParsedGradioSchema): Tool[] {
+	return parsed.tools
+		.filter((t) => !t.name.toLowerCase().includes('<lambda'))
+		.map((parsedTool) => ({
+			name: parsedTool.name,
+			description: parsedTool.description || `${parsedTool.name} tool`,
+			inputSchema: parsedTool.inputSchema as Tool['inputSchema'],
+		}));
+}

package/src/space/utils/parameter-formatter.ts

@@ -1,5 +1,5 @@
 import type { SchemaComplexityResult, ParameterInfo } from '../types.js';
-import { FILE_INPUT_HELP_MESSAGE } from '../types.js';
+import { FILE_INPUT_HELP_MESSAGE, VIEW_PARAMETERS } from '../types.js';
 
 /**
  * Formats parameter schema for display to users
@@ -194,7 +194,7 @@ export function formatValidationError(errors: string[], spaceName: string): stri
 		output += `- ${error}\n`;
 	}
 
-	output += `\nUse the view_parameters operation to see all required parameters and their types.`;
+	output += `\nUse the ${VIEW_PARAMETERS} operation to see all required parameters and their types.`;
 
 	return output;
 }

package/test/gradio-caller.test.ts

@@ -0,0 +1,77 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { rewriteReplicaUrlsInResult, extractReplicaId } from '../src/space/utils/gradio-caller.js';
+import { CallToolResultSchema } from '@modelcontextprotocol/sdk/types.js';
+
+const baseResult: typeof CallToolResultSchema._type = {
+	content: [],
+	isError: false,
+};
+
+describe('extractReplicaId', () => {
+	it('extracts the suffix after hyphen', () => {
+		expect(extractReplicaId('oyerizs4-dspr4')).toBe('dspr4');
+	});
+
+	it('returns null when no hyphen exists', () => {
+		expect(extractReplicaId('singlepart')).toBeNull();
+	});
+
+	it('returns null for empty input', () => {
+		expect(extractReplicaId('')).toBeNull();
+		expect(extractReplicaId(undefined)).toBeNull();
+	});
+});
+
+describe('rewriteReplicaUrlsInResult', () => {
+	const matchUrl = 'https://mcp-tools-qwen-image-fast.hf.space/gradio_api';
+	const rewrittenUrl = 'https://mcp-tools-qwen-image-fast.hf.space/--replicas/dspr4/gradio_api';
+
+	beforeEach(() => {
+		delete process.env.NO_REPLICA_REWRITE;
+	});
+
+	afterEach(() => {
+		delete process.env.NO_REPLICA_REWRITE;
+	});
+
+	it('rewrites URLs in text content when header is present', () => {
+		const result: typeof CallToolResultSchema._type = {
+			...baseResult,
+			content: [
+				{ type: 'text', text: `prefix ${matchUrl} suffix` },
+				`plain ${matchUrl}`,
+				{ type: 'image', data: 'noop' },
+			],
+		};
+
+		const rewritten = rewriteReplicaUrlsInResult(result, 'oyerizs4-dspr4');
+
+		expect((rewritten.content[0] as { text: string }).text).toContain(rewrittenUrl);
+		expect((rewritten.content[1] as { text: string }).text).toContain(rewrittenUrl);
+		// Non-text blocks untouched
+		expect(rewritten.content[2]).toEqual(result.content[2]);
+	});
+
+	it('does nothing when header is missing', () => {
+		const result: typeof CallToolResultSchema._type = {
+			...baseResult,
+			content: [{ type: 'text', text: `prefix ${matchUrl} suffix` }],
+		};
+
+		const rewritten = rewriteReplicaUrlsInResult(result, undefined);
+
+		expect(rewritten).toEqual(result);
+	});
+
+	it('respects NO_REPLICA_REWRITE env', () => {
+		process.env.NO_REPLICA_REWRITE = '1';
+		const result: typeof CallToolResultSchema._type = {
+			...baseResult,
+			content: [{ type: 'text', text: matchUrl }],
+		};
+
+		const rewritten = rewriteReplicaUrlsInResult(result, 'oyerizs4-dspr4');
+
+		expect(rewritten).toEqual(result);
+	});
+});

package/dist/space/space-tool.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"space-tool.d.ts","sourceRoot":"","sources":["../../src/space/space-tool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAC5F,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,8CAA8C,CAAC;AACxF,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,EAEN,KAAK,SAAS,EACd,KAAK,YAAY,EAIjB,MAAM,YAAY,CAAC;AAOpB,cAAc,YAAY,CAAC;AAmJ3B,wBAAgB,yBAAyB,IAAI;IAC5C,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC;IACnC,WAAW,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,OAAO,CAAC;QAAC,aAAa,EAAE,OAAO,CAAA;KAAE,CAAC;CAC9E,CAgBA;AAKD,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;CAW5B,CAAC;AAKX,qBAAa,SAAS;IACrB,OAAO,CAAC,OAAO,CAAC,CAAS;gBAEb,OAAO,CAAC,EAAE,MAAM;IAStB,OAAO,CACZ,MAAM,EAAE,SAAS,EACjB,KAAK,CAAC,EAAE,mBAAmB,CAAC,aAAa,EAAE,kBAAkB,CAAC,GAC5D,OAAO,CAAC,YAAY,GAAG,UAAU,CAAC;YAgEvB,UAAU;YAOV,cAAc;YAOd,oBAAoB;YAyBpB,YAAY;CA+C1B"}

package/dist/space/space-tool.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"space-tool.js","sourceRoot":"","sources":["../../src/space/space-tool.ts"],"names":[],"mappings":"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"}