@nudojs/core 0.1.0 → 0.3.0

package/src/strip-types.ts

@@ -0,0 +1,236 @@
+import type { Node } from "@babel/types";
+
+/**
+ * TS 剥除 pass（Babel typescript 插件 AST → 纯 JS AST）。
+ *
+ * 为什么放在 parser 层而不是 evaluator 里逐节点 unwrap：
+ * parse() 的产物被所有下游消费——CLI resolveModule/generate、service
+ * analyzer/case-emitter、LSP server/agent-tools、evaluator 的整条求值链。
+ * 在 evaluator 层做 unwrap 只能修一条链，其余消费方（buildModuleGraph 的
+ * import 提取、directive 提取、semanticTokens 等）仍会撞上 TS-only 节点。
+ * parse() 统一剥除后所有消费方零改动即可分析 .ts 文件。
+ *
+ * 对纯 JS 源码本 pass 是结构性 no-op（TS-only 节点/字段根本不会出现），
+ * 向后兼容；节点均原地改写，loc/start/end 与兄弟节点顺序保持不变
+ * （@nudo:case 注释按 comment loc 对齐，删语句只从语句数组中剔除）。
+ *
+ * 剥除规则：
+ *  - 表达式解包：TSAsExpression（含 as const）/ TSSatisfiesExpression /
+ *    TSTypeAssertion（<T>x）/ TSNonNullExpression（x!）/ TSInstantiationExpression
+ *    （裸泛型引用 const f = foo<number>）→ 直接取 .expression
+ *  - 类型声明删除：TSInterfaceDeclaration / TSTypeAliasDeclaration /
+ *    TSDeclareFunction / declare 修饰的 TSModuleDeclaration、VariableDeclaration、
+ *    ClassDeclaration，以及包装它们的 ExportNamedDeclaration / ExportDefaultDeclaration
+ *  - TSEnumDeclaration 直接删除。风险：TS enum 有运行时语义（编译为带反向映射的
+ *    对象），删除后源码中 enum 成员引用会退化为 unknown-global 诊断；nudo 的
+ *    求值器没有 enum 求值语义，保真合成对象超出本次范围
+ *  - type-only import/export：importKind/exportKind === "type" 的声明删除；
+ *    值 import 里混入的 type specifier（import { type A, b }）按 specifier 剔除，
+ *    全部为 type 时整个声明删除
+ *  - 类成员：TSIndexSignature / TSDeclareMethod（含 abstract 方法）/ declare·abstract
+ *    的 ClassProperty 删除；implements / superTypeParameters 字段删除
+ *  - 求值器不读的类型字段：typeParameters（声明与调用点 TSTypeParameterInstantiation，
+ *    即 foo<string>(1)）、typeAnnotation、returnType（含 TSTypePredicate）、
+ *    参数 Identifier/ObjectPattern/ArrayPattern/RestElement 上的 optional 一律 delete
+ *
+ * 已知不处理（会以 unknown 求值，不崩溃）：非 declare 的 namespace（运行时语义）、
+ * TSImportEqualsDeclaration（import x = require(...)）、构造器参数属性
+ * （constructor(private x)）——均在 .ts 推断目标场景之外。
+ */
+
+/** 数组槽位删除哨兵：语句/成员/specifier 只出现在数组上下文中 */
+const REMOVE: unique symbol = Symbol("nudo.strip.remove");
+
+/** 不含 AST 子节点的键：位置/注释/打印器元数据 */
+const SKIP_KEYS = new Set([
+  "loc",
+  "start",
+  "end",
+  "range",
+  "leadingComments",
+  "trailingComments",
+  "innerComments",
+  "comments",
+  "tokens",
+  "extra",
+]);
+
+/** 实参/形参模式等数组中的空洞（ArrayPattern 的 elision）保持原样 */
+function transformValue(value: unknown): unknown {
+  if (Array.isArray(value)) {
+    let changed = false;
+    const out: unknown[] = [];
+    for (const el of value) {
+      if (el === null || el === undefined) {
+        out.push(el);
+        continue;
+      }
+      const r = transformValue(el);
+      if (r === REMOVE) {
+        changed = true;
+      } else {
+        if (r !== el) changed = true;
+        out.push(r);
+      }
+    }
+    return changed ? out : value;
+  }
+  if (typeof value !== "object" || value === null) return value;
+  if (typeof (value as { type?: unknown }).type !== "string") return value;
+  return transformNode(value as Node & Record<string, unknown>);
+}
+
+function isTsDeclareLike(node: Node): boolean {
+  return (node as { declare?: unknown }).declare === true;
+}
+
+/** 类型声明本身是否 TS-only（供 export 包装语句判断整体删除） */
+function isTypeOnlyDeclaration(decl: Node): boolean {
+  switch (decl.type) {
+    case "TSInterfaceDeclaration":
+    case "TSTypeAliasDeclaration":
+    case "TSEnumDeclaration":
+    case "TSDeclareFunction":
+      return true;
+    case "VariableDeclaration":
+    case "ClassDeclaration":
+      return isTsDeclareLike(decl);
+    default:
+      return false;
+  }
+}
+
+/**
+ * 语句/类成员/specifier 级删除判定（只会在数组上下文中出现，
+ * 返回 REMOVE 时父数组剔除该元素）。
+ */
+function isTypeOnlyStatement(node: Node): boolean {
+  const anyNode = node as Node & { importKind?: string; exportKind?: string; specifiers?: unknown[] };
+  switch (node.type) {
+    case "TSInterfaceDeclaration":
+    case "TSTypeAliasDeclaration":
+    case "TSEnumDeclaration":
+    case "TSDeclareFunction":
+      return true;
+    case "TSModuleDeclaration":
+      // declare module / declare namespace 纯类型；非 declare 的 namespace 有运行时语义，保留
+      return isTsDeclareLike(node);
+    case "VariableDeclaration":
+    case "ClassDeclaration":
+      return isTsDeclareLike(node);
+    case "ImportDeclaration":
+      if (anyNode.importKind === "type") return true;
+      // import { type A, type B } from "m" —— 全 type specifier 则整个 import 无值语义
+      {
+        const specs = anyNode.specifiers as { importKind?: string }[] | undefined;
+        if (specs && specs.length > 0 && specs.every((s) => s.importKind === "type" || s.importKind === "typeof")) {
+          return true;
+        }
+      }
+      return false;
+    case "ExportNamedDeclaration": {
+      if (anyNode.exportKind === "type") return true;
+      const decl = (node as { declaration: Node | null }).declaration;
+      if (decl && isTypeOnlyDeclaration(decl)) return true;
+      // export { type A } / export { type A } from "m"
+      {
+        const specs = anyNode.specifiers as { exportKind?: string }[] | null;
+        if (!decl && specs && specs.length > 0 && specs.every((s) => s.exportKind === "type")) return true;
+      }
+      return false;
+    }
+    case "ExportAllDeclaration":
+      return anyNode.exportKind === "type";
+    case "ExportDefaultDeclaration":
+      return isTypeOnlyDeclaration((node as { declaration: Node }).declaration);
+    // ---- 类成员 ----
+    case "TSIndexSignature":
+    case "TSDeclareMethod": // declare / abstract 方法，无运行时实现
+      return true;
+    case "ClassProperty":
+    case "ClassPrivateProperty":
+      return isTsDeclareLike(node) || (node as { abstract?: unknown }).abstract === true;
+    default:
+      return false;
+  }
+}
+
+/** 求值器不读的类型字段：原地 delete */
+function deleteTypeSyntaxFields(node: Node & Record<string, unknown>): void {
+  const tp = node.typeParameters as { type?: string } | undefined;
+  if (tp && typeof tp.type === "string" && tp.type.startsWith("TSTypeParameter")) {
+    // 声明处（TSTypeParameterDeclaration）与调用处（TSTypeParameterInstantiation，
+    // 即 foo<string>(1) / new Foo<string>()）一并删除
+    delete node.typeParameters;
+  }
+  const ta = node.typeAnnotation as { type?: string } | undefined;
+  if (ta && ta.type === "TSTypeAnnotation") delete node.typeAnnotation;
+  const rt = node.returnType as { type?: string } | undefined;
+  if (rt && (rt.type === "TSTypeAnnotation" || rt.type === "TSTypePredicate")) delete node.returnType;
+  // `a?: T` 的可选标记。只在这些模式节点上删：OptionalMemberExpression 等
+  // 表达式节点自己的 optional 语义（a?.b）不属于 TS 语法，不能动
+  if (
+    node.optional === true &&
+    (node.type === "Identifier" || node.type === "ObjectPattern" || node.type === "ArrayPattern" || node.type === "RestElement")
+  ) {
+    delete node.optional;
+  }
+  // 类的 implements 子句与继承泛型实参
+  if ("implements" in node) delete node.implements;
+  if ("superTypeParameters" in node) delete node.superTypeParameters;
+}
+
+/** 表达式级解包：类型断言/满足断言/非空断言/裸泛型引用 → 内层表达式 */
+function unwrapExpression(node: Node & Record<string, unknown>): Node | null {
+  switch (node.type) {
+    case "TSAsExpression": // 含 as const
+    case "TSSatisfiesExpression":
+    case "TSTypeAssertion":
+    case "TSNonNullExpression":
+    case "TSInstantiationExpression":
+      return node.expression as Node;
+    default:
+      return null;
+  }
+}
+
+function transformNode(node: Node & Record<string, unknown>): Node | typeof REMOVE {
+  if (isTypeOnlyStatement(node)) return REMOVE;
+
+  deleteTypeSyntaxFields(node);
+
+  // 值 import/export 里混入的 type-only specifier 逐个剔除
+  if (node.type === "ImportDeclaration") {
+    node.specifiers = node.specifiers.filter(
+      (s) => !((s as { importKind?: string }).importKind === "type" || (s as { importKind?: string }).importKind === "typeof"),
+    );
+  } else if (node.type === "ExportNamedDeclaration") {
+    if (node.specifiers) {
+      node.specifiers = node.specifiers.filter((s) => (s as { exportKind?: string }).exportKind !== "type");
+    }
+  }
+
+  for (const key of Object.keys(node)) {
+    if (SKIP_KEYS.has(key)) continue;
+    const child = node[key];
+    if (child === null || typeof child !== "object") continue;
+    const r = transformValue(child);
+    if (r === REMOVE) {
+      // 单槽位理论上不会收到 REMOVE（删除项均为数组上下文），防御性清槽
+      delete node[key];
+    } else {
+      node[key] = r;
+    }
+  }
+
+  return unwrapExpression(node) ?? node;
+}
+
+/**
+ * 原地剥除 AST 中的 TS-only 语法节点/字段，返回同一棵 AST（便于链式使用）。
+ * 不改写任何 loc/start/end；语句删除只影响所在数组，不重排兄弟节点。
+ */
+export function stripTypes<T extends Node>(ast: T): T {
+  transformValue(ast);
+  return ast;
+}

package/src/type-value.ts

@@ -1,9 +1,33 @@
 import type { Node } from "@babel/types";
 import type { Environment } from "./environment.ts";
+// 注意：isTemplate 必须来自 template-predicates.ts（只含 `import type` 反向边）
+// 而非 template.ts——后者运行时依赖本模块（T、typeValueToString），会构成环。
+import { isTemplate } from "./refinements/template-predicates.ts";
 
-// --- TypeValue discriminated union ---
+// --- 评估 IR：不是类型系统本体，是 Abs 的外延投影格式 ---
 
-export type LiteralValue = string | number | boolean | null | undefined;
+export type LiteralValue = string | number | boolean | bigint | null | undefined;
+
+// `thisVal` is the bound receiver when the signature is invoked as a method
+// or through Function.prototype.call/apply (e.g. Object.prototype.toString
+// brand computation needs it); direct calls leave it undefined.
+export type SigImpl = (args: TypeValue[], thisVal?: TypeValue) => TypeValue | undefined;
+
+export type FunctionSignature = {
+  paramTypes: TypeValue[];
+  returnType: TypeValue;
+  throwsType: TypeValue;
+  impl?: SigImpl;
+};
+
+export type Refinement = {
+  name: string;
+  meta: Record<string, unknown>;
+  check?: (value: unknown) => boolean;
+  ops?: Record<string, (self: TypeValue, other: TypeValue) => TypeValue | undefined>;
+  methods?: Record<string, (self: TypeValue, args: TypeValue[]) => TypeValue | undefined>;
+  properties?: Record<string, (self: TypeValue) => TypeValue | undefined>;
+};
 
 export type TypeValue =
   | { kind: "literal"; value: LiteralValue }
@@ -11,6 +35,7 @@ export type TypeValue =
       kind: "primitive";
       type: "number" | "string" | "boolean" | "bigint" | "symbol";
     }
+  | { kind: "refined"; base: TypeValue; refinement: Refinement }
   | { kind: "object"; properties: Record<string, TypeValue>; id: symbol }
   | { kind: "array"; element: TypeValue }
   | { kind: "tuple"; elements: TypeValue[] }
@@ -68,6 +93,26 @@ export const T = {
     body,
     closure,
   }),
+  refine: (base: TypeValue, refinement: Refinement): TypeValue => ({
+    kind: "refined",
+    base,
+    refinement,
+  }),
+  fnSig: (
+    paramTypes: TypeValue[],
+    returnType: TypeValue,
+    throwsType: TypeValue = { kind: "never" },
+    impl?: SigImpl,
+  ): TypeValue => {
+    const dummy = {
+      kind: "function" as const,
+      params: paramTypes.map((_p, i) => `_arg${i}`),
+      body: { type: "BlockStatement", body: [], directives: [] } as unknown as Node,
+      closure: null as unknown as Environment,
+    };
+    (dummy as any)._signature = { paramTypes, returnType, throwsType, impl } satisfies FunctionSignature;
+    return dummy;
+  },
 } as const;
 
 // --- Helpers ---
@@ -78,6 +123,9 @@ export function typeValueEquals(a: TypeValue, b: TypeValue): boolean {
   if (a.kind === "primitive" && b.kind === "primitive") return a.type === b.type;
   if (a.kind === "never" && b.kind === "never") return true;
   if (a.kind === "unknown" && b.kind === "unknown") return true;
+  if (a.kind === "refined" && b.kind === "refined") {
+    return a.refinement.name === b.refinement.name && typeValueEquals(a.base, b.base);
+  }
   if (a.kind === "promise" && b.kind === "promise") {
     return typeValueEquals(a.value, b.value);
   }
@@ -94,6 +142,29 @@ export function typeValueEquals(a: TypeValue, b: TypeValue): boolean {
 }
 
 export function simplifyUnion(members: TypeValue[]): TypeValue {
+  // Fast path: empty or single element
+  if (members.length === 0) return T.never;
+  if (members.length === 1) return members[0].kind === "never" ? T.never : members[0];
+
+  // Fast path: two non-union elements, check equality first
+  if (members.length === 2) {
+    const a = members[0];
+    const b = members[1];
+    // Only use fast path if neither is a union (need flattening)
+    if (a.kind !== "union" && b.kind !== "union") {
+      if (a.kind === "never") return b.kind === "never" ? T.never : b;
+      if (b.kind === "never") return a;
+      if (typeValueEquals(a, b)) return a;
+      if (a.kind === "unknown" || b.kind === "unknown") return T.unknown;
+      // 吸收律：字面量被共存的 widening 基类型吸收（3 | number → number）
+      const aBase = absorbablePrimitiveBase(a);
+      if (aBase !== undefined && typeValueEquals(aBase, b)) return b;
+      const bBase = absorbablePrimitiveBase(b);
+      if (bBase !== undefined && typeValueEquals(bBase, a)) return a;
+      return { kind: "union", members: [a, b] };
+    }
+  }
+
   const flat: TypeValue[] = [];
   for (const m of members) {
     if (m.kind === "never") continue;
@@ -111,10 +182,38 @@ export function simplifyUnion(members: TypeValue[]): TypeValue {
     }
   }
 
-  if (deduped.length === 0) return T.never;
-  if (deduped.length === 1) return deduped[0];
-  if (deduped.some((m) => m.kind === "unknown")) return T.unknown;
-  return { kind: "union", members: deduped };
+  // 吸收律：成员中存在某字面量/模板字面量的 widening 基类型（非字面量
+  // number/string/boolean/bigint）时，删去该字面量成员（3 | number → number、
+  // "a" | string → string）。不同基底（1 | "a"）、纯字面量联合（"a" | "b"）、
+  // null/undefined 字面量不受影响；filter 保序，成员顺序稳定。
+  const primitives = deduped.filter((m) => m.kind === "primitive");
+  const absorbed =
+    primitives.length > 0
+      ? deduped.filter((m) => {
+          const base = absorbablePrimitiveBase(m);
+          return base === undefined || !primitives.some((p) => typeValueEquals(p, base));
+        })
+      : deduped;
+
+  if (absorbed.length === 0) return T.never;
+  if (absorbed.length === 1) return absorbed[0];
+  if (absorbed.some((m) => m.kind === "unknown")) return T.unknown;
+  return { kind: "union", members: absorbed };
+}
+
+/**
+ * 吸收律辅助：返回 tv 可被吸收进的原语基类型（number/string/boolean/bigint）。
+ * 仅数字/字符串/布尔/bigint 字面量与模板字面量（refined over T.string）有值；
+ * null/undefined 字面量 widen 后仍是字面量、基类型原语与其余类型不参与吸收
+ * （基类型自身不能被自己吸收，否则纯原语联合 number | string 会被误删）。
+ */
+function absorbablePrimitiveBase(tv: TypeValue): TypeValue | undefined {
+  if (tv.kind === "literal") {
+    const widened = widenLiteral(tv);
+    return widened.kind === "primitive" ? widened : undefined;
+  }
+  if (isTemplate(tv)) return T.string;
+  return undefined;
 }
 
 export function widenLiteral(tv: TypeValue): TypeValue {
@@ -123,11 +222,34 @@ export function widenLiteral(tv: TypeValue): TypeValue {
   if (typeof v === "number") return T.number;
   if (typeof v === "string") return T.string;
   if (typeof v === "boolean") return T.boolean;
+  // 吸收律要求 bigint 字面量能 widen 到 T.bigint
+  if (typeof v === "bigint") return T.bigint;
   if (v === null) return T.null;
   if (v === undefined) return T.undefined;
   return T.unknown;
 }
 
+/**
+ * union 成员全部为同原语基底的字面量且数量 > maxLiterals 时塌缩为该基类型；
+ * 非 union、混合类型、或数量不超限的原样返回。
+ *
+ * 复用 simplifyUnion（内含吸收律与去重）：先让「基类型已在场」的字面量被吸收
+ * （3 | number → number），再对剩余的纯字面量联合做阈值坍缩（1|2|…|20 → number）。
+ * 两步不冲突也不重复：吸收只删基类型已在场的字面量，阈值坍缩只处理无基类型
+ * 在场的纯字面量联合。
+ */
+export function collapseLiteralUnion(tv: TypeValue, maxLiterals: number): TypeValue {
+  if (tv.kind !== "union") return tv;
+  if (tv.members.length <= maxLiterals) return tv;
+  const simplified = simplifyUnion(tv.members);
+  if (simplified.kind !== "union") return simplified;
+  // 保守：成员中含非字面量（如显式 T.number 未吸收掉的异构成员）时不塌缩
+  if (!simplified.members.every((m) => m.kind === "literal")) return simplified;
+  const first = widenLiteral(simplified.members[0]);
+  if (!simplified.members.every((m) => typeValueEquals(widenLiteral(m), first))) return simplified;
+  return first;
+}
+
 export function isSubtypeOf(a: TypeValue, b: TypeValue): boolean {
   if (b.kind === "unknown") return true;
   if (a.kind === "never") return true;
@@ -141,6 +263,18 @@ export function isSubtypeOf(a: TypeValue, b: TypeValue): boolean {
     return false;
   }
 
+  if (a.kind === "literal" && b.kind === "refined") {
+    if (!isSubtypeOf(a, b.base)) return false;
+    return b.refinement.check ? b.refinement.check(a.value) : false;
+  }
+
+  if (a.kind === "refined") {
+    if (b.kind === "refined" && a.refinement.name === b.refinement.name) {
+      return isSubtypeOf(a.base, b.base);
+    }
+    return isSubtypeOf(a.base, b);
+  }
+
   if (a.kind === "object" && b.kind === "object") {
     return Object.entries(b.properties).every(
       ([k, bv]) => k in a.properties && isSubtypeOf(a.properties[k], bv),
@@ -226,6 +360,9 @@ export function deepCloneTypeValue(tv: TypeValue, idMap?: Map<symbol, symbol>):
     }
     return { kind: "instance", className: tv.className, properties: newProps };
   }
+  if (tv.kind === "refined") {
+    return { kind: "refined", base: deepCloneTypeValue(tv.base, map), refinement: tv.refinement };
+  }
   if (tv.kind === "union") {
     return simplifyUnion(tv.members.map((m) => deepCloneTypeValue(m, map)));
   }
@@ -251,6 +388,27 @@ export function mergeObjectProperties(
 }
 
 export function typeValueToString(tv: TypeValue): string {
+  // Self-referential structures (x.y = x surviving a clone) would recurse
+  // infinitely: a seen-set renders revisits as an ellipsis token.
+  return typeValueToStringInner(tv, new Set());
+}
+
+function typeValueToStringInner(tv: TypeValue, seen: Set<object>, depth = 0): string {
+  // Path-scoped seen-set: a node renders "…" only while its own expansion
+  // is on the stack (a true cycle); shared singletons (T.number in two
+  // slots) still render in full. A depth cap bounds fixture-scale DAGs
+  // whose repeated shared substructure would otherwise explode the string.
+  if (depth > 48) return "…";
+  const recur = (inner: TypeValue): string => {
+    if (inner && typeof inner === "object") {
+      if (seen.has(inner)) return "…";
+      seen.add(inner);
+      const out = typeValueToStringInner(inner, seen, depth + 1);
+      seen.delete(inner);
+      return out;
+    }
+    return typeValueToStringInner(inner, seen, depth + 1);
+  };
   switch (tv.kind) {
     case "literal": {
       const v = tv.value;
@@ -261,36 +419,43 @@ export function typeValueToString(tv: TypeValue): string {
     }
     case "primitive":
       return tv.type;
+    case "refined":
+      return tv.refinement.name;
     case "object": {
       const entries = Object.entries(tv.properties);
       if (entries.length === 0) return "{}";
       const inner = entries
-        .map(([k, v]) => `${k}: ${typeValueToString(v)}`)
+        .map(([k, v]) => `${k}: ${recur(v)}`)
         .join(", ");
       return `{ ${inner} }`;
     }
     case "array":
-      return `${typeValueToString(tv.element)}[]`;
+      return `${recur(tv.element)}[]`;
     case "tuple": {
-      const inner = tv.elements.map(typeValueToString).join(", ");
+      const inner = tv.elements.map(recur).join(", ");
       return `[${inner}]`;
     }
     case "function": {
+      const sig = getFnSig(tv);
+      if (sig) {
+        const params = sig.paramTypes.map((p, i) => `${tv.params[i]}: ${recur(p)}`).join(", ");
+        return `(${params}) => ${recur(sig.returnType)}`;
+      }
       const params = tv.params.join(", ");
       return `(${params}) => ...`;
     }
     case "promise":
-      return `Promise<${typeValueToString(tv.value)}>`;
+      return `Promise<${recur(tv.value)}>`;
     case "instance": {
       const entries = Object.entries(tv.properties);
       if (entries.length === 0) return tv.className;
       const inner = entries
-        .map(([k, v]) => `${k}: ${typeValueToString(v)}`)
+        .map(([k, v]) => `${k}: ${recur(v)}`)
         .join(", ");
       return `${tv.className} { ${inner} }`;
     }
     case "union": {
-      return tv.members.map(typeValueToString).join(" | ");
+      return tv.members.map(recur).join(" | ");
     }
     case "never":
       return "never";
@@ -323,6 +488,7 @@ export function getPrimitiveTypeOf(tv: TypeValue): string | undefined {
     return typeof v;
   }
   if (tv.kind === "primitive") return tv.type;
+  if (tv.kind === "refined") return getPrimitiveTypeOf(tv.base);
   if (tv.kind === "object") return "object";
   if (tv.kind === "array" || tv.kind === "tuple") return "object";
   if (tv.kind === "function") return "function";
@@ -330,3 +496,18 @@ export function getPrimitiveTypeOf(tv: TypeValue): string | undefined {
   if (tv.kind === "instance") return "object";
   return undefined;
 }
+
+export function getRefinedBase(tv: TypeValue): TypeValue {
+  return tv.kind === "refined" ? getRefinedBase(tv.base) : tv;
+}
+
+export function isFnSig(tv: TypeValue): boolean {
+  return tv.kind === "function" && "_signature" in tv;
+}
+
+export function getFnSig(tv: TypeValue): FunctionSignature | undefined {
+  if (tv.kind === "function" && "_signature" in tv) {
+    return (tv as any)._signature as FunctionSignature;
+  }
+  return undefined;
+}