figmanage 0.1.0

package/dist/tools/compound.js

@@ -0,0 +1,334 @@
+import { z } from 'zod';
+import { internalClient } from '../clients/internal-api.js';
+import { publicClient } from '../clients/public-api.js';
+import { hasPat, hasCookie } from '../auth/client.js';
+import { defineTool, toolResult, toolError, figmaId, requireOrgId } from './register.js';
+// -- file_summary --
+defineTool({
+    toolset: 'compound',
+    auth: 'pat',
+    register(server, config) {
+        server.registerTool('file_summary', {
+            description: 'Quick overview of a Figma file. Fetches pages, components, styles, and comment counts in parallel.',
+            inputSchema: {
+                file_key: figmaId.describe('File key'),
+            },
+        }, async ({ file_key }) => {
+            try {
+                const api = publicClient(config);
+                const [fileResult, componentsResult, stylesResult, commentsResult] = await Promise.allSettled([
+                    api.get(`/v1/files/${file_key}`, { params: { depth: '1' } }),
+                    api.get(`/v1/files/${file_key}/components`),
+                    api.get(`/v1/files/${file_key}/styles`),
+                    api.get(`/v1/files/${file_key}/comments`),
+                ]);
+                if (fileResult.status === 'rejected') {
+                    return toolError(`Failed to fetch file: ${fileResult.reason?.response?.status || fileResult.reason?.message}`);
+                }
+                const fileData = fileResult.value.data;
+                const pages = (fileData.document?.children || []).map((c) => c.name);
+                const components = componentsResult.status === 'fulfilled' ? componentsResult.value.data?.meta?.components || [] : [];
+                const styles = stylesResult.status === 'fulfilled' ? stylesResult.value.data?.meta?.styles || [] : [];
+                const comments = commentsResult.status === 'fulfilled' ? commentsResult.value.data?.comments || [] : [];
+                const unresolved = comments.filter((c) => !c.resolved_at);
+                const summary = {
+                    name: fileData.name,
+                    last_modified: fileData.lastModified,
+                    version: fileData.version,
+                    pages,
+                    component_count: components.length,
+                    style_count: styles.length,
+                    comment_count: comments.length,
+                    unresolved_comment_count: unresolved.length,
+                };
+                return toolResult(JSON.stringify(summary, null, 2));
+            }
+            catch (e) {
+                return toolError(`Failed to summarize file: ${e.response?.status || e.message}`);
+            }
+        });
+    },
+});
+// -- workspace_overview --
+defineTool({
+    toolset: 'compound',
+    auth: 'cookie',
+    register(server, config) {
+        server.registerTool('workspace_overview', {
+            description: 'Full org snapshot: teams with member/project counts, seat breakdown, and billing summary.',
+            inputSchema: {
+                org_id: figmaId.optional().describe('Org ID override (defaults to current workspace)'),
+            },
+        }, async ({ org_id }) => {
+            try {
+                let orgId;
+                try {
+                    orgId = requireOrgId(config, org_id);
+                }
+                catch (e) {
+                    return toolError(e.message);
+                }
+                const api = internalClient(config);
+                const [teamsResult, seatsResult, billingResult] = await Promise.allSettled([
+                    api.get(`/api/orgs/${orgId}/teams`, {
+                        params: { include_member_count: true, include_project_count: true, include_top_members: true },
+                    }),
+                    api.get(`/api/orgs/${orgId}/org_users/filter_counts`),
+                    api.get(`/api/orgs/${orgId}/billing_data`),
+                ]);
+                const teamsData = teamsResult.status === 'fulfilled' ? (teamsResult.value.data?.meta || teamsResult.value.data) : null;
+                const teamsRaw = teamsData ? (Array.isArray(teamsData) ? teamsData : (teamsData?.teams || [])) : [];
+                const teams = teamsRaw.map((t) => ({
+                    id: String(t.id),
+                    name: t.name,
+                    members: t.member_count || 0,
+                    projects: t.project_count || 0,
+                }));
+                const seats = seatsResult.status === 'fulfilled' ? (seatsResult.value.data?.meta || seatsResult.value.data) : null;
+                const rawBilling = billingResult.status === 'fulfilled' ? (billingResult.value.data?.meta || billingResult.value.data) : null;
+                // Strip PII from billing data
+                const billing = rawBilling ? { ...rawBilling } : null;
+                if (billing)
+                    delete billing.shipping_address;
+                const errors = [];
+                if (teamsResult.status === 'rejected')
+                    errors.push(`teams: ${teamsResult.reason?.response?.status || teamsResult.reason?.message}`);
+                if (seatsResult.status === 'rejected')
+                    errors.push(`seats: ${seatsResult.reason?.response?.status || seatsResult.reason?.message}`);
+                if (billingResult.status === 'rejected')
+                    errors.push(`billing: ${billingResult.reason?.response?.status || billingResult.reason?.message}`);
+                const overview = { teams, seats, billing };
+                if (errors.length > 0)
+                    overview.errors = errors;
+                return toolResult(JSON.stringify(overview, null, 2));
+            }
+            catch (e) {
+                return toolError(`Failed to fetch workspace overview: ${e.response?.status || e.message}`);
+            }
+        });
+    },
+});
+// -- open_comments --
+defineTool({
+    toolset: 'compound',
+    auth: 'pat',
+    register(server, config) {
+        server.registerTool('open_comments', {
+            description: 'Aggregated unresolved comments across all files in a project. Checks up to 20 files.',
+            inputSchema: {
+                project_id: figmaId.describe('Project ID'),
+            },
+        }, async ({ project_id }) => {
+            try {
+                const api = publicClient(config);
+                const filesRes = await api.get(`/v1/projects/${project_id}/files`);
+                const allFiles = filesRes.data?.files || [];
+                const capped = allFiles.length > 20;
+                const files = allFiles.slice(0, 20);
+                const commentResults = [];
+                for (const f of files) {
+                    try {
+                        const commentsRes = await api.get(`/v1/files/${f.key}/comments`);
+                        const comments = (commentsRes.data?.comments || [])
+                            .filter((c) => !c.resolved_at);
+                        commentResults.push({ file_key: f.key, file_name: f.name, comments });
+                    }
+                    catch (e) {
+                        commentResults.push({ file_key: f.key, file_name: f.name, comments: [], error: e.response?.status || e.message });
+                    }
+                }
+                const filesWithComments = commentResults
+                    .filter(f => f.comments.length > 0)
+                    .map(f => ({
+                    file_key: f.file_key,
+                    file_name: f.file_name,
+                    comments: f.comments.map((c) => ({
+                        id: c.id,
+                        author: c.user?.handle || c.user?.email || 'unknown',
+                        message: c.message,
+                        created_at: c.created_at,
+                    })),
+                }));
+                const totalUnresolved = filesWithComments.reduce((sum, f) => sum + f.comments.length, 0);
+                const errors = commentResults
+                    .filter((f) => f.error)
+                    .map((f) => ({ file_key: f.file_key, file_name: f.file_name, error: f.error }));
+                const result = {
+                    total_unresolved: totalUnresolved,
+                    files: filesWithComments,
+                };
+                if (errors.length > 0) {
+                    result.errors = errors;
+                }
+                if (capped) {
+                    result.note = `Project has ${allFiles.length} files; only the first 20 were checked.`;
+                }
+                return toolResult(JSON.stringify(result, null, 2));
+            }
+            catch (e) {
+                return toolError(`Failed to fetch open comments: ${e.response?.status || e.message}`);
+            }
+        });
+    },
+});
+// -- cleanup_stale_files --
+defineTool({
+    toolset: 'compound',
+    auth: 'either',
+    mutates: true,
+    destructive: true,
+    register(server, config) {
+        server.registerTool('cleanup_stale_files', {
+            description: 'Find files not modified in N days and optionally trash them. Defaults to dry run.',
+            inputSchema: {
+                project_id: figmaId.describe('Project ID'),
+                days_stale: z.number().optional().default(90).describe('Days since last modification (default: 90)'),
+                dry_run: z.boolean().optional().default(true).describe('Preview only, no deletion (default: true)'),
+            },
+        }, async ({ project_id, days_stale, dry_run: rawDryRun }) => {
+            try {
+                const dry_run = rawDryRun ?? true;
+                if (!dry_run && !hasCookie(config)) {
+                    return toolError('Cookie auth required to trash files. Run with dry_run=true to preview, or configure cookie auth.');
+                }
+                let files;
+                if (hasPat(config)) {
+                    const res = await publicClient(config).get(`/v1/projects/${project_id}/files`);
+                    files = res.data?.files || [];
+                }
+                else {
+                    const res = await internalClient(config).get(`/api/folders/${project_id}/paginated_files`, { params: { folderId: project_id, sort_column: 'touched_at', sort_order: 'desc', page_size: 100, file_type: '' } });
+                    const meta = res.data?.meta || res.data;
+                    files = meta?.files || meta || [];
+                }
+                const cutoff = Date.now() - days_stale * 86400000;
+                const staleFiles = files.filter((f) => {
+                    const raw = f.last_modified || f.touched_at;
+                    if (!raw)
+                        return false;
+                    const modified = new Date(raw).getTime();
+                    return !isNaN(modified) && modified < cutoff;
+                });
+                const MAX_TRASH_BATCH = 25;
+                const result = {
+                    stale_files: staleFiles.map((f) => ({
+                        key: f.key,
+                        name: f.name,
+                        last_modified: f.last_modified || f.touched_at,
+                    })),
+                    total_stale: staleFiles.length,
+                    dry_run,
+                    trashed: false,
+                };
+                if (!dry_run) {
+                    if (staleFiles.length > MAX_TRASH_BATCH) {
+                        return toolError(`${staleFiles.length} stale files exceeds safety limit of ${MAX_TRASH_BATCH}. ` +
+                            `Run with dry_run=true to review, then trash in smaller batches using trash_files.`);
+                    }
+                    if (staleFiles.length > 0) {
+                        await internalClient(config).delete('/api/files_batch', {
+                            data: { files: staleFiles.map((f) => ({ key: f.key })), trashed: true },
+                        });
+                        result.trashed = true;
+                    }
+                }
+                return toolResult(JSON.stringify(result, null, 2));
+            }
+            catch (e) {
+                return toolError(`Failed to cleanup stale files: ${e.response?.status || e.message}`);
+            }
+        });
+    },
+});
+// -- organize_project --
+defineTool({
+    toolset: 'compound',
+    auth: 'cookie',
+    mutates: true,
+    register(server, config) {
+        server.registerTool('organize_project', {
+            description: 'Move multiple files into a target project in a single batch.',
+            inputSchema: {
+                file_keys: z.array(figmaId).min(1).describe('File keys to move'),
+                target_project_id: figmaId.describe('Destination project ID'),
+            },
+        }, async ({ file_keys, target_project_id }) => {
+            try {
+                const payload = {
+                    files: file_keys.map(key => ({
+                        key,
+                        folder_id: target_project_id,
+                        is_multi_move: true,
+                        restore_files: false,
+                    })),
+                };
+                const res = await internalClient(config).put('/api/files_batch', payload);
+                const data = res.data?.meta || res.data;
+                const moved = Object.keys(data?.success || {}).length;
+                const failed = Object.keys(data?.errors || {}).length;
+                const result = {
+                    moved: moved || (failed === 0 ? file_keys.length : 0),
+                    failed,
+                    errors: data?.errors || {},
+                };
+                return toolResult(JSON.stringify(result, null, 2));
+            }
+            catch (e) {
+                return toolError(`Failed to organize project: ${e.response?.status || e.message}`);
+            }
+        });
+    },
+});
+// -- setup_project_structure --
+defineTool({
+    toolset: 'compound',
+    auth: 'cookie',
+    mutates: true,
+    register(server, config) {
+        server.registerTool('setup_project_structure', {
+            description: 'Create multiple projects in a team from a plan. Optionally set descriptions.',
+            inputSchema: {
+                team_id: figmaId.describe('Team ID'),
+                projects: z.array(z.object({
+                    name: z.string().describe('Project name'),
+                    description: z.string().optional().describe('Project description'),
+                })).min(1).describe('Projects to create'),
+            },
+        }, async ({ team_id, projects }) => {
+            try {
+                const api = internalClient(config);
+                const created = [];
+                const failed = [];
+                for (const project of projects) {
+                    try {
+                        const createRes = await api.post('/api/folders', {
+                            team_id,
+                            path: project.name,
+                            sharing_audience_control: 'org_view',
+                            team_access: 'team_edit',
+                        });
+                        const meta = createRes.data?.meta;
+                        const p = Array.isArray(meta) ? meta[0] : (meta?.folder || meta || createRes.data);
+                        const folderId = p?.id != null ? String(p.id) : null;
+                        if (!folderId) {
+                            failed.push({ name: project.name, error: 'Could not extract project ID from response' });
+                            continue;
+                        }
+                        if (project.description) {
+                            await api.put(`/api/folders/${folderId}`, { description: project.description });
+                        }
+                        created.push({ id: folderId, name: project.name, description: project.description || null });
+                    }
+                    catch (e) {
+                        failed.push({ name: project.name, error: e.response?.status || e.message });
+                    }
+                }
+                return toolResult(JSON.stringify({ created, failed }, null, 2));
+            }
+            catch (e) {
+                return toolError(`Failed to setup project structure: ${e.response?.status || e.message}`);
+            }
+        });
+    },
+});
+//# sourceMappingURL=compound.js.map

package/dist/tools/export.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=export.d.ts.map

package/dist/tools/export.js

@@ -0,0 +1,70 @@
+import { z } from 'zod';
+import { publicClient } from '../clients/public-api.js';
+import { defineTool, toolResult, toolError, figmaId } from './register.js';
+// -- export_nodes --
+defineTool({
+    toolset: 'export',
+    auth: 'pat',
+    register(server, config) {
+        server.registerTool('export_nodes', {
+            description: 'Export specific nodes from a file as images. Returns temporary URLs (valid ~14 days).',
+            inputSchema: {
+                file_key: figmaId.describe('File key'),
+                node_ids: z.array(figmaId).min(1).describe('Node IDs to export (e.g. ["1:2", "3:4"])'),
+                format: z.enum(['png', 'svg', 'pdf', 'jpg']).optional().describe('Image format (default: png)'),
+                scale: z.number().optional().describe('Scale factor, 0.01-4 (default: 1)'),
+            },
+        }, async ({ file_key, node_ids, format, scale }) => {
+            try {
+                const params = {
+                    ids: node_ids.join(','),
+                    format: format || 'png',
+                };
+                if (scale)
+                    params.scale = String(Math.min(Math.max(scale, 0.01), 4));
+                const res = await publicClient(config).get(`/v1/images/${file_key}`, { params });
+                const images = res.data?.images || {};
+                const err = res.data?.err;
+                if (err)
+                    return toolError(`Export error: ${err}`);
+                const results = Object.entries(images).map(([nodeId, url]) => ({
+                    node_id: nodeId,
+                    url,
+                }));
+                return toolResult(JSON.stringify(results, null, 2));
+            }
+            catch (e) {
+                return toolError(`Failed to export nodes: ${e.response?.status || e.message}`);
+            }
+        });
+    },
+});
+// -- get_image_fills --
+defineTool({
+    toolset: 'export',
+    auth: 'pat',
+    register(server, config) {
+        server.registerTool('get_image_fills', {
+            description: 'Get download URLs for all images used as fills in a file.',
+            inputSchema: {
+                file_key: figmaId.describe('File key'),
+            },
+        }, async ({ file_key }) => {
+            try {
+                const res = await publicClient(config).get(`/v1/files/${file_key}/images`);
+                const images = res.data?.meta?.images || res.data?.images || {};
+                const results = Object.entries(images).map(([ref, url]) => ({
+                    image_ref: ref,
+                    url,
+                }));
+                if (results.length === 0)
+                    return toolResult('No image fills in this file.');
+                return toolResult(JSON.stringify(results, null, 2));
+            }
+            catch (e) {
+                return toolError(`Failed to get image fills: ${e.response?.status || e.message}`);
+            }
+        });
+    },
+});
+//# sourceMappingURL=export.js.map

package/dist/tools/files.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=files.d.ts.map

package/dist/tools/files.js

@@ -0,0 +1,241 @@
+import { z } from 'zod';
+import { internalClient } from '../clients/internal-api.js';
+import { defineTool, toolResult, toolError, figmaId, resolveOrgId } from './register.js';
+// -- create_file --
+defineTool({
+    toolset: 'files',
+    auth: 'cookie',
+    mutates: true,
+    register(server, config) {
+        server.registerTool('create_file', {
+            description: 'Create a new Figma file in a project. Supports design, whiteboard, slides, sites.',
+            inputSchema: {
+                project_id: figmaId.describe('Project (folder) ID to create the file in'),
+                editor_type: z.enum(['design', 'whiteboard', 'slides', 'sites']).optional().describe('File type (default: design)'),
+                org_id: figmaId.optional().describe('Org ID override (defaults to current workspace)'),
+            },
+        }, async ({ project_id, editor_type, org_id }) => {
+            try {
+                const res = await internalClient(config).post('/api/files/create', {
+                    folder_id: project_id,
+                    org_id: resolveOrgId(config, org_id),
+                    editor_type: editor_type || 'design',
+                });
+                const f = res.data?.meta?.fig_file || res.data?.meta || res.data;
+                return toolResult(JSON.stringify({
+                    key: f.key,
+                    name: f.name,
+                    editor_type: f.editor_type,
+                    url: `https://www.figma.com/design/${f.key}`,
+                }, null, 2));
+            }
+            catch (e) {
+                return toolError(`Failed to create file: ${e.response?.status || e.message}`);
+            }
+        });
+    },
+});
+// -- rename_file --
+defineTool({
+    toolset: 'files',
+    auth: 'cookie',
+    mutates: true,
+    register(server, config) {
+        server.registerTool('rename_file', {
+            description: 'Rename a Figma file.',
+            inputSchema: {
+                file_key: figmaId.describe('File key'),
+                name: z.string().describe('New name'),
+            },
+        }, async ({ file_key, name }) => {
+            try {
+                await internalClient(config).put(`/api/files/${file_key}`, {
+                    key: file_key,
+                    name,
+                });
+                return toolResult(`Renamed to "${name}"`);
+            }
+            catch (e) {
+                return toolError(`Failed to rename file: ${e.response?.status || e.message}`);
+            }
+        });
+    },
+});
+// -- move_files --
+defineTool({
+    toolset: 'files',
+    auth: 'cookie',
+    mutates: true,
+    register(server, config) {
+        server.registerTool('move_files', {
+            description: 'Move one or more files to a different project. Supports batch moves.',
+            inputSchema: {
+                file_keys: z.array(figmaId).min(1).describe('Array of file keys to move'),
+                destination_project_id: figmaId.describe('Destination project (folder) ID'),
+            },
+        }, async ({ file_keys, destination_project_id }) => {
+            try {
+                const files = file_keys.map(key => ({
+                    key,
+                    folder_id: destination_project_id,
+                    is_multi_move: file_keys.length > 1,
+                    restore_files: false,
+                }));
+                const res = await internalClient(config).put('/api/files_batch', { files });
+                const data = res.data?.meta || res.data;
+                const succeeded = Object.keys(data.success || {}).length;
+                const failed = Object.keys(data.errors || {}).length;
+                let msg = `Moved ${succeeded} file(s) to project ${destination_project_id}`;
+                if (failed > 0)
+                    msg += `. ${failed} failed: ${JSON.stringify(data.errors)}`;
+                return toolResult(msg);
+            }
+            catch (e) {
+                return toolError(`Failed to move files: ${e.response?.status || e.message}`);
+            }
+        });
+    },
+});
+// -- duplicate_file --
+defineTool({
+    toolset: 'files',
+    auth: 'cookie',
+    mutates: true,
+    register(server, config) {
+        server.registerTool('duplicate_file', {
+            description: 'Duplicate a file. Optionally specify a destination project.',
+            inputSchema: {
+                file_key: figmaId.describe('File key to duplicate'),
+                project_id: figmaId.optional().describe('Destination project ID (optional, defaults to same project)'),
+            },
+        }, async ({ file_key, project_id }) => {
+            try {
+                const res = await internalClient(config).post(`/api/multiplayer/${file_key}/copy`, null, {
+                    headers: { 'Content-Length': '0' },
+                    params: project_id ? { folder_id: project_id } : undefined,
+                });
+                const f = res.data?.meta?.fig_file || res.data?.meta || res.data;
+                return toolResult(JSON.stringify({
+                    key: f.key,
+                    name: f.name,
+                    url: `https://www.figma.com/design/${f.key}`,
+                }, null, 2));
+            }
+            catch (e) {
+                return toolError(`Failed to duplicate file: ${e.response?.status || e.message}`);
+            }
+        });
+    },
+});
+// -- trash_files --
+defineTool({
+    toolset: 'files',
+    auth: 'cookie',
+    mutates: true,
+    destructive: true,
+    register(server, config) {
+        server.registerTool('trash_files', {
+            description: 'Move files to trash. Supports batch operations.',
+            inputSchema: {
+                file_keys: z.array(figmaId).min(1).describe('Array of file keys to trash'),
+            },
+        }, async ({ file_keys }) => {
+            try {
+                const files = file_keys.map(key => ({ key }));
+                const res = await internalClient(config).delete('/api/files_batch', {
+                    data: { files, trashed: true },
+                });
+                const data = res.data?.meta || res.data;
+                const succeeded = Object.keys(data.success || {}).length;
+                return toolResult(`Trashed ${succeeded} file(s)`);
+            }
+            catch (e) {
+                return toolError(`Failed to trash files: ${e.response?.status || e.message}`);
+            }
+        });
+    },
+});
+// -- restore_files --
+defineTool({
+    toolset: 'files',
+    auth: 'cookie',
+    mutates: true,
+    register(server, config) {
+        server.registerTool('restore_files', {
+            description: 'Restore files from trash.',
+            inputSchema: {
+                file_keys: z.array(figmaId).min(1).describe('Array of file keys to restore'),
+            },
+        }, async ({ file_keys }) => {
+            try {
+                const files = file_keys.map(key => ({ key }));
+                const res = await internalClient(config).post('/api/files_batch/restore', { files });
+                const data = res.data?.meta || res.data;
+                const succeeded = Object.keys(data?.success || {}).length || file_keys.length;
+                const failed = Object.keys(data?.errors || {}).length;
+                let msg = `Restored ${succeeded} file(s)`;
+                if (failed > 0)
+                    msg += `. ${failed} failed: ${JSON.stringify(data.errors)}`;
+                return toolResult(msg);
+            }
+            catch (e) {
+                return toolError(`Failed to restore files: ${e.response?.status || e.message}`);
+            }
+        });
+    },
+});
+// -- favorite_file --
+defineTool({
+    toolset: 'files',
+    auth: 'cookie',
+    mutates: true,
+    register(server, config) {
+        server.registerTool('favorite_file', {
+            description: 'Add or remove a file from your sidebar favorites.',
+            inputSchema: {
+                file_key: figmaId.describe('File key'),
+                favorited: z.boolean().optional().describe('true to favorite, false to unfavorite (default: true)'),
+            },
+        }, async ({ file_key, favorited }) => {
+            try {
+                const isFavorited = favorited !== false;
+                await internalClient(config).put('/api/favorited_resources', {
+                    resource_type: 'file',
+                    resource_id_or_key: file_key,
+                    is_favorited: isFavorited,
+                });
+                return toolResult(`${isFavorited ? 'Favorited' : 'Unfavorited'} file ${file_key}`);
+            }
+            catch (e) {
+                return toolError(`Failed to toggle favorite: ${e.response?.status || e.message}`);
+            }
+        });
+    },
+});
+// -- set_link_access --
+defineTool({
+    toolset: 'files',
+    auth: 'cookie',
+    mutates: true,
+    register(server, config) {
+        server.registerTool('set_link_access', {
+            description: 'Set link access on a file. Use "inherit" to remove custom access and fall back to project/team defaults.',
+            inputSchema: {
+                file_key: figmaId.describe('File key'),
+                link_access: z.enum(['inherit', 'view', 'edit', 'org_view', 'org_edit']).optional().describe('Link access level (default: inherit)'),
+            },
+        }, async ({ file_key, link_access }) => {
+            try {
+                const res = await internalClient(config).put(`/api/files/${file_key}`, {
+                    link_access: link_access || 'inherit',
+                });
+                const newAccess = res.data?.meta?.link_access || link_access || 'inherit';
+                return toolResult(`Set link access to "${newAccess}" on file ${file_key}`);
+            }
+            catch (e) {
+                return toolError(`Failed to set link access: ${e.response?.status || e.message}`);
+            }
+        });
+    },
+});
+//# sourceMappingURL=files.js.map

package/dist/tools/libraries.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=libraries.d.ts.map