@popoverai/dotrequirements 0.11.0

package/dist/mcp/requirements.d.ts

@@ -0,0 +1,47 @@
+import { type RequirementNode, type Metadata } from '../schema/index.js';
+import type { FlattenedRequirement } from './types.js';
+/**
+ * Parsed requirements file
+ */
+export interface ParsedRequirementsFile {
+    metadata: Metadata;
+    requirements: RequirementNode[];
+}
+/**
+ * Find all *.requirements.md files in the workspace.
+ * Supports both .requirements/ directories and colocated files.
+ * Excludes example files, test fixtures, and build artifacts.
+ */
+export declare function findRequirementsFiles(workspaceRoot: string): Promise<string[]>;
+/**
+ * Load all requirements from the workspace
+ */
+export declare function loadAllRequirements(workspaceRoot: string): Promise<{
+    files: ParsedRequirementsFile[];
+    flattened: FlattenedRequirement[];
+}>;
+/**
+ * Flatten a requirements file into searchable requirements
+ */
+export declare function flattenRequirementsFile(file: ParsedRequirementsFile, sourceFile: string): FlattenedRequirement[];
+/**
+ * Search requirements by text query
+ */
+export declare function searchRequirements(requirements: FlattenedRequirement[], query: string): FlattenedRequirement[];
+/**
+ * Get a specific requirement by ID (supports partial matching)
+ */
+export declare function getRequirementById(requirements: FlattenedRequirement[], id: string): FlattenedRequirement | undefined;
+/**
+ * Get a requirement and all its children
+ */
+export declare function getRequirementTree(requirements: FlattenedRequirement[], rootId: string): FlattenedRequirement[];
+/**
+ * Format a requirement for display
+ */
+export declare function formatRequirement(req: FlattenedRequirement): string;
+/**
+ * Format a requirement tree for display
+ */
+export declare function formatRequirementTree(requirements: FlattenedRequirement[]): string;
+//# sourceMappingURL=requirements.d.ts.map

package/dist/mcp/requirements.js

@@ -0,0 +1,141 @@
+import * as path from 'path';
+import { glob } from 'glob';
+import { parseRequirementsFromFile, getAllRequirements, } from '../schema/index.js';
+/**
+ * Find all *.requirements.md files in the workspace.
+ * Supports both .requirements/ directories and colocated files.
+ * Excludes example files, test fixtures, and build artifacts.
+ */
+export async function findRequirementsFiles(workspaceRoot) {
+    const pattern = '**/*.requirements.md';
+    const matches = await glob(pattern, {
+        cwd: workspaceRoot,
+        ignore: [
+            '**/node_modules/**',
+            '**/dist/**',
+            '**/.git/**',
+            '**/build/**',
+            // Exclude example and test fixture directories
+            '**/example/**',
+            '**/examples/**',
+            '**/__tests__/**',
+            '**/fixtures/**',
+            '**/.fixtures/**',
+        ],
+        dot: true, // Include dotfiles/dotdirs like .requirements/
+    });
+    return matches.map(m => path.join(workspaceRoot, m));
+}
+/**
+ * Load all requirements from the workspace
+ */
+export async function loadAllRequirements(workspaceRoot) {
+    const filePaths = await findRequirementsFiles(workspaceRoot);
+    const allFiles = [];
+    const allFlattened = [];
+    for (const filePath of filePaths) {
+        try {
+            const parsed = parseRequirementsFromFile(filePath);
+            allFiles.push(parsed);
+            const flattened = flattenRequirementsFile(parsed, filePath);
+            allFlattened.push(...flattened);
+        }
+        catch (error) {
+            // Skip invalid files
+            console.error(`Failed to parse ${filePath}:`, error);
+        }
+    }
+    return { files: allFiles, flattened: allFlattened };
+}
+/**
+ * Flatten a requirements file into searchable requirements
+ */
+export function flattenRequirementsFile(file, sourceFile) {
+    const results = [];
+    // Use shared utility to get all requirements (flattened)
+    const allReqs = getAllRequirements(file.requirements);
+    for (const req of allReqs) {
+        // Extract position from ID (e.g., "REQ123.0.1" -> "0.1")
+        const idParts = req.id.split('.');
+        const rootId = idParts[0];
+        const position = idParts.slice(1).join('.');
+        results.push({
+            id: req.id,
+            rootId: rootId,
+            label: req.label,
+            content: req.content,
+            path: idParts.slice(1), // ["0", "1"] for "REQ123.0.1"
+            sourceFile: sourceFile,
+            documentTitle: file.metadata.document?.title || rootId,
+        });
+    }
+    return results;
+}
+/**
+ * Search requirements by text query
+ */
+export function searchRequirements(requirements, query) {
+    const lowerQuery = query.toLowerCase();
+    return requirements.filter(req => {
+        // Search in ID
+        if (req.id.toLowerCase().includes(lowerQuery))
+            return true;
+        // Search in content
+        if (req.content.toLowerCase().includes(lowerQuery))
+            return true;
+        // Search in label
+        if (req.label.toLowerCase().includes(lowerQuery))
+            return true;
+        return false;
+    });
+}
+/**
+ * Get a specific requirement by ID (supports partial matching)
+ */
+export function getRequirementById(requirements, id) {
+    // Exact match first
+    const exact = requirements.find(r => r.id === id);
+    if (exact)
+        return exact;
+    // Try partial match (just the root ID)
+    return requirements.find(r => r.rootId === id || r.id.startsWith(id + '.'));
+}
+/**
+ * Get a requirement and all its children
+ */
+export function getRequirementTree(requirements, rootId) {
+    return requirements.filter(r => r.rootId === rootId || r.id === rootId);
+}
+/**
+ * Format a requirement for display
+ */
+export function formatRequirement(req) {
+    const indent = '  '.repeat(req.path.length);
+    const label = req.label ? ` (${req.label})` : '';
+    return `${indent}${req.id}${label}: ${req.content}`;
+}
+/**
+ * Format a requirement tree for display
+ */
+export function formatRequirementTree(requirements) {
+    // Sort by path to maintain hierarchy - children appear immediately after parent
+    const sorted = [...requirements].sort((a, b) => {
+        // Compare paths element by element for proper tree order
+        const maxLen = Math.max(a.path.length, b.path.length);
+        for (let i = 0; i < maxLen; i++) {
+            const aVal = i < a.path.length ? parseInt(a.path[i]) : -1;
+            const bVal = i < b.path.length ? parseInt(b.path[i]) : -1;
+            // If one path is a prefix of the other, the shorter one comes first
+            if (aVal === -1)
+                return -1;
+            if (bVal === -1)
+                return 1;
+            if (aVal !== bVal) {
+                return aVal - bVal;
+            }
+        }
+        return 0;
+    });
+    return sorted.map(formatRequirement).join('\n');
+}
+//# sourceMappingURL=requirements.js.map

package/dist/mcp/testCodeExtractor.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Extract test code context using @babel/parser AST traversal.
+ *
+ * Finds requirement() call references and extracts the enclosing
+ * meaningful code block (function, describe, test, etc.)
+ */
+export interface TestCodeReference {
+    file: string;
+    startLine: number;
+    endLine: number;
+    code: string;
+    requirementId: string;
+}
+/**
+ * Find all test code blocks that reference a specific requirement
+ */
+export declare function findTestCodeForRequirement(filePath: string, requirementId: string): TestCodeReference[];
+/**
+ * Find all files that reference a requirement
+ */
+export declare function findFilesWithRequirement(files: string[], requirementId: string): string[];
+//# sourceMappingURL=testCodeExtractor.d.ts.map

package/dist/mcp/testCodeExtractor.js

@@ -0,0 +1,152 @@
+/**
+ * Extract test code context using @babel/parser AST traversal.
+ *
+ * Finds requirement() call references and extracts the enclosing
+ * meaningful code block (function, describe, test, etc.)
+ */
+import { parse } from '@babel/parser';
+import traverse from '@babel/traverse';
+import * as t from '@babel/types';
+import * as fs from 'fs';
+/**
+ * Find all test code blocks that reference a specific requirement
+ */
+export function findTestCodeForRequirement(filePath, requirementId) {
+    try {
+        const code = fs.readFileSync(filePath, 'utf-8');
+        const results = [];
+        // Parse with TypeScript and JSX support
+        const ast = parse(code, {
+            sourceType: 'module',
+            plugins: ['typescript', 'jsx'],
+            errorRecovery: true,
+        });
+        // Handle both ES module and CommonJS exports
+        const traverseFunc = typeof traverse === 'function' ? traverse : traverse.default;
+        traverseFunc(ast, {
+            CallExpression(path) {
+                // Check if this is a requirement('ID', ...) call
+                const callee = path.node.callee;
+                if (t.isIdentifier(callee) && callee.name === 'requirement') {
+                    const args = path.node.arguments;
+                    // Extract all string literal arguments (supports multi-requirement calls)
+                    const refIds = [];
+                    for (const arg of args) {
+                        if (t.isStringLiteral(arg)) {
+                            refIds.push(arg.value);
+                        }
+                    }
+                    // Check if any argument matches the requirement we're looking for
+                    // Match exact ID or if it's a child (e.g., searching for REQ-123 matches REQ-123.0)
+                    for (const refId of refIds) {
+                        const isMatch = refId === requirementId ||
+                            refId.startsWith(`${requirementId}.`);
+                        if (isMatch) {
+                            // Find the meaningful enclosing block
+                            const contextNode = findMeaningfulParent(path);
+                            if (contextNode && contextNode.node.loc) {
+                                const { start, end } = contextNode.node.loc;
+                                const nodeStart = contextNode.node.start ?? 0;
+                                const nodeEnd = contextNode.node.end ?? code.length;
+                                results.push({
+                                    file: filePath,
+                                    startLine: start.line,
+                                    endLine: end.line,
+                                    code: code.slice(nodeStart, nodeEnd),
+                                    requirementId: refId,
+                                });
+                            }
+                            // Only add one result per call expression, even if multiple refs match
+                            break;
+                        }
+                    }
+                }
+            },
+        });
+        return results;
+    }
+    catch (error) {
+        console.error(`Error parsing ${filePath}:`, error);
+        return [];
+    }
+}
+/**
+ * Walk up the AST to find the nearest "meaningful" parent node.
+ * This could be a function, describe/test/it call, method, etc.
+ */
+function findMeaningfulParent(path) {
+    let current = path;
+    while (current) {
+        const node = current.node;
+        // Check for various meaningful boundaries
+        if (t.isFunctionDeclaration(node) ||
+            t.isFunctionExpression(node) ||
+            t.isArrowFunctionExpression(node) ||
+            t.isClassMethod(node) ||
+            t.isObjectMethod(node)) {
+            return current;
+        }
+        // Check for call expressions (describe, test, it, etc.)
+        if (t.isCallExpression(node)) {
+            const callee = node.callee;
+            // Common test framework function names
+            const testFunctionNames = [
+                'describe',
+                'it',
+                'test',
+                'suite',
+                'context',
+                'beforeEach',
+                'afterEach',
+                'beforeAll',
+                'afterAll',
+            ];
+            if (t.isIdentifier(callee) && testFunctionNames.includes(callee.name)) {
+                return current;
+            }
+        }
+        // Check for variable declarations that might contain test functions
+        if (t.isVariableDeclarator(node)) {
+            return current;
+        }
+        // Check for export declarations (for Storybook stories, etc.)
+        if (t.isExportNamedDeclaration(node) ||
+            t.isExportDefaultDeclaration(node)) {
+            return current;
+        }
+        current = current.parentPath;
+    }
+    return null;
+}
+/**
+ * Find all files that reference a requirement
+ */
+export function findFilesWithRequirement(files, requirementId) {
+    const matchingFiles = [];
+    for (const file of files) {
+        try {
+            const code = fs.readFileSync(file, 'utf-8');
+            // Check for exact match or child references (e.g., AUTH-VALID-LOGIN or AUTH-VALID-LOGIN.0)
+            // Simple string search first for performance
+            // Patterns match both single and multi-arg calls:
+            //   requirement('REQ-123')
+            //   requirement('REQ-123', 'REQ-456')
+            //   requirement('REQ-456', 'REQ-123')  <-- ID anywhere in args
+            const hasMatch = code.includes(`'${requirementId}'`) ||
+                code.includes(`"${requirementId}"`) ||
+                code.includes(`\`${requirementId}\``) ||
+                code.includes(`'${requirementId}.`) ||
+                code.includes(`"${requirementId}.`) ||
+                code.includes(`\`${requirementId}.`);
+            if (hasMatch) {
+                matchingFiles.push(file);
+            }
+        }
+        catch (error) {
+            // Skip files that can't be read
+            continue;
+        }
+    }
+    return matchingFiles;
+}
+//# sourceMappingURL=testCodeExtractor.js.map

package/dist/mcp/types.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Re-export shared types from CLI schema module
+ */
+export type { Metadata, RequirementNode, RequirementsFile, } from '../schema/index.js';
+/**
+ * Flattened requirement for search results
+ */
+export interface FlattenedRequirement {
+    id: string;
+    rootId: string;
+    label: string;
+    content: string;
+    path: string[];
+    sourceFile: string;
+    documentTitle: string;
+}
+/**
+ * Test reference found in codebase
+ */
+export interface TestReference {
+    file: string;
+    line: number;
+    column: number;
+    requirementId: string;
+    context: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/mcp/types.js

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

package/dist/schema/browser.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Browser-safe exports from the schema module.
+ * This file excludes Node.js-specific functionality (file I/O, fs module).
+ * Use this entry point when importing from browser/web environments.
+ */
+export { MetadataSchema, RequirementNodeSchema, RequirementsFileSchema, ParsedCriterionSchema, RequirementPrefixSchema, RequirementKeySchema, REQUIREMENT_PREFIX_PATTERN, REQUIREMENT_KEY_PATTERN, ValidationError, validateMetadata, validateRequirementNode, validateRequirementsFile, validatePrefix, validateKey, normalizePrefix, parseRequirementKey, buildRequirementKey, } from './schemas.js';
+export type { Metadata, RequirementNode, RequirementsFile, ParsedCriterion, RequirementPrefix, RequirementKey, } from './schemas.js';
+export { DEFAULT_DELIMITER, buildRequirementsMarkdown, buildRequirementMarkdown, } from './builder.js';
+export type { ConvexRequirement, } from './conversions.js';
+export { convexToRequirements, requirementsToConvex, buildMetadata, extractRequirementKeys, groupByRoot, constructKey, parseKey, } from './conversions.js';
+export { DELIMITER_PATTERN, parseCriterionLine, parseRootLine, parseRequirementBlock, extractRequirementBlocks, parseRequirementBlocksFromMarkdown, flattenRequirementTree, findRequirementById, getAllRequirements, } from './parser-core.js';
+//# sourceMappingURL=browser.d.ts.map

package/dist/schema/browser.js

@@ -0,0 +1,24 @@
+/**
+ * Browser-safe exports from the schema module.
+ * This file excludes Node.js-specific functionality (file I/O, fs module).
+ * Use this entry point when importing from browser/web environments.
+ */
+// Schemas and types (uses zod - browser-safe)
+export { 
+// Zod schemas
+MetadataSchema, RequirementNodeSchema, RequirementsFileSchema, ParsedCriterionSchema, RequirementPrefixSchema, RequirementKeySchema, 
+// Patterns (for external validation)
+REQUIREMENT_PREFIX_PATTERN, REQUIREMENT_KEY_PATTERN, 
+// Validation
+ValidationError, validateMetadata, validateRequirementNode, validateRequirementsFile, validatePrefix, validateKey, 
+// Prefix/key utilities
+normalizePrefix, parseRequirementKey, buildRequirementKey, } from './schemas.js';
+// Building (uses yaml package - browser-safe)
+export { DEFAULT_DELIMITER, buildRequirementsMarkdown, buildRequirementMarkdown, } from './builder.js';
+export { convexToRequirements, requirementsToConvex, buildMetadata, extractRequirementKeys, groupByRoot, constructKey, parseKey, } from './conversions.js';
+// Parser core (pure TypeScript - browser-safe, no fs dependency)
+// These functions parse markdown strings directly without file I/O
+export { DELIMITER_PATTERN, parseCriterionLine, parseRootLine, parseRequirementBlock, extractRequirementBlocks, parseRequirementBlocksFromMarkdown, flattenRequirementTree, findRequirementById, getAllRequirements, } from './parser-core.js';
+// NOTE: parser.ts and resolver.ts are excluded because they use Node.js 'fs' module.
+// Use parser-core.ts functions above for browser/Convex environments.
+//# sourceMappingURL=browser.js.map

package/dist/schema/builder.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Build Markdown requirements files from structured data.
+ */
+import { RequirementNode, Metadata } from './schemas.js';
+/**
+ * Default delimiter for requirements.
+ * Can be overridden for organization-specific preferences.
+ */
+export declare const DEFAULT_DELIMITER = "\u2192";
+/**
+ * Build complete Markdown requirements document.
+ */
+export declare function buildRequirementsMarkdown(metadata: Metadata, requirements: RequirementNode[], documentTitle?: string): string;
+/**
+ * Build Markdown for a single requirement (for testing/debugging).
+ */
+export declare function buildRequirementMarkdown(node: RequirementNode): string;
+/**
+ * Build a complete requirements file from metadata and raw markdown content.
+ * Used by CLI pull to combine frontmatter with cloud-sourced markdown.
+ *
+ * SYNC-ARCH-1: markdownContent is the source of truth from the cloud.
+ */
+export declare function buildRequirementsFile(metadata: Metadata, markdownContent: string): string;
+//# sourceMappingURL=builder.d.ts.map

package/dist/schema/builder.js

@@ -0,0 +1,125 @@
+/**
+ * Build Markdown requirements files from structured data.
+ */
+import YAML from 'yaml';
+/**
+ * Default delimiter for requirements.
+ * Can be overridden for organization-specific preferences.
+ */
+export const DEFAULT_DELIMITER = '→';
+/**
+ * Build YAML frontmatter from metadata.
+ */
+function buildFrontmatter(metadata) {
+    const yamlStr = YAML.stringify(metadata, {
+        lineWidth: 0, // Don't wrap lines
+        minContentWidth: 0,
+    });
+    return `---\n${yamlStr.trim()}\n---`;
+}
+/**
+ * Build a dotrequirements block from a requirement node.
+ * Formats children with explicit position paths and proper indentation.
+ */
+function buildRequirementBlock(node, delimiter = DEFAULT_DELIMITER) {
+    // First line: root requirement with delimiter
+    // Include label if it's not empty (empty string means unlabeled)
+    const rootLabel = node.label
+        ? `${node.label.charAt(0).toUpperCase() + node.label.slice(1)} `
+        : '';
+    let block = `${rootLabel}${delimiter} ${node.content}\n`;
+    // Recursively build criteria lines
+    function addCriteria(children, parentPosition = '') {
+        children.forEach((child, index) => {
+            const position = parentPosition === '' ? `${index}` : `${parentPosition}.${index}`;
+            const depth = position.split('.').length - 1;
+            const indent = '  '.repeat(depth + 1); // 2 spaces per level
+            // Include label if present, otherwise just delimiter
+            const labelPart = child.label
+                ? `${child.label.charAt(0).toUpperCase() + child.label.slice(1)} `
+                : '';
+            block += `${indent}${position}. ${labelPart}${delimiter} ${child.content}\n`;
+            // Recursively add grandchildren
+            if (child.children && child.children.length > 0) {
+                addCriteria(child.children, position);
+            }
+        });
+    }
+    addCriteria(node.children);
+    return block.trimEnd();
+}
+/**
+ * Build the children portion of a requirement block (without the root line).
+ */
+function buildChildrenBlock(children) {
+    let block = '';
+    function addChildren(nodes, parentPosition = '') {
+        nodes.forEach((child, index) => {
+            const position = parentPosition === '' ? `${index}` : `${parentPosition}.${index}`;
+            const depth = position.split('.').length - 1;
+            const indent = '  '.repeat(depth + 1); // 2 spaces per level
+            // Include label if present, otherwise just delimiter
+            const labelPart = child.label
+                ? `${child.label.charAt(0).toUpperCase() + child.label.slice(1)} `
+                : '';
+            block += `${indent}${position}. ${labelPart}→ ${child.content}\n`;
+            // Recursively add grandchildren
+            if (child.children && child.children.length > 0) {
+                addChildren(child.children, position);
+            }
+        });
+    }
+    addChildren(children);
+    return block.trimEnd();
+}
+/**
+ * Build a complete requirement section (heading + block).
+ */
+function buildRequirementSection(node, title) {
+    const displayTitle = title || node.content;
+    // Heading now just has the title, no key
+    let section = `## ${displayTitle}\n\n`;
+    section += '```dotrequirements\n';
+    // First line of block has the key
+    section += `${node.id}: ${node.content}\n`;
+    // Then add children
+    if (node.children && node.children.length > 0) {
+        section += buildChildrenBlock(node.children);
+    }
+    section += '\n```\n';
+    return section;
+}
+/**
+ * Build complete Markdown requirements document.
+ */
+export function buildRequirementsMarkdown(metadata, requirements, documentTitle) {
+    let markdown = buildFrontmatter(metadata);
+    markdown += '\n\n';
+    // Add document title if provided
+    if (documentTitle) {
+        markdown += `# ${documentTitle}\n\n`;
+    }
+    // Add each requirement section
+    for (const req of requirements) {
+        markdown += buildRequirementSection(req);
+        markdown += '\n';
+    }
+    return markdown.trimEnd() + '\n';
+}
+/**
+ * Build Markdown for a single requirement (for testing/debugging).
+ */
+export function buildRequirementMarkdown(node) {
+    return buildRequirementSection(node);
+}
+/**
+ * Build a complete requirements file from metadata and raw markdown content.
+ * Used by CLI pull to combine frontmatter with cloud-sourced markdown.
+ *
+ * SYNC-ARCH-1: markdownContent is the source of truth from the cloud.
+ */
+export function buildRequirementsFile(metadata, markdownContent) {
+    const frontmatter = buildFrontmatter(metadata);
+    return `${frontmatter}\n\n${markdownContent.trim()}\n`;
+}
+//# sourceMappingURL=builder.js.map

package/dist/schema/conversions.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Convert between Convex flat representation and hierarchical RequirementNode trees.
+ */
+import { RequirementNode, Metadata } from './schemas.js';
+/**
+ * Convex requirement type (flat structure with position paths).
+ * This mirrors the Convex database schema.
+ */
+export interface ConvexRequirement {
+    _id: string;
+    prefix: string;
+    index: number;
+    documentId: string;
+    label: string;
+    content: string;
+    projectId: string;
+    rootId?: string;
+    position?: string;
+    metadata?: any;
+    externalLinks?: {
+        jira?: string;
+        notion?: string;
+    };
+    updatedAt: number;
+}
+/**
+ * Construct a requirement key from prefix and index.
+ * E.g., ("REQ", 123) -> "REQ-123"
+ */
+export declare function constructKey(prefix: string, index: number): string;
+/**
+ * Parse a requirement key into prefix and index.
+ * E.g., "REQ-123" -> { prefix: "REQ", index: 123 }
+ * Returns null if key doesn't match expected format.
+ */
+export declare function parseKey(key: string): {
+    prefix: string;
+    index: number;
+} | null;
+/**
+ * Build a hierarchical tree from flat Convex requirements.
+ * Uses position paths to reconstruct parent-child relationships.
+ */
+export declare function convexToRequirements(convexReqs: ConvexRequirement[]): RequirementNode[];
+/**
+ * Flatten a hierarchical structure back to Convex flat format.
+ * Generates position paths for each node.
+ */
+export declare function requirementsToConvex(nodes: RequirementNode[], projectId: string, documentId: string): ConvexRequirement[];
+/**
+ * Build metadata from project info and pull time.
+ * DOC-HEADER-11.3: When pulling, include defaultPrefix in the frontmatter.
+ */
+export declare function buildMetadata(projectId: string, version?: number, document?: {
+    id?: string;
+    title: string;
+    defaultPrefix?: string;
+}): Metadata;
+/**
+ * Extract unique requirement keys from Convex data.
+ * Useful for detecting duplicates or tracking which requirements exist.
+ */
+export declare function extractRequirementKeys(convexReqs: ConvexRequirement[]): Set<string>;
+/**
+ * Group Convex requirements by their root.
+ * Returns a map of rootId → children.
+ */
+export declare function groupByRoot(convexReqs: ConvexRequirement[]): Map<string | undefined, ConvexRequirement[]>;
+//# sourceMappingURL=conversions.d.ts.map