@thewhateverapp/tile-sdk 0.1.0

package/dist/bridge/TileBridge.js

@@ -0,0 +1,362 @@
+/**
+ * Secure message bridge for tile-parent communication
+ * This runs inside the iframe (tile side)
+ */
+export class TileBridge {
+    constructor(expectedOrigin = 'https://thewhatever.app') {
+        this.config = null;
+        this.messageQueue = [];
+        this.responseHandlers = new Map();
+        this.eventHandlers = new Map();
+        this.ready = false;
+        this.parentOrigin = expectedOrigin;
+        // In development, allow localhost
+        if (typeof window !== 'undefined' && window.location.hostname === 'localhost') {
+            this.parentOrigin = 'http://localhost:3000';
+        }
+        this.initialize();
+    }
+    initialize() {
+        if (typeof window === 'undefined')
+            return;
+        // Listen for messages from parent
+        window.addEventListener('message', this.handleMessage.bind(this));
+        // Send ready signal to parent
+        this.sendToParent({ type: 'tile:ready' });
+        // Request configuration from parent
+        this.sendToParent({ type: 'tile:request-config' });
+    }
+    handleMessage(event) {
+        // Validate origin
+        if (event.origin !== this.parentOrigin && !this.isDevelopment()) {
+            console.warn('Received message from untrusted origin:', event.origin);
+            return;
+        }
+        const message = event.data;
+        // Handle system messages
+        switch (message.type) {
+            case 'parent:config':
+                this.handleConfig(message.payload);
+                break;
+            case 'parent:response':
+                this.handleResponse(message);
+                break;
+            case 'parent:event':
+                this.handleEvent(message);
+                break;
+            default:
+                // Handle custom messages
+                this.emitEvent(message.type, message.payload);
+        }
+    }
+    handleConfig(config) {
+        this.config = config;
+        this.ready = true;
+        // Process queued messages
+        while (this.messageQueue.length > 0) {
+            const message = this.messageQueue.shift();
+            if (message) {
+                this.sendToParent(message);
+            }
+        }
+        // Emit config ready event
+        this.emitEvent('config:ready', config);
+    }
+    handleResponse(message) {
+        if (message.id) {
+            const handler = this.responseHandlers.get(message.id);
+            if (handler) {
+                handler(message.payload);
+                this.responseHandlers.delete(message.id);
+            }
+        }
+    }
+    handleEvent(message) {
+        this.emitEvent(message.payload?.type, message.payload?.data);
+    }
+    sendToParent(message) {
+        if (typeof window === 'undefined' || !window.parent)
+            return;
+        // Add metadata
+        const fullMessage = {
+            ...message,
+            timestamp: Date.now(),
+            id: message.id || this.generateId(),
+        };
+        // Queue if not ready
+        if (!this.ready && message.type !== 'tile:ready' && message.type !== 'tile:request-config') {
+            this.messageQueue.push(fullMessage);
+            return;
+        }
+        // Send to parent
+        window.parent.postMessage(fullMessage, this.parentOrigin);
+    }
+    // Public API
+    /**
+     * Request to navigate to full page view
+     */
+    navigateToPage() {
+        this.sendToParent({
+            type: 'tile:navigate',
+            payload: { target: 'page' },
+        });
+    }
+    /**
+     * Request to open a URL (with user confirmation)
+     */
+    openUrl(url, target = '_blank') {
+        this.sendToParent({
+            type: 'tile:open-url',
+            payload: { url, target },
+        });
+    }
+    /**
+     * Send analytics event
+     */
+    trackEvent(eventName, data) {
+        this.sendToParent({
+            type: 'tile:track',
+            payload: { event: eventName, data },
+        });
+    }
+    /**
+     * Request clipboard write (requires user permission)
+     */
+    async writeToClipboard(text) {
+        return new Promise((resolve, reject) => {
+            const id = this.generateId();
+            this.responseHandlers.set(id, (response) => {
+                if (response.success) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(response.error || 'Clipboard write failed'));
+                }
+            });
+            this.sendToParent({
+                type: 'tile:clipboard-write',
+                payload: { text },
+                id,
+            });
+            // Timeout after 5 seconds
+            setTimeout(() => {
+                if (this.responseHandlers.has(id)) {
+                    this.responseHandlers.delete(id);
+                    reject(new Error('Request timeout'));
+                }
+            }, 5000);
+        });
+    }
+    /**
+     * Store data in parent's storage (limited to 100KB per tile)
+     */
+    async setStorage(key, value) {
+        return new Promise((resolve, reject) => {
+            const id = this.generateId();
+            // Check size limit
+            const serialized = JSON.stringify(value);
+            if (serialized.length > 100 * 1024) {
+                reject(new Error('Storage value exceeds 100KB limit'));
+                return;
+            }
+            this.responseHandlers.set(id, (response) => {
+                if (response.success) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(response.error || 'Storage write failed'));
+                }
+            });
+            this.sendToParent({
+                type: 'tile:storage-set',
+                payload: { key, value },
+                id,
+            });
+        });
+    }
+    /**
+     * Get data from parent's storage
+     */
+    async getStorage(key) {
+        return new Promise((resolve, reject) => {
+            const id = this.generateId();
+            this.responseHandlers.set(id, (response) => {
+                if (response.success) {
+                    resolve(response.value);
+                }
+                else {
+                    reject(new Error(response.error || 'Storage read failed'));
+                }
+            });
+            this.sendToParent({
+                type: 'tile:storage-get',
+                payload: { key },
+                id,
+            });
+        });
+    }
+    /**
+     * Request resize (within limits)
+     */
+    requestResize(width, height) {
+        // Limit to max 512x512 for tiles
+        const constrainedWidth = Math.min(width, 512);
+        const constrainedHeight = Math.min(height, 512);
+        this.sendToParent({
+            type: 'tile:resize',
+            payload: { width: constrainedWidth, height: constrainedHeight },
+        });
+    }
+    /**
+     * Request user authentication with specific scopes
+     */
+    async getUser(options) {
+        return new Promise((resolve, reject) => {
+            const id = this.generateId();
+            this.responseHandlers.set(id, (response) => {
+                if (response.success && response.user) {
+                    resolve(response.user);
+                }
+                else if (response.denied) {
+                    resolve(null); // User denied permission
+                }
+                else {
+                    reject(new Error(response.error || 'Authentication failed'));
+                }
+            });
+            this.sendToParent({
+                type: 'tile:auth-request',
+                payload: {
+                    scopes: options?.scopes || ['id'],
+                    reason: options?.reason,
+                },
+                id,
+            });
+            // Timeout after 30 seconds
+            setTimeout(() => {
+                if (this.responseHandlers.has(id)) {
+                    this.responseHandlers.delete(id);
+                    reject(new Error('Authentication request timeout'));
+                }
+            }, 30000);
+        });
+    }
+    /**
+     * Request additional permission scopes
+     */
+    async requestScopes(scopes) {
+        return new Promise((resolve, reject) => {
+            const id = this.generateId();
+            this.responseHandlers.set(id, (response) => {
+                if (response.success) {
+                    resolve(true);
+                }
+                else if (response.denied) {
+                    resolve(false);
+                }
+                else {
+                    reject(new Error(response.error || 'Permission request failed'));
+                }
+            });
+            this.sendToParent({
+                type: 'tile:auth-request-scopes',
+                payload: { scopes },
+                id,
+            });
+            // Timeout after 30 seconds
+            setTimeout(() => {
+                if (this.responseHandlers.has(id)) {
+                    this.responseHandlers.delete(id);
+                    reject(new Error('Permission request timeout'));
+                }
+            }, 30000);
+        });
+    }
+    /**
+     * Get current authenticated user (if available)
+     */
+    async getCurrentUser() {
+        return new Promise((resolve) => {
+            const id = this.generateId();
+            this.responseHandlers.set(id, (response) => {
+                resolve(response.user || null);
+            });
+            this.sendToParent({
+                type: 'tile:auth-get-current',
+                id,
+            });
+            // Timeout after 5 seconds, return null if no response
+            setTimeout(() => {
+                if (this.responseHandlers.has(id)) {
+                    this.responseHandlers.delete(id);
+                    resolve(null);
+                }
+            }, 5000);
+        });
+    }
+    /**
+     * Subscribe to events from parent
+     */
+    on(event, handler) {
+        if (!this.eventHandlers.has(event)) {
+            this.eventHandlers.set(event, new Set());
+        }
+        this.eventHandlers.get(event).add(handler);
+        // Return unsubscribe function
+        return () => {
+            const handlers = this.eventHandlers.get(event);
+            if (handlers) {
+                handlers.delete(handler);
+            }
+        };
+    }
+    /**
+     * Get tile configuration
+     */
+    getConfig() {
+        return this.config;
+    }
+    /**
+     * Check if ready
+     */
+    isReady() {
+        return this.ready;
+    }
+    /**
+     * Wait for ready state
+     */
+    async waitForReady() {
+        if (this.ready && this.config) {
+            return this.config;
+        }
+        return new Promise((resolve) => {
+            const unsubscribe = this.on('config:ready', (config) => {
+                unsubscribe();
+                resolve(config);
+            });
+        });
+    }
+    // Private helpers
+    emitEvent(event, data) {
+        const handlers = this.eventHandlers.get(event);
+        if (handlers) {
+            handlers.forEach(handler => handler(data));
+        }
+    }
+    generateId() {
+        return `${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+    isDevelopment() {
+        return typeof window !== 'undefined' &&
+            (window.location.hostname === 'localhost' ||
+                window.location.hostname === '127.0.0.1');
+    }
+}
+// Singleton instance
+let bridgeInstance = null;
+export function getTileBridge() {
+    if (!bridgeInstance) {
+        bridgeInstance = new TileBridge();
+    }
+    return bridgeInstance;
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { TileProvider } from './react/TileProvider';
+export { useTile } from './react/useTile';
+export { TileContainer } from './react/TileContainer';
+export { withTile } from './react/withTile';
+export { getTileBridge, TileBridge } from './bridge/TileBridge';
+export type { TileMessage, TileConfig } from './bridge/TileBridge';
+export * from './tools';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACpD,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC1C,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAG5C,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAChE,YAAY,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAGnE,cAAc,SAAS,CAAC;AAGxB,cAAc,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,11 @@
+// React components and hooks
+export { TileProvider } from './react/TileProvider';
+export { useTile } from './react/useTile';
+export { TileContainer } from './react/TileContainer';
+export { withTile } from './react/withTile';
+// Bridge for secure communication
+export { getTileBridge, TileBridge } from './bridge/TileBridge';
+// Domain-specific tools
+export * from './tools';
+// Types
+export * from './types';

package/dist/react/TileContainer.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { TileProps } from '../types';
+export declare function TileContainer({ width, height, className, children }: TileProps): React.JSX.Element;
+//# sourceMappingURL=TileContainer.d.ts.map

package/dist/react/TileContainer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TileContainer.d.ts","sourceRoot":"","sources":["../../src/react/TileContainer.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAErC,wBAAgB,aAAa,CAAC,EAC5B,KAAW,EACX,MAAY,EACZ,SAAc,EACd,QAAQ,EACT,EAAE,SAAS,qBAmBX"}

package/dist/react/TileContainer.js

@@ -0,0 +1,14 @@
+import React from 'react';
+export function TileContainer({ width = 512, height = 512, className = '', children }) {
+    return (React.createElement("div", { className: `tile-container ${className}`, style: {
+            width: `${width}px`,
+            height: `${height}px`,
+            overflow: 'hidden',
+            position: 'relative',
+            display: 'flex',
+            flexDirection: 'column',
+            alignItems: 'center',
+            justifyContent: 'center',
+            boxSizing: 'border-box',
+        } }, children));
+}

package/dist/react/TileProvider.d.ts

@@ -0,0 +1,33 @@
+import React from 'react';
+import { TileBridge, TileConfig } from '../bridge/TileBridge';
+export interface TileContextValue {
+    config: TileConfig | null;
+    bridge: TileBridge;
+    isReady: boolean;
+    navigateToPage: () => void;
+    openUrl: (url: string, target?: '_blank' | '_self') => void;
+    trackEvent: (eventName: string, data?: any) => void;
+    storage: {
+        get: (key: string) => Promise<any>;
+        set: (key: string, value: any) => Promise<void>;
+    };
+    clipboard: {
+        write: (text: string) => Promise<void>;
+    };
+    auth: {
+        getUser: (options?: {
+            scopes?: string[];
+            reason?: string;
+        }) => Promise<any>;
+        requestScopes: (scopes: string[]) => Promise<boolean>;
+        getCurrentUser: () => Promise<any>;
+    };
+}
+export declare const TileContext: React.Context<TileContextValue | null>;
+interface TileProviderProps {
+    children: React.ReactNode;
+    fallback?: React.ReactNode;
+}
+export declare function TileProvider({ children, fallback }: TileProviderProps): React.JSX.Element;
+export {};
+//# sourceMappingURL=TileProvider.d.ts.map

package/dist/react/TileProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TileProvider.d.ts","sourceRoot":"","sources":["../../src/react/TileProvider.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA0D,MAAM,OAAO,CAAC;AAC/E,OAAO,EAAiB,UAAU,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAE7E,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,UAAU,GAAG,IAAI,CAAC;IAC1B,MAAM,EAAE,UAAU,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;IACjB,cAAc,EAAE,MAAM,IAAI,CAAC;IAC3B,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,QAAQ,GAAG,OAAO,KAAK,IAAI,CAAC;IAC5D,UAAU,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,KAAK,IAAI,CAAC;IACpD,OAAO,EAAE;QACP,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;QACnC,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;KACjD,CAAC;IACF,SAAS,EAAE;QACT,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;KACxC,CAAC;IACF,IAAI,EAAE;QACJ,OAAO,EAAE,CAAC,OAAO,CAAC,EAAE;YAAE,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;YAAC,MAAM,CAAC,EAAE,MAAM,CAAA;SAAE,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;QAC5E,aAAa,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;QACtD,cAAc,EAAE,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC;KACpC,CAAC;CACH;AAED,eAAO,MAAM,WAAW,wCAA+C,CAAC;AAExE,UAAU,iBAAiB;IACzB,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;CAC5B;AAED,wBAAgB,YAAY,CAAC,EAAE,QAAQ,EAAE,QAAQ,EAAE,EAAE,iBAAiB,qBAmDrE"}

package/dist/react/TileProvider.js

@@ -0,0 +1,45 @@
+import React, { createContext, useEffect, useState } from 'react';
+import { getTileBridge } from '../bridge/TileBridge';
+export const TileContext = createContext(null);
+export function TileProvider({ children, fallback }) {
+    const [config, setConfig] = useState(null);
+    const [isReady, setIsReady] = useState(false);
+    const bridge = getTileBridge();
+    useEffect(() => {
+        // Wait for bridge to be ready and config to be received
+        bridge.waitForReady().then((receivedConfig) => {
+            setConfig(receivedConfig);
+            setIsReady(true);
+        });
+        // Listen for config updates
+        const unsubscribe = bridge.on('config:update', (updatedConfig) => {
+            setConfig(updatedConfig);
+        });
+        return unsubscribe;
+    }, [bridge]);
+    const contextValue = {
+        config,
+        bridge,
+        isReady,
+        navigateToPage: () => bridge.navigateToPage(),
+        openUrl: (url, target) => bridge.openUrl(url, target),
+        trackEvent: (eventName, data) => bridge.trackEvent(eventName, data),
+        storage: {
+            get: (key) => bridge.getStorage(key),
+            set: (key, value) => bridge.setStorage(key, value),
+        },
+        clipboard: {
+            write: (text) => bridge.writeToClipboard(text),
+        },
+        auth: {
+            getUser: (options) => bridge.getUser(options),
+            requestScopes: (scopes) => bridge.requestScopes(scopes),
+            getCurrentUser: () => bridge.getCurrentUser(),
+        },
+    };
+    // Show fallback while loading
+    if (!isReady && fallback) {
+        return React.createElement(React.Fragment, null, fallback);
+    }
+    return (React.createElement(TileContext.Provider, { value: contextValue }, children));
+}

package/dist/react/index.d.ts

@@ -0,0 +1,5 @@
+export { TileProvider } from './TileProvider';
+export { useTile } from './useTile';
+export { TileContainer } from './TileContainer';
+export { withTile } from './withTile';
+//# sourceMappingURL=index.d.ts.map

package/dist/react/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/react/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC"}

package/dist/react/index.js

@@ -0,0 +1,4 @@
+export { TileProvider } from './TileProvider';
+export { useTile } from './useTile';
+export { TileContainer } from './TileContainer';
+export { withTile } from './withTile';

package/dist/react/useTile.d.ts

@@ -0,0 +1,3 @@
+import { TileContextValue } from './TileProvider';
+export declare function useTile(): TileContextValue;
+//# sourceMappingURL=useTile.d.ts.map

package/dist/react/useTile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTile.d.ts","sourceRoot":"","sources":["../../src/react/useTile.ts"],"names":[],"mappings":"AACA,OAAO,EAAe,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAE/D,wBAAgB,OAAO,IAAI,gBAAgB,CAQ1C"}

package/dist/react/useTile.js

@@ -0,0 +1,9 @@
+import { useContext } from 'react';
+import { TileContext } from './TileProvider';
+export function useTile() {
+    const context = useContext(TileContext);
+    if (!context) {
+        throw new Error('useTile must be used within a TileProvider');
+    }
+    return context;
+}

package/dist/react/withTile.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import type { TileContextValue } from './TileProvider';
+export declare function withTile<P extends object>(Component: React.ComponentType<P & {
+    tile: TileContextValue;
+}>): React.ComponentType<P>;
+//# sourceMappingURL=withTile.d.ts.map

package/dist/react/withTile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withTile.d.ts","sourceRoot":"","sources":["../../src/react/withTile.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAEvD,wBAAgB,QAAQ,CAAC,CAAC,SAAS,MAAM,EACvC,SAAS,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC,GAAG;IAAE,IAAI,EAAE,gBAAgB,CAAA;CAAE,CAAC,GAC7D,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,CAKxB"}

package/dist/react/withTile.js

@@ -0,0 +1,8 @@
+import React from 'react';
+import { useTile } from './useTile';
+export function withTile(Component) {
+    return function WithTileComponent(props) {
+        const tile = useTile();
+        return React.createElement(Component, { ...props, tile: tile });
+    };
+}

package/dist/tools/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Tile SDK Tools - Placeholder exports
+ * TODO: Implement domain-specific tools for tile development
+ */
+export declare const tools: {};
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tools/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,eAAO,MAAM,KAAK,IAAK,CAAC"}

package/dist/tools/index.js

@@ -0,0 +1,6 @@
+/**
+ * Tile SDK Tools - Placeholder exports
+ * TODO: Implement domain-specific tools for tile development
+ */
+// Placeholder exports - tools not yet implemented
+export const tools = {};

package/dist/types.d.ts

@@ -0,0 +1,61 @@
+/**
+ * App manifest structure
+ */
+export interface AppManifest {
+    id: string;
+    name: string;
+    description: string;
+    version: string;
+    owner: string;
+    createdAt: string;
+    updatedAt: string;
+    components: {
+        tile: {
+            entrypoint: string;
+            assets: string[];
+        };
+        page?: {
+            entrypoint: string;
+            assets: string[];
+        };
+        worker?: {
+            entrypoint: string;
+            routes: string[];
+        };
+    };
+}
+export interface TileContext {
+    appId: string;
+    manifest: AppManifest;
+    position: {
+        row: number;
+        col: number;
+    };
+    isFullscreen: boolean;
+    navigateToPage: () => void;
+    sendMessage: (type: string, data: any) => void;
+    onMessage: (handler: (type: string, data: any) => void) => void;
+    storage: {
+        get: (key: string) => Promise<any>;
+        set: (key: string, value: any) => Promise<void>;
+        delete: (key: string) => Promise<void>;
+    };
+    api: {
+        call: (endpoint: string, options?: RequestInit) => Promise<Response>;
+    };
+}
+export interface TileProps {
+    width?: number;
+    height?: number;
+    className?: string;
+    children: React.ReactNode;
+}
+export interface TileConfig {
+    id: string;
+    name: string;
+    version: string;
+    entrypoint: string;
+    permissions?: string[];
+    capabilities?: string[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE;QACV,IAAI,EAAE;YACJ,UAAU,EAAE,MAAM,CAAC;YACnB,MAAM,EAAE,MAAM,EAAE,CAAC;SAClB,CAAC;QACF,IAAI,CAAC,EAAE;YACL,UAAU,EAAE,MAAM,CAAC;YACnB,MAAM,EAAE,MAAM,EAAE,CAAC;SAClB,CAAC;QACF,MAAM,CAAC,EAAE;YACP,UAAU,EAAE,MAAM,CAAC;YACnB,MAAM,EAAE,MAAM,EAAE,CAAC;SAClB,CAAC;KACH,CAAC;CACH;AAED,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,WAAW,CAAC;IACtB,QAAQ,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC;IACvC,YAAY,EAAE,OAAO,CAAC;IACtB,cAAc,EAAE,MAAM,IAAI,CAAC;IAC3B,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,KAAK,IAAI,CAAC;IAC/C,SAAS,EAAE,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,KAAK,IAAI,KAAK,IAAI,CAAC;IAChE,OAAO,EAAE;QACP,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;QACnC,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;QAChD,MAAM,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;KACxC,CAAC;IACF,GAAG,EAAE;QACH,IAAI,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;KACtE,CAAC;CACH;AAED,MAAM,WAAW,SAAS;IACxB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B;AAED,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;CACzB"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};