law-mcp-server 0.1.1 → 0.1.3

package/README.md

@@ -80,6 +80,10 @@ This repository will host an MCP server that uses **法令API Version 2** (e-Gov
 }
 ```
 
+If you are installing from a local clone instead of the published
+package, run `npm install && npm run build` and then `npm link` so the
+`law-mcp-server` command is available on your `PATH` for Claude Desktop.
+
 ## Usage Examples (conceptual)
 
 - Search and fetch: “Search for 個人情報保護 and show the latest articles.” → calls `search_laws` then `fetch_law`.

package/bin/law-mcp-server.js

@@ -1,3 +1,11 @@
 #!/usr/bin/env node
 
-import("../dist/index.js");
+const entry = new URL("../dist/src/index.js", import.meta.url);
+
+import(entry.href).catch((error) => {
+  console.error(
+    "Failed to start law-mcp-server. Run `npm run build` to generate dist/ before launching."
+  );
+  console.error(error);
+  process.exit(1);
+});

package/dist/src/index.js

@@ -2,6 +2,23 @@
 import { StdioJsonRpcServer } from "./mcp.js";
 import { tools, resolveTool } from "./tools.js";
 const server = new StdioJsonRpcServer();
+const serverInfo = { name: "law-mcp-server", version: "0.1.2" };
+server.register("initialize", async (params) => {
+    const payload = (params ?? {});
+    const protocolVersion = typeof payload.protocolVersion === "string"
+        ? payload.protocolVersion
+        : "2024-06-17";
+    return {
+        protocolVersion,
+        serverInfo,
+        capabilities: {
+            tools: {
+                list: true,
+                call: true,
+            },
+        },
+    };
+});
 server.register("ping", async () => ({ ok: true }));
 server.register("tools/list", async () => ({
     tools: tools.map((tool) => ({

package/package.json

@@ -1,14 +1,21 @@
 {
   "name": "law-mcp-server",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "type": "module",
   "description": "MCP server for e-Gov law API consistency checks",
+  "files": [
+    "dist",
+    "bin",
+    "README.md",
+    "LICENSE"
+  ],
   "bin": {
     "law-mcp-server": "bin/law-mcp-server.js"
   },
-  "main": "dist/index.js",
+  "main": "dist/src/index.js",
   "scripts": {
     "build": "tsc",
+    "prepare": "npm run build",
     "start": "node dist/index.js",
     "dev": "ts-node src/index.ts",
     "lint": "eslint \"src/**/*.ts\" \"test/**/*.ts\"",
@@ -16,16 +23,17 @@
     "test": "npm run build && node dist/test/integration.test.js"
   },
   "dependencies": {
+    "stripe": "^20.3.1",
     "undici": "^6.13.0"
   },
   "devDependencies": {
-    "ts-node": "^10.9.2",
-    "typescript": "5.3.3",
     "@types/node": "^20.11.0",
-    "eslint": "^8.57.0",
     "@typescript-eslint/eslint-plugin": "^6.21.0",
     "@typescript-eslint/parser": "^6.21.0",
+    "eslint": "^8.57.0",
     "eslint-config-prettier": "^9.1.0",
-    "prettier": "^3.2.5"
+    "prettier": "^3.2.5",
+    "ts-node": "^10.9.2",
+    "typescript": "5.3.3"
   }
 }

package/.env.example

@@ -1,8 +0,0 @@
-# Base URL for the e-Gov 法令API v2
-LAW_API_BASE=https://laws.e-gov.go.jp/api/2/
-
-# HTTP request timeout in milliseconds
-HTTP_TIMEOUT_MS=15000
-
-# Cache TTL for fetched law responses in seconds
-CACHE_TTL_SECONDS=900

package/.eslintignore

@@ -1,2 +0,0 @@
-dist/
-node_modules/

package/.eslintrc.cjs

@@ -1,19 +0,0 @@
-module.exports = {
-  env: {
-    es2022: true,
-    node: true,
-  },
-  parser: "@typescript-eslint/parser",
-  parserOptions: {
-    sourceType: "module",
-    ecmaVersion: "latest",
-  },
-  plugins: ["@typescript-eslint"],
-  extends: [
-    "eslint:recommended",
-    "plugin:@typescript-eslint/recommended",
-    "prettier",
-  ],
-  ignorePatterns: ["dist/**"],
-  rules: {},
-};

package/.prettierignore

@@ -1,2 +0,0 @@
-dist/
-node_modules/

package/.prettierrc

@@ -1,5 +0,0 @@
-{
-  "singleQuote": false,
-  "semi": true,
-  "trailingComma": "es5"
-}

package/src/cache.ts

@@ -1,25 +0,0 @@
-type Entry<T> = {
-  value: T;
-  expiresAt: number;
-};
-
-export class MemoryCache<T> {
-  private store = new Map<string, Entry<T>>();
-
-  get(key: string): T | undefined {
-    const entry = this.store.get(key);
-    if (!entry) return undefined;
-    if (Date.now() > entry.expiresAt) {
-      this.store.delete(key);
-      return undefined;
-    }
-    return entry.value;
-  }
-
-  set(key: string, value: T, ttlSeconds: number) {
-    const expiresAt = Date.now() + ttlSeconds * 1000;
-    this.store.set(key, { value, expiresAt });
-  }
-}
-
-export const cache = new MemoryCache<unknown>();

package/src/config.ts

@@ -1,19 +0,0 @@
-export type AppConfig = {
-  apiBase: string;
-  httpTimeoutMs: number;
-  cacheTtlSeconds: number;
-  userAgent: string;
-};
-
-const toNumber = (value: string | undefined, fallback: number) => {
-  const parsed = Number(value);
-  return Number.isFinite(parsed) ? parsed : fallback;
-};
-
-export const config: AppConfig = {
-  apiBase:
-    process.env.LAW_API_BASE?.trim() || "https://laws.e-gov.go.jp/api/2/",
-  httpTimeoutMs: toNumber(process.env.HTTP_TIMEOUT_MS, 15000),
-  cacheTtlSeconds: toNumber(process.env.CACHE_TTL_SECONDS, 900),
-  userAgent: "law-mcp-server/0.1.0",
-};

package/src/consistency.ts

@@ -1,128 +0,0 @@
-import {
-  LawArticle,
-  LawData,
-  ConsistencyFinding,
-  ConsistencyOutput,
-} from "./types.js";
-
-type FlattenedArticle = {
-  lawId: string;
-  articleNumber?: string;
-  text: string;
-};
-
-const toArray = <T>(value: T | T[] | undefined): T[] => {
-  if (!value) return [];
-  return Array.isArray(value) ? value : [value];
-};
-
-const paragraphText = (paragraph: unknown): string => {
-  if (!paragraph || typeof paragraph !== "object") return "";
-  const p = paragraph as { ParagraphSentence?: string | string[] };
-  const sentences = toArray(p.ParagraphSentence);
-  return sentences.join("\n");
-};
-
-const articleText = (article: LawArticle): string => {
-  const paragraphs = toArray(article.Paragraph);
-  const body = paragraphs.map(paragraphText).filter(Boolean).join("\n");
-  const title = article.ArticleTitle || "";
-  return [title, body].filter(Boolean).join("\n");
-};
-
-const flattenArticles = (law: LawData): FlattenedArticle[] => {
-  const articles = toArray(law.LawBody?.MainProvision?.Article);
-  return articles.map((article) => ({
-    lawId: law.LawID,
-    articleNumber: article.ArticleNumber,
-    text: articleText(article),
-  }));
-};
-
-const similarityScore = (a: string, b: string): number => {
-  const tokenize = (value: string) =>
-    value
-      .replace(/[\s、。,．.\n\t]+/g, " ")
-      .split(" ")
-      .map((v) => v.trim())
-      .filter(Boolean);
-  const tokensA = tokenize(a.toLowerCase());
-  const tokensB = tokenize(b.toLowerCase());
-  if (!tokensA.length || !tokensB.length) return 0;
-  const setB = new Set(tokensB);
-  const intersection = tokensA.filter((token) => setB.has(token)).length;
-  const union = new Set([...tokensA, ...tokensB]).size;
-  return intersection / union;
-};
-
-const extractArticleHint = (segment: string): string | undefined => {
-  const match = segment.match(
-    /第\s*([0-9０-９一二三四五六七八九十百千]+)\s*条/
-  );
-  return match ? match[1] : undefined;
-};
-
-const bestArticleMatch = (
-  segment: string,
-  articles: FlattenedArticle[]
-): FlattenedArticle | undefined => {
-  const hint = extractArticleHint(segment);
-  if (hint) {
-    const exact = articles.find(
-      (a) => a.articleNumber && a.articleNumber.includes(hint)
-    );
-    if (exact) return exact;
-  }
-  let best: FlattenedArticle | undefined;
-  let bestScore = 0;
-  for (const article of articles) {
-    const score = similarityScore(segment, article.text);
-    if (score > bestScore) {
-      best = article;
-      bestScore = score;
-    }
-  }
-  return best;
-};
-
-export const checkConsistency = (
-  documentText: string,
-  laws: LawData[]
-): ConsistencyOutput => {
-  const segments = documentText
-    .split(/\n+/)
-    .map((s) => s.trim())
-    .filter(Boolean);
-
-  const flattened = laws
-    .flatMap(flattenArticles)
-    .filter((a) => a.text.trim().length > 0);
-
-  const findings: ConsistencyFinding[] = segments.map((segment) => {
-    const match = bestArticleMatch(segment, flattened);
-    if (!match) {
-      return { segment, status: "not_found" };
-    }
-    const score = similarityScore(segment, match.text);
-    const status =
-      score >= 0.6
-        ? "aligned"
-        : score >= 0.25
-          ? "potential_mismatch"
-          : "not_found";
-    return {
-      segment,
-      status,
-      lawId: match.lawId,
-      articleNumber: match.articleNumber,
-      lawSnippet: match.text.slice(0, 400),
-      score: Number(score.toFixed(3)),
-    };
-  });
-
-  const matchedLawIds = Array.from(
-    new Set(findings.map((f) => f.lawId).filter(Boolean))
-  ) as string[];
-
-  return { findings, matchedLawIds };
-};

package/src/index.ts

@@ -1,36 +0,0 @@
-#!/usr/bin/env node
-
-import { StdioJsonRpcServer } from "./mcp.js";
-import { tools, resolveTool } from "./tools.js";
-
-const server = new StdioJsonRpcServer();
-
-server.register("ping", async () => ({ ok: true }));
-
-server.register("tools/list", async () => ({
-  tools: tools.map((tool) => ({
-    name: tool.name,
-    description: tool.description,
-    inputSchema: tool.inputSchema,
-    outputSchema: tool.outputSchema,
-  })),
-}));
-
-server.register("tools/call", async (params) => {
-  const payload = (params ?? {}) as { name?: unknown; arguments?: unknown };
-  if (typeof payload.name !== "string") {
-    throw new Error("Tool name is required and must be a string");
-  }
-  const tool = resolveTool(payload.name);
-  if (!tool) {
-    throw new Error(`Tool ${payload.name} is not available`);
-  }
-  const args =
-    payload.arguments && typeof payload.arguments === "object"
-      ? (payload.arguments as Record<string, unknown>)
-      : {};
-  const result = await tool.handler(args);
-  return { content: result };
-});
-
-server.start();

package/src/lawApi.ts

@@ -1,62 +0,0 @@
-import { fetch } from "undici";
-import { cache } from "./cache.js";
-import { config } from "./config.js";
-import { LawData, LawSearchResponse } from "./types.js";
-
-const withTimeout = async <T>(promise: Promise<T>, ms: number) => {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), ms);
-  try {
-    return await promise;
-  } finally {
-    clearTimeout(timer);
-  }
-};
-
-const request = async <T>(url: string) => {
-  const res = await withTimeout(
-    fetch(url, {
-      headers: {
-        "User-Agent": config.userAgent,
-        Accept: "application/json",
-      },
-    }),
-    config.httpTimeoutMs
-  );
-
-  if (!res.ok) {
-    const body = await res.text();
-    throw new Error(`Request failed ${res.status}: ${body}`);
-  }
-
-  const data = (await res.json()) as T;
-  return data;
-};
-
-export const fetchLawData = async (
-  lawId: string,
-  revisionDate?: string
-): Promise<LawData> => {
-  const cacheKey = `law:${lawId}:${revisionDate || "latest"}`;
-  const cached = cache.get(cacheKey) as LawData | undefined;
-  if (cached) return cached;
-
-  const base = config.apiBase.endsWith("/")
-    ? config.apiBase
-    : `${config.apiBase}/`;
-  const url = new URL(`lawdata/${encodeURIComponent(lawId)}`, base);
-  if (revisionDate) url.searchParams.set("revision", revisionDate);
-  const data = await request<LawData>(url.toString());
-  cache.set(cacheKey, data, config.cacheTtlSeconds);
-  return data;
-};
-
-export const searchLaws = async (
-  keyword: string
-): Promise<LawSearchResponse> => {
-  const base = config.apiBase.endsWith("/")
-    ? config.apiBase
-    : `${config.apiBase}/`;
-  const url = new URL(`lawsearch/${encodeURIComponent(keyword)}`, base);
-  return request<LawSearchResponse>(url.toString());
-};

package/src/mcp.ts

@@ -1,87 +0,0 @@
-import readline from "node:readline";
-
-type JsonRpcId = string | number | null;
-
-type JsonRpcRequest = {
-  jsonrpc: "2.0";
-  method: string;
-  id?: JsonRpcId;
-  params?: unknown;
-};
-
-type JsonRpcError = {
-  code: number;
-  message: string;
-};
-
-type RequestHandler = (params: unknown) => Promise<unknown> | unknown;
-
-export class StdioJsonRpcServer {
-  private handlers = new Map<string, RequestHandler>();
-
-  register(method: string, handler: RequestHandler) {
-    this.handlers.set(method, handler);
-  }
-
-  start() {
-    const rl = readline.createInterface({ input: process.stdin });
-    rl.on("line", async (line) => {
-      const message = this.parseMessage(line);
-      if (!message) return;
-
-      const { id, method, params } = message;
-      const handler = this.handlers.get(method);
-      if (!handler) {
-        if (id !== undefined) {
-          this.send({
-            jsonrpc: "2.0",
-            id,
-            error: { code: -32601, message: "Method not found" },
-          });
-        }
-        return;
-      }
-      try {
-        const result = await handler(params ?? {});
-        if (id !== undefined) {
-          this.send({ jsonrpc: "2.0", id, result });
-        }
-      } catch (error) {
-        if (id !== undefined) {
-          const messageText =
-            error instanceof Error ? error.message : String(error);
-          this.send({
-            jsonrpc: "2.0",
-            id,
-            error: { code: -32000, message: messageText },
-          });
-        }
-      }
-    });
-  }
-
-  private parseMessage(line: string): JsonRpcRequest | null {
-    try {
-      const parsed = JSON.parse(line) as JsonRpcRequest;
-      if (
-        !parsed ||
-        parsed.jsonrpc !== "2.0" ||
-        typeof parsed.method !== "string"
-      ) {
-        return null;
-      }
-      return parsed;
-    } catch (error) {
-      return null;
-    }
-  }
-
-  private send(payload: {
-    jsonrpc: "2.0";
-    id: JsonRpcId;
-    result?: unknown;
-    error?: JsonRpcError;
-  }) {
-    process.stdout.write(JSON.stringify(payload) + "\n");
-  }
-}

package/src/tools.ts

@@ -1,162 +0,0 @@
-import { fetchLawData, searchLaws } from "./lawApi.js";
-import { checkConsistency } from "./consistency.js";
-import { ConsistencyOutput } from "./types.js";
-
-type ToolContent = { type: string; text?: string; data?: unknown };
-type ToolHandler = (input: Record<string, unknown>) => Promise<ToolContent[]>;
-
-type Tool = {
-  name: string;
-  description: string;
-  inputSchema: Record<string, unknown>;
-  outputSchema?: Record<string, unknown>;
-  handler: ToolHandler;
-};
-
-const requireString = (value: unknown, field: string) => {
-  if (typeof value !== "string" || value.trim().length === 0) {
-    throw new Error(`Field ${field} is required`);
-  }
-  return value.trim();
-};
-
-const requireArrayOfStrings = (value: unknown, field: string) => {
-  if (!Array.isArray(value) || value.some((v) => typeof v !== "string")) {
-    throw new Error(`Field ${field} must be an array of strings`);
-  }
-  return value as string[];
-};
-
-const fetchLaw: Tool = {
-  name: "fetch_law",
-  description: "Fetch a law by LawID and optional revision date",
-  inputSchema: {
-    type: "object",
-    properties: {
-      lawId: { type: "string" },
-      revisionDate: { type: "string" },
-    },
-    required: ["lawId"],
-  },
-  handler: async (input) => {
-    const lawId = requireString(input.lawId, "lawId");
-    const revisionDate =
-      typeof input.revisionDate === "string" ? input.revisionDate : undefined;
-    const data = await fetchLawData(lawId, revisionDate);
-    return [{ type: "json", data }];
-  },
-};
-
-const search: Tool = {
-  name: "search_laws",
-  description: "Search laws by keyword",
-  inputSchema: {
-    type: "object",
-    properties: {
-      keyword: { type: "string" },
-    },
-    required: ["keyword"],
-  },
-  handler: async (input) => {
-    const keyword = requireString(input.keyword, "keyword");
-    const results = await searchLaws(keyword);
-    return [{ type: "json", data: results }];
-  },
-};
-
-const summarize: Tool = {
-  name: "summarize_law",
-  description: "Summarize a law or selected articles",
-  inputSchema: {
-    type: "object",
-    properties: {
-      lawId: { type: "string" },
-      articles: { type: "array", items: { type: "string" } },
-    },
-    required: ["lawId"],
-  },
-  handler: async (input) => {
-    const lawId = requireString(input.lawId, "lawId");
-    const articlesFilter = Array.isArray(input.articles)
-      ? requireArrayOfStrings(input.articles, "articles")
-      : undefined;
-    const data = await fetchLawData(lawId);
-    const articles = Array.isArray(data.LawBody?.MainProvision?.Article)
-      ? data.LawBody?.MainProvision?.Article
-      : data.LawBody?.MainProvision?.Article
-        ? [data.LawBody.MainProvision.Article]
-        : [];
-    const filtered = articlesFilter
-      ? articles.filter(
-          (article) =>
-            article.ArticleNumber &&
-            articlesFilter.includes(article.ArticleNumber)
-        )
-      : articles;
-    const body = filtered
-      .map((article) =>
-        `${article.ArticleNumber || ""} ${article.ArticleTitle || ""}`.trim()
-      )
-      .slice(0, 10)
-      .join("\n");
-    return [{ type: "text", text: body || "No articles available" }];
-  },
-};
-
-const listRevisions: Tool = {
-  name: "list_revisions",
-  description: "List known revisions for a law if provided by the API",
-  inputSchema: {
-    type: "object",
-    properties: {
-      lawId: { type: "string" },
-    },
-    required: ["lawId"],
-  },
-  handler: async (input) => {
-    const lawId = requireString(input.lawId, "lawId");
-    const data = await fetchLawData(lawId);
-    const revisions = Array.isArray((data as Record<string, unknown>).revisions)
-      ? ((data as Record<string, unknown>).revisions as string[])
-      : [];
-    return [{ type: "json", data: { lawId, revisions } }];
-  },
-};
-
-const check: Tool = {
-  name: "check_consistency",
-  description: "Check a document against one or more laws",
-  inputSchema: {
-    type: "object",
-    properties: {
-      documentText: { type: "string" },
-      lawIds: { type: "array", items: { type: "string" } },
-      articleHints: { type: "array", items: { type: "string" } },
-      strictness: { type: "string", enum: ["low", "medium", "high"] },
-    },
-    required: ["documentText"],
-  },
-  handler: async (input) => {
-    const documentText = requireString(input.documentText, "documentText");
-    const lawIds = Array.isArray(input.lawIds)
-      ? requireArrayOfStrings(input.lawIds, "lawIds")
-      : [];
-    if (!lawIds.length) {
-      throw new Error("At least one lawId is required for consistency checks");
-    }
-    const laws = await Promise.all(lawIds.map((lawId) => fetchLawData(lawId)));
-    const output: ConsistencyOutput = checkConsistency(documentText, laws);
-    return [{ type: "json", data: output }];
-  },
-};
-
-export const tools: Tool[] = [
-  fetchLaw,
-  search,
-  listRevisions,
-  check,
-  summarize,
-];
-
-export const resolveTool = (name: string) =>
-  tools.find((tool) => tool.name === name);

package/src/types.ts

@@ -1,54 +0,0 @@
-export type LawArticleParagraph = {
-  ParagraphTitle?: string;
-  ParagraphSentence?: string | string[];
-};
-
-export type LawArticle = {
-  ArticleNumber?: string;
-  ArticleTitle?: string;
-  Paragraph?: LawArticleParagraph | LawArticleParagraph[];
-};
-
-export type LawBody = {
-  MainProvision?: {
-    Article?: LawArticle | LawArticle[];
-  };
-};
-
-export type LawData = {
-  LawID: string;
-  LawName?: string;
-  LawBody?: LawBody;
-  ApplProvision?: unknown;
-  SupplProvision?: unknown;
-};
-
-export type LawSearchItem = {
-  LawID: string;
-  LawName?: string;
-  PromulgationDate?: string;
-};
-
-export type LawSearchResponse = {
-  numberOfHits?: number;
-  referencelaw?: LawSearchItem | LawSearchItem[];
-};
-
-export type ToolResult = {
-  contentType: string;
-  data: unknown;
-};
-
-export type ConsistencyFinding = {
-  segment: string;
-  status: "aligned" | "potential_mismatch" | "not_found";
-  lawId?: string;
-  articleNumber?: string;
-  lawSnippet?: string;
-  score?: number;
-};
-
-export type ConsistencyOutput = {
-  findings: ConsistencyFinding[];
-  matchedLawIds: string[];
-};

package/test/integration.test.ts

@@ -1,75 +0,0 @@
-import assert from "node:assert";
-import { MockAgent, setGlobalDispatcher } from "undici";
-import { fetchLawData, searchLaws } from "../src/lawApi.js";
-import { checkConsistency } from "../src/consistency.js";
-
-const mockAgent = new MockAgent();
-mockAgent.disableNetConnect();
-const mockPool = mockAgent.get("https://laws.e-gov.go.jp");
-
-mockPool
-  .intercept({ path: "/api/2/lawdata/TEST-LAW", method: "GET" })
-  .reply(200, {
-    LawID: "TEST-LAW",
-    LawName: "テスト法",
-    LawBody: {
-      MainProvision: {
-        Article: [
-          {
-            ArticleNumber: "第1条",
-            ArticleTitle: "（目的）",
-            Paragraph: {
-              ParagraphSentence: "この法律はテスト目的のために存在する。",
-            },
-          },
-          {
-            ArticleNumber: "第2条",
-            ArticleTitle: "（定義）",
-            Paragraph: { ParagraphSentence: "用語の定義を定める。" },
-          },
-        ],
-      },
-    },
-  });
-
-mockPool
-  .intercept({
-    path: "/api/2/lawsearch/%E3%83%86%E3%82%B9%E3%83%88",
-    method: "GET",
-  })
-  .reply(200, {
-    numberOfHits: 1,
-    referencelaw: {
-      LawID: "TEST-LAW",
-      LawName: "テスト法",
-      PromulgationDate: "2024-01-01",
-    },
-  });
-
-setGlobalDispatcher(mockAgent);
-
-const run = async () => {
-  // fetchLawData returns structured law
-  const law = await fetchLawData("TEST-LAW");
-  assert.strictEqual(law.LawID, "TEST-LAW");
-  assert.ok(law.LawBody?.MainProvision?.Article);
-
-  // searchLaws returns the mocked hit
-  const search = await searchLaws("テスト");
-  assert.strictEqual(search.numberOfHits, 1);
-
-  // consistency check aligns a segment with 第1条
-  const doc = "この法律はテスト目的のために存在する。";
-  const result = checkConsistency(doc, [law]);
-  assert.strictEqual(result.findings.length, 1);
-  const finding = result.findings[0];
-  assert.notStrictEqual(finding.status, "not_found");
-  assert.strictEqual(finding.articleNumber, "第1条");
-
-  console.log("integration tests passed");
-};
-
-run().catch((error) => {
-  console.error(error);
-  process.exitCode = 1;
-});

package/tsconfig.json

@@ -1,14 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ES2022",
-    "moduleResolution": "node",
-    "rootDir": ".",
-    "outDir": "dist",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "resolveJsonModule": true
-  },
-  "include": ["src/**/*.ts", "test/**/*.ts"]
-}