@mastra/mcp-docs-server 0.0.0-error-handler-fix-20251020202607 → 0.0.0-execa-dynamic-import-20260304221256

package/.docs/raw/workflows-legacy/variables.mdx

@@ -1,316 +0,0 @@
----
-title: "Data Mapping with Workflow (Legacy) Variables | Mastra Docs"
-description: "Learn how to use workflow variables to map data between steps and create dynamic data flows in your Mastra workflows."
----
-
-# Data Mapping with Workflow Variables
-
-Workflow variables in Mastra provide a powerful mechanism for mapping data between steps, allowing you to create dynamic data flows and pass information from one step to another.
-
-## Understanding Workflow Variables
-
-In Mastra workflows, variables serve as a way to:
-
-- Map data from trigger inputs to step inputs
-- Pass outputs from one step to inputs of another step
-- Access nested properties within step outputs
-- Create more flexible and reusable workflow steps
-
-## Using Variables for Data Mapping
-
-### Basic Variable Mapping
-
-You can map data between steps using the `variables` property when adding a step to your workflow:
-
-```typescript showLineNumbers filename="src/mastra/workflows/index.ts" copy
-import { LegacyStep, LegacyWorkflow } from "@mastra/core/workflows/legacy";
-
-const workflow = new LegacyWorkflow({
-  name: "data-mapping-workflow",
-  triggerSchema: z.object({
-    inputData: z.string(),
-  }),
-});
-
-workflow
-  .step(step1, {
-    variables: {
-      // Map trigger data to step input
-      inputData: { step: "trigger", path: "inputData" },
-    },
-  })
-  .then(step2, {
-    variables: {
-      // Map output from step1 to input for step2
-      previousValue: { step: step1, path: "outputField" },
-    },
-  })
-  .commit();
-
-// Register the workflow with Mastra
-export const mastra = new Mastra({
-  legacy_workflows: { workflow },
-});
-```
-
-### Accessing Nested Properties
-
-You can access nested properties using dot notation in the `path` field:
-
-```typescript showLineNumbers filename="src/mastra/workflows/index.ts" copy
-workflow
-  .step(step1)
-  .then(step2, {
-    variables: {
-      // Access a nested property from step1's output
-      nestedValue: { step: step1, path: "nested.deeply.value" },
-    },
-  })
-  .commit();
-```
-
-### Mapping Entire Objects
-
-You can map an entire object by using `.` as the path:
-
-```typescript showLineNumbers filename="src/mastra/workflows/index.ts" copy
-workflow
-  .step(step1, {
-    variables: {
-      // Map the entire trigger data object
-      triggerData: { step: "trigger", path: "." },
-    },
-  })
-  .commit();
-```
-
-### Variables in Loops
-
-Variables can also be passed to `while` and `until` loops. This is useful for passing data between iterations or from outside steps:
-
-```typescript showLineNumbers filename="src/mastra/workflows/loop-variables.ts" copy
-// Step that increments a counter
-const incrementStep = new LegacyStep({
-  id: "increment",
-  inputSchema: z.object({
-    // Previous value from last iteration
-    prevValue: z.number().optional(),
-  }),
-  outputSchema: z.object({
-    // Updated counter value
-    updatedCounter: z.number(),
-  }),
-  execute: async ({ context }) => {
-    const { prevValue = 0 } = context.inputData;
-    return { updatedCounter: prevValue + 1 };
-  },
-});
-
-const workflow = new LegacyWorkflow({
-  name: "counter",
-});
-
-workflow.step(incrementStep).while(
-  async ({ context }) => {
-    // Continue while counter is less than 10
-    const result = context.getStepResult(incrementStep);
-    return (result?.updatedCounter ?? 0) < 10;
-  },
-  incrementStep,
-  {
-    // Pass previous value to next iteration
-    prevValue: {
-      step: incrementStep,
-      path: "updatedCounter",
-    },
-  },
-);
-```
-
-## Variable Resolution
-
-When a workflow executes, Mastra resolves variables at runtime by:
-
-1. Identifying the source step specified in the `step` property
-2. Retrieving the output from that step
-3. Navigating to the specified property using the `path`
-4. Injecting the resolved value into the target step's context as the `inputData` property
-
-## Examples
-
-### Mapping from Trigger Data
-
-This example shows how to map data from the workflow trigger to a step:
-
-```typescript showLineNumbers filename="src/mastra/workflows/trigger-mapping.ts" copy
-import { Mastra } from "@mastra/core";
-import { LegacyStep, LegacyWorkflow } from "@mastra/core/workflows/legacy";
-import { z } from "zod";
-
-// Define a step that needs user input
-const processUserInput = new LegacyStep({
-  id: "processUserInput",
-  execute: async ({ context }) => {
-    // The inputData will be available in context because of the variable mapping
-    const { inputData } = context.inputData;
-
-    return {
-      processedData: `Processed: ${inputData}`,
-    };
-  },
-});
-
-// Create the workflow
-const workflow = new LegacyWorkflow({
-  name: "trigger-mapping",
-  triggerSchema: z.object({
-    inputData: z.string(),
-  }),
-});
-
-// Map the trigger data to the step
-workflow
-  .step(processUserInput, {
-    variables: {
-      inputData: { step: "trigger", path: "inputData" },
-    },
-  })
-  .commit();
-
-// Register the workflow with Mastra
-export const mastra = new Mastra({
-  legacy_workflows: { workflow },
-});
-```
-
-### Mapping Between Steps
-
-This example demonstrates mapping data from one step to another:
-
-```typescript showLineNumbers filename="src/mastra/workflows/step-mapping.ts" copy
-import { Mastra } from "@mastra/core";
-import { LegacyStep, LegacyWorkflow } from "@mastra/core/workflows/legacy";
-import { z } from "zod";
-
-// Step 1: Generate data
-const generateData = new LegacyStep({
-  id: "generateData",
-  outputSchema: z.object({
-    nested: z.object({
-      value: z.string(),
-    }),
-  }),
-  execute: async () => {
-    return {
-      nested: {
-        value: "step1-data",
-      },
-    };
-  },
-});
-
-// Step 2: Process the data from step 1
-const processData = new LegacyStep({
-  id: "processData",
-  inputSchema: z.object({
-    previousValue: z.string(),
-  }),
-  execute: async ({ context }) => {
-    // previousValue will be available because of the variable mapping
-    const { previousValue } = context.inputData;
-
-    return {
-      result: `Processed: ${previousValue}`,
-    };
-  },
-});
-
-// Create the workflow
-const workflow = new LegacyWorkflow({
-  name: "step-mapping",
-});
-
-// Map data from step1 to step2
-workflow
-  .step(generateData)
-  .then(processData, {
-    variables: {
-      // Map the nested.value property from generateData's output
-      previousValue: { step: generateData, path: "nested.value" },
-    },
-  })
-  .commit();
-
-// Register the workflow with Mastra
-export const mastra = new Mastra({
-  legacy_workflows: { workflow },
-});
-```
-
-## Type Safety
-
-Mastra provides type safety for variable mappings when using TypeScript:
-
-```typescript showLineNumbers filename="src/mastra/workflows/type-safe.ts" copy
-import { Mastra } from "@mastra/core";
-import { LegacyStep, LegacyWorkflow } from "@mastra/core/workflows/legacy";
-import { z } from "zod";
-
-// Define schemas for better type safety
-const triggerSchema = z.object({
-  inputValue: z.string(),
-});
-
-type TriggerType = z.infer<typeof triggerSchema>;
-
-// Step with typed context
-const step1 = new LegacyStep({
-  id: "step1",
-  outputSchema: z.object({
-    nested: z.object({
-      value: z.string(),
-    }),
-  }),
-  execute: async ({ context }) => {
-    // TypeScript knows the shape of triggerData
-    const triggerData = context.getStepResult<TriggerType>("trigger");
-
-    return {
-      nested: {
-        value: `processed-${triggerData?.inputValue}`,
-      },
-    };
-  },
-});
-
-// Create the workflow with the schema
-const workflow = new LegacyWorkflow({
-  name: "type-safe-workflow",
-  triggerSchema,
-});
-
-workflow.step(step1).commit();
-
-// Register the workflow with Mastra
-export const mastra = new Mastra({
-  legacy_workflows: { workflow },
-});
-```
-
-## Best Practices
-
-1. **Validate Inputs and Outputs**: Use `inputSchema` and `outputSchema` to ensure data consistency.
-
-2. **Keep Mappings Simple**: Avoid overly complex nested paths when possible.
-
-3. **Consider Default Values**: Handle cases where mapped data might be undefined.
-
-## Comparison with Direct Context Access
-
-While you can access previous step results directly via `context.steps`, using variable mappings offers several advantages:
-
-| Feature     | Variable Mapping                            | Direct Context Access           |
-| ----------- | ------------------------------------------- | ------------------------------- |
-| Clarity     | Explicit data dependencies                  | Implicit dependencies           |
-| Reusability | Steps can be reused with different mappings | Steps are tightly coupled       |
-| Type Safety | Better TypeScript integration               | Requires manual type assertions |

package/dist/chunk-TUAHUTTB.js

@@ -1,356 +0,0 @@
-import fs2 from 'fs/promises';
-import path4, { dirname } from 'path';
-import { fileURLToPath } from 'url';
-import z from 'zod';
-
-// src/utils.ts
-var mdxFileCache = /* @__PURE__ */ new Map();
-var __dirname = dirname(fileURLToPath(import.meta.url));
-function fromRepoRoot(relative) {
-  return path4.resolve(__dirname, `../../../`, relative);
-}
-function fromPackageRoot(relative) {
-  return path4.resolve(__dirname, `../`, relative);
-}
-var log = console.error;
-async function* walkMdxFiles(dir) {
-  if (mdxFileCache.has(dir)) {
-    for (const file of mdxFileCache.get(dir)) yield file;
-    return;
-  }
-  const filesInDir = [];
-  const entries = await fs2.readdir(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = path4.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      for await (const file of walkMdxFiles(fullPath)) {
-        filesInDir.push(file);
-        yield file;
-      }
-    } else if (entry.isFile() && entry.name.endsWith(".mdx")) {
-      filesInDir.push(fullPath);
-      yield fullPath;
-    }
-  }
-  mdxFileCache.set(dir, filesInDir);
-}
-async function searchDocumentContent(keywords, baseDir) {
-  if (keywords.length === 0) return [];
-  const fileScores = /* @__PURE__ */ new Map();
-  for await (const filePath of walkMdxFiles(baseDir)) {
-    let content;
-    try {
-      content = await fs2.readFile(filePath, "utf-8");
-    } catch {
-      continue;
-    }
-    const lines = content.split("\n");
-    lines.forEach((lineText) => {
-      const lowerLine = lineText.toLowerCase();
-      for (const keyword of keywords) {
-        if (lowerLine.includes(keyword.toLowerCase())) {
-          const relativePath = path4.relative(baseDir, filePath).replace(/\\/g, "/");
-          if (!fileScores.has(relativePath)) {
-            fileScores.set(relativePath, {
-              path: relativePath,
-              keywordMatches: /* @__PURE__ */ new Set(),
-              totalMatches: 0,
-              titleMatches: 0,
-              pathRelevance: calculatePathRelevance(relativePath, keywords)
-            });
-          }
-          const score = fileScores.get(relativePath);
-          score.keywordMatches.add(keyword);
-          score.totalMatches++;
-          if (lowerLine.includes("#") || lowerLine.includes("title")) {
-            score.titleMatches++;
-          }
-        }
-      }
-    });
-  }
-  const validFiles = Array.from(fileScores.values()).sort((a, b) => calculateFinalScore(b, keywords.length) - calculateFinalScore(a, keywords.length)).slice(0, 10);
-  return validFiles.map((score) => score.path);
-}
-function calculatePathRelevance(filePath, keywords) {
-  let relevance = 0;
-  const pathLower = filePath.toLowerCase();
-  if (pathLower.startsWith("reference/")) relevance += 2;
-  keywords.forEach((keyword) => {
-    if (pathLower.includes(keyword.toLowerCase())) relevance += 3;
-  });
-  const highValueDirs = ["rag", "memory", "agents", "workflows"];
-  if (highValueDirs.some((dir) => pathLower.includes(dir))) {
-    relevance += 1;
-  }
-  return relevance;
-}
-function calculateFinalScore(score, totalKeywords) {
-  const allKeywordsBonus = score.keywordMatches.size === totalKeywords ? 10 : 0;
-  return score.totalMatches * 1 + score.titleMatches * 3 + score.pathRelevance * 2 + score.keywordMatches.size * 5 + allKeywordsBonus;
-}
-function extractKeywordsFromPath(path5) {
-  const filename = path5.split("/").pop()?.replace(/\.(mdx|md)$/, "") || "";
-  const keywords = /* @__PURE__ */ new Set();
-  const splitParts = filename.split(/[-_]|(?=[A-Z])/);
-  splitParts.forEach((keyword) => {
-    if (keyword.length > 2) {
-      keywords.add(keyword.toLowerCase());
-    }
-  });
-  return Array.from(keywords);
-}
-function normalizeKeywords(keywords) {
-  return Array.from(new Set(keywords.flatMap((k) => k.split(/\s+/).filter(Boolean)).map((k) => k.toLowerCase())));
-}
-async function getMatchingPaths(path5, queryKeywords, baseDir) {
-  const pathKeywords = extractKeywordsFromPath(path5);
-  const allKeywords = normalizeKeywords([...pathKeywords, ...queryKeywords || []]);
-  if (allKeywords.length === 0) {
-    return "";
-  }
-  const suggestedPaths = await searchDocumentContent(allKeywords, baseDir);
-  if (suggestedPaths.length === 0) {
-    return "";
-  }
-  const pathList = suggestedPaths.map((path6) => `- ${path6}`).join("\n");
-  return `Here are some paths that might be relevant based on your query:
-
-${pathList}`;
-}
-var blogPostSchema = z.object({
-  slug: z.string(),
-  content: z.string(),
-  metadata: z.object({
-    title: z.string(),
-    publishedAt: z.string(),
-    summary: z.string(),
-    image: z.string().optional(),
-    author: z.string().optional(),
-    draft: z.boolean().optional().default(false),
-    categories: z.array(z.string()).or(z.string())
-  })
-});
-var EXAMPLES_SOURCE = fromRepoRoot("examples");
-var OUTPUT_DIR = fromPackageRoot(".docs/organized/code-examples");
-async function loadExampleConfig(examplePath) {
-  try {
-    const configPath = path4.join(examplePath, ".mcp-docs.json");
-    const configContent = await fs2.readFile(configPath, "utf-8");
-    return JSON.parse(configContent);
-  } catch {
-    return {};
-  }
-}
-function shouldIgnoreFile(filePath, ignorePatterns = []) {
-  return ignorePatterns.some((pattern) => {
-    const regex = pattern.replace(/\*/g, ".*").replace(/\?/g, ".").replace(/\//g, "\\/");
-    return new RegExp(regex).test(filePath);
-  });
-}
-async function prepareCodeExamples() {
-  try {
-    await fs2.rm(OUTPUT_DIR, { recursive: true, force: true });
-  } catch {
-  }
-  await fs2.mkdir(OUTPUT_DIR, { recursive: true });
-  const examples = await fs2.readdir(EXAMPLES_SOURCE, { withFileTypes: true });
-  const exampleDirs = examples.filter((entry) => entry.isDirectory());
-  for (const dir of exampleDirs) {
-    const examplePath = path4.join(EXAMPLES_SOURCE, dir.name);
-    const outputFile = path4.join(OUTPUT_DIR, `${dir.name}.md`);
-    const config = await loadExampleConfig(examplePath);
-    const files = [];
-    if (!shouldIgnoreFile("package.json", config.ignore)) {
-      try {
-        const packageJsonContent = await fs2.readFile(path4.join(examplePath, "package.json"), "utf-8");
-        const packageJson = JSON.parse(packageJsonContent);
-        for (const key of [
-          "scripts",
-          "private",
-          "type",
-          "description",
-          "version",
-          "main",
-          "pnpm",
-          "packageManager",
-          "keywords",
-          "author",
-          "license"
-        ]) {
-          if (key in packageJson) delete packageJson[key];
-        }
-        files.push({
-          path: "package.json",
-          content: JSON.stringify(packageJson, null, 2)
-        });
-      } catch {
-      }
-    }
-    try {
-      const srcPath = path4.join(examplePath, "src");
-      await scanDirectory(srcPath, srcPath, files, config.ignore);
-    } catch {
-    }
-    if (files.length > 0) {
-      const output = files.map((file) => `### ${file.path}
-\`\`\`${getFileType(file.path)}
-${file.content}
-\`\`\`
-`).join("\n");
-      const totalLines = output.split("\n").length;
-      const limit = config.maxLines || 1500;
-      if (totalLines > limit) {
-        log(`Skipping ${dir.name}: ${totalLines} lines exceeds limit of ${limit}`);
-        continue;
-      }
-      await fs2.writeFile(outputFile, output, "utf-8");
-      log(`Generated ${dir.name}.md with ${totalLines} lines`);
-    }
-  }
-}
-async function scanDirectory(basePath, currentPath, files, ignorePatterns) {
-  const entries = await fs2.readdir(currentPath, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = path4.join(currentPath, entry.name);
-    const relativePath = path4.relative(basePath, fullPath);
-    if (shouldIgnoreFile(relativePath, ignorePatterns)) {
-      continue;
-    }
-    if (entry.isDirectory()) {
-      await scanDirectory(basePath, fullPath, files, ignorePatterns);
-    } else if (entry.isFile() && entry.name.endsWith(".ts")) {
-      const content = await fs2.readFile(fullPath, "utf-8");
-      files.push({
-        path: relativePath,
-        content
-      });
-    }
-  }
-}
-function getFileType(filePath) {
-  if (filePath === "package.json") return "json";
-  if (filePath.endsWith(".ts")) return "typescript";
-  return "";
-}
-var DOCS_SOURCE = fromRepoRoot("docs/src/content/en/docs");
-var REFERENCE_SOURCE = fromRepoRoot("docs/src/content/en/reference");
-var COURSE_SOURCE = fromRepoRoot("docs/src/course");
-var DOCS_DEST = fromPackageRoot(".docs/raw");
-var REFERENCE_DEST = path4.join(DOCS_DEST, "reference");
-var COURSE_DEST = path4.join(DOCS_DEST, "course");
-async function copyDir(src, dest) {
-  await fs2.mkdir(dest, { recursive: true });
-  const entries = await fs2.readdir(src, { withFileTypes: true });
-  for (const entry of entries) {
-    const srcPath = path4.join(src, entry.name);
-    const destPath = path4.join(dest, entry.name);
-    if (entry.isDirectory()) {
-      await copyDir(srcPath, destPath);
-    } else if (entry.isFile() && (entry.name.endsWith(".mdx") || entry.name.endsWith(".md"))) {
-      await fs2.copyFile(srcPath, destPath);
-    }
-  }
-}
-async function copyRaw() {
-  try {
-    try {
-      await fs2.rm(DOCS_DEST, { recursive: true });
-    } catch {
-    }
-    await copyDir(DOCS_SOURCE, DOCS_DEST);
-    await copyDir(REFERENCE_SOURCE, REFERENCE_DEST);
-    await copyDir(COURSE_SOURCE, COURSE_DEST);
-    log("\u2705 Documentation files copied successfully");
-  } catch (error) {
-    console.error("\u274C Failed to copy documentation files:", error);
-    process.exit(1);
-  }
-}
-var SOURCE_DIRS = ["packages", "speech", "stores", "voice", "integrations", "deployers", "client-sdks"].map(
-  fromRepoRoot
-);
-var CHANGELOGS_DEST = fromPackageRoot(".docs/organized/changelogs");
-var MAX_LINES = 300;
-function truncateContent(content, maxLines) {
-  const lines = content.split("\n");
-  if (lines.length <= maxLines) return content;
-  const visibleLines = lines.slice(0, maxLines);
-  const hiddenCount = lines.length - maxLines;
-  return visibleLines.join("\n") + `
-
-... ${hiddenCount} more lines hidden. See full changelog in package directory.`;
-}
-async function processPackageDir(packagePath, outputDir) {
-  let packageName;
-  try {
-    const packageJsonPath = path4.join(packagePath, "package.json");
-    const packageJson = JSON.parse(await fs2.readFile(packageJsonPath, "utf-8"));
-    packageName = packageJson.name;
-    if (!packageName) {
-      log(`Skipping ${path4.basename(packagePath)}: No package name found in package.json`);
-      return;
-    }
-  } catch {
-    console.error(`Skipping ${path4.basename(packagePath)}: No valid package.json found`);
-    return;
-  }
-  try {
-    const changelogPath = path4.join(packagePath, "CHANGELOG.md");
-    let changelog;
-    try {
-      changelog = await fs2.readFile(changelogPath, "utf-8");
-      changelog = truncateContent(changelog, MAX_LINES);
-    } catch {
-      changelog = "No changelog available.";
-    }
-    const outputFile = path4.join(outputDir, `${encodeURIComponent(packageName)}.md`);
-    await fs2.writeFile(outputFile, changelog, "utf-8");
-    log(`Generated changelog for ${packageName}`);
-  } catch (error) {
-    console.error(`Error processing changelog for ${packageName}:`, error);
-  }
-}
-async function preparePackageChanges() {
-  const outputDir = path4.resolve(process.cwd(), CHANGELOGS_DEST);
-  try {
-    await fs2.rm(outputDir, { recursive: true, force: true });
-  } catch {
-  }
-  await fs2.mkdir(outputDir, { recursive: true });
-  for (const sourceDir of SOURCE_DIRS) {
-    const fullSourceDir = path4.resolve(process.cwd(), sourceDir);
-    try {
-      await fs2.access(fullSourceDir);
-      const entries = await fs2.readdir(fullSourceDir, { withFileTypes: true });
-      const packageDirs = entries.filter((entry) => entry.isDirectory()).filter((entry) => entry.name !== "docs-mcp" && entry.name !== "_config");
-      for (const dir of packageDirs) {
-        const packagePath = path4.join(fullSourceDir, dir.name);
-        await processPackageDir(packagePath, outputDir);
-      }
-    } catch {
-      console.error(`Skipping ${sourceDir}: Directory not found or not accessible`);
-    }
-  }
-}
-
-// src/prepare-docs/prepare.ts
-async function prepare() {
-  log("Preparing documentation...");
-  await copyRaw();
-  log("Preparing code examples...");
-  await prepareCodeExamples();
-  log("Preparing package changelogs...");
-  await preparePackageChanges();
-  log("Documentation preparation complete!");
-}
-if (process.env.PREPARE === `true`) {
-  try {
-    await prepare();
-  } catch (error) {
-    console.error("Error preparing documentation:", error);
-    process.exit(1);
-  }
-}
-
-export { blogPostSchema, fromPackageRoot, getMatchingPaths, prepare };

package/dist/prepare-docs/code-examples.d.ts

@@ -1,5 +0,0 @@
-/**
- * Scans example directories and creates flattened code example files
- */
-export declare function prepareCodeExamples(): Promise<void>;
-//# sourceMappingURL=code-examples.d.ts.map

package/dist/prepare-docs/code-examples.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"code-examples.d.ts","sourceRoot":"","sources":["../../src/prepare-docs/code-examples.ts"],"names":[],"mappings":"AAoCA;;GAEG;AACH,wBAAsB,mBAAmB,kBAmFxC"}

package/dist/prepare-docs/copy-raw.d.ts

@@ -1,2 +0,0 @@
-export declare function copyRaw(): Promise<void>;
-//# sourceMappingURL=copy-raw.d.ts.map

package/dist/prepare-docs/copy-raw.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"copy-raw.d.ts","sourceRoot":"","sources":["../../src/prepare-docs/copy-raw.ts"],"names":[],"mappings":"AAgCA,wBAAsB,OAAO,kBAkB5B"}

package/dist/prepare-docs/package-changes.d.ts

@@ -1,5 +0,0 @@
-/**
- * Scans package directories and creates organized changelog files
- */
-export declare function preparePackageChanges(): Promise<void>;
-//# sourceMappingURL=package-changes.d.ts.map

package/dist/prepare-docs/package-changes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"package-changes.d.ts","sourceRoot":"","sources":["../../src/prepare-docs/package-changes.ts"],"names":[],"mappings":"AA8DA;;GAEG;AACH,wBAAsB,qBAAqB,kBAmC1C"}

package/dist/prepare-docs/prepare.d.ts

@@ -1,2 +0,0 @@
-export declare function prepare(): Promise<void>;
-//# sourceMappingURL=prepare.d.ts.map