@cardenelabs/cdl 0.5.0

package/src/formula/parser.ts

@@ -0,0 +1,399 @@
+import { ALLOWED_MATH_FNS, type BinaryOp, type FormulaAst, type MathFnName } from "./ast";
+
+/**
+ * formula expression parser (CAR #244)。
+ *
+ * safe subset のみ受け付ける:
+ * - 数値リテラル (整数 / 小数、 負数 は unary `-` 経由)
+ * - identifier (signal 名参照、 property access `.` は Math. 以外禁止)
+ * - Math.* 関数 (min / max / abs / floor / ceil / round のみ、 他は syntax error)
+ * - 算術 (+ - * / %) / 比較 (< <= > >= == !=) / 三項 (?:)
+ * - 括弧 ( )
+ *
+ * 禁止 pattern (parse 時に throw):
+ * - 代入 (= は == のみ、 単独 = は throw)
+ * - property access `x.y` (Math.* 以外)
+ * - Function / eval / import / for / while (identifier として来た場合は signal として扱われるので直接 error にならないが、
+ *   runtime に signal lookup 失敗する = evaluator 側で throw)
+ * - `!` (単独。 `!=` は accept)
+ */
+
+type Token =
+  | { kind: "num"; value: number; pos: number }
+  | { kind: "id"; name: string; pos: number }
+  | { kind: "math"; fn: MathFnName; pos: number }
+  | { kind: "op"; op: BinaryOp; pos: number }
+  | { kind: "lparen"; pos: number }
+  | { kind: "rparen"; pos: number }
+  | { kind: "comma"; pos: number }
+  | { kind: "question"; pos: number }
+  | { kind: "colon"; pos: number }
+  | { kind: "unaryMinus"; pos: number };
+
+function tokenize(src: string): Token[] {
+  const tokens: Token[] = [];
+  let i = 0;
+  while (i < src.length) {
+    const c = src[i]!;
+    if (c === " " || c === "\t" || c === "\n" || c === "\r") {
+      i++;
+      continue;
+    }
+    // number: digits + optional decimal
+    if (c >= "0" && c <= "9") {
+      const start = i;
+      let hasDot = false;
+      while (i < src.length) {
+        const cc = src[i]!;
+        if (cc >= "0" && cc <= "9") {
+          i++;
+        } else if (cc === "." && !hasDot) {
+          hasDot = true;
+          i++;
+        } else {
+          break;
+        }
+      }
+      const numStr = src.slice(start, i);
+      const num = Number(numStr);
+      if (Number.isNaN(num)) {
+        throw new Error(`invalid number literal "${numStr}" at position ${start}`);
+      }
+      tokens.push({ kind: "num", value: num, pos: start });
+      continue;
+    }
+    // decimal starting with `.` (e.g. .5)
+    if (c === "." && i + 1 < src.length && src[i + 1]! >= "0" && src[i + 1]! <= "9") {
+      const start = i;
+      i++;
+      while (i < src.length && src[i]! >= "0" && src[i]! <= "9") i++;
+      const num = Number(src.slice(start, i));
+      tokens.push({ kind: "num", value: num, pos: start });
+      continue;
+    }
+    // identifier / Math.<fn>
+    if ((c >= "a" && c <= "z") || (c >= "A" && c <= "Z") || c === "_" || c === "$") {
+      const start = i;
+      while (i < src.length) {
+        const cc = src[i]!;
+        if (
+          (cc >= "a" && cc <= "z") ||
+          (cc >= "A" && cc <= "Z") ||
+          (cc >= "0" && cc <= "9") ||
+          cc === "_" ||
+          cc === "$"
+        ) {
+          i++;
+        } else {
+          break;
+        }
+      }
+      const name = src.slice(start, i);
+      // Math.<fn>
+      if (name === "Math") {
+        if (src[i] !== ".") {
+          throw new Error(
+            `bare "Math" identifier at position ${start} is not allowed (use Math.min / Math.max / Math.abs / Math.floor / Math.ceil / Math.round)`,
+          );
+        }
+        i++; // skip .
+        const fnStart = i;
+        while (i < src.length) {
+          const cc = src[i]!;
+          if ((cc >= "a" && cc <= "z") || (cc >= "A" && cc <= "Z")) {
+            i++;
+          } else {
+            break;
+          }
+        }
+        const fnName = src.slice(fnStart, i);
+        if (!ALLOWED_MATH_FNS.has(fnName)) {
+          throw new Error(
+            `unsupported Math.${fnName} at position ${start} (allowed: Math.min / Math.max / Math.abs / Math.floor / Math.ceil / Math.round)`,
+          );
+        }
+        tokens.push({ kind: "math", fn: `Math.${fnName}` as MathFnName, pos: start });
+        continue;
+      }
+      // property access on other identifiers is禁止
+      if (src[i] === ".") {
+        throw new Error(
+          `property access "${name}.${src[i + 1] ?? ""}..." at position ${start} is not allowed (only Math.* namespace is accessible)`,
+        );
+      }
+      tokens.push({ kind: "id", name, pos: start });
+      continue;
+    }
+    // operators
+    if (c === "+") {
+      tokens.push({ kind: "op", op: "+", pos: i });
+      i++;
+      continue;
+    }
+    if (c === "-") {
+      // unary vs binary は parser 側で判定、 tokenizer は「-」 として emit
+      tokens.push({ kind: "op", op: "-", pos: i });
+      i++;
+      continue;
+    }
+    if (c === "*") {
+      tokens.push({ kind: "op", op: "*", pos: i });
+      i++;
+      continue;
+    }
+    if (c === "/") {
+      tokens.push({ kind: "op", op: "/", pos: i });
+      i++;
+      continue;
+    }
+    if (c === "%") {
+      tokens.push({ kind: "op", op: "%", pos: i });
+      i++;
+      continue;
+    }
+    if (c === "<") {
+      if (src[i + 1] === "=") {
+        tokens.push({ kind: "op", op: "<=", pos: i });
+        i += 2;
+      } else {
+        tokens.push({ kind: "op", op: "<", pos: i });
+        i++;
+      }
+      continue;
+    }
+    if (c === ">") {
+      if (src[i + 1] === "=") {
+        tokens.push({ kind: "op", op: ">=", pos: i });
+        i += 2;
+      } else {
+        tokens.push({ kind: "op", op: ">", pos: i });
+        i++;
+      }
+      continue;
+    }
+    if (c === "=") {
+      if (src[i + 1] === "=") {
+        tokens.push({ kind: "op", op: "==", pos: i });
+        i += 2;
+        continue;
+      }
+      throw new Error(
+        `assignment "=" at position ${i} is not allowed (use "==" for equality comparison)`,
+      );
+    }
+    if (c === "!") {
+      if (src[i + 1] === "=") {
+        tokens.push({ kind: "op", op: "!=", pos: i });
+        i += 2;
+        continue;
+      }
+      throw new Error(`unary "!" (logical not) at position ${i} is not allowed`);
+    }
+    if (c === "(") {
+      tokens.push({ kind: "lparen", pos: i });
+      i++;
+      continue;
+    }
+    if (c === ")") {
+      tokens.push({ kind: "rparen", pos: i });
+      i++;
+      continue;
+    }
+    if (c === ",") {
+      tokens.push({ kind: "comma", pos: i });
+      i++;
+      continue;
+    }
+    if (c === "?") {
+      tokens.push({ kind: "question", pos: i });
+      i++;
+      continue;
+    }
+    if (c === ":") {
+      tokens.push({ kind: "colon", pos: i });
+      i++;
+      continue;
+    }
+    throw new Error(`unexpected character "${c}" at position ${i}`);
+  }
+  return tokens;
+}
+
+/**
+ * 再帰下降 parser。 precedence (low → high):
+ *   ternary (?:) → comparison (< <= > >= == !=) → additive (+ -) → multiplicative (* / %) → unary (-) → primary
+ */
+class Parser {
+  private pos = 0;
+  constructor(private readonly tokens: Token[]) {}
+
+  private peek(): Token | undefined {
+    return this.tokens[this.pos];
+  }
+
+  private consume(): Token {
+    const t = this.tokens[this.pos];
+    if (!t) throw new Error("unexpected end of expression");
+    this.pos++;
+    return t;
+  }
+
+  private isOp(...ops: BinaryOp[]): boolean {
+    const t = this.peek();
+    return !!t && t.kind === "op" && ops.includes(t.op);
+  }
+
+  parse(): FormulaAst {
+    const ast = this.parseTernary();
+    if (this.pos < this.tokens.length) {
+      const t = this.tokens[this.pos]!;
+      throw new Error(`unexpected token after expression at position ${t.pos}`);
+    }
+    return ast;
+  }
+
+  private parseTernary(): FormulaAst {
+    const condition = this.parseComparison();
+    if (this.peek()?.kind === "question") {
+      this.consume();
+      const whenTrue = this.parseTernary();
+      const colon = this.peek();
+      if (!colon || colon.kind !== "colon") {
+        throw new Error("expected ':' in ternary expression");
+      }
+      this.consume();
+      const whenFalse = this.parseTernary();
+      return { type: "ternary", condition, whenTrue, whenFalse };
+    }
+    return condition;
+  }
+
+  private parseComparison(): FormulaAst {
+    let left = this.parseAdditive();
+    while (this.isOp("<", "<=", ">", ">=", "==", "!=")) {
+      const opTok = this.consume() as Extract<Token, { kind: "op" }>;
+      const right = this.parseAdditive();
+      left = { type: "binaryOp", op: opTok.op, left, right };
+    }
+    return left;
+  }
+
+  private parseAdditive(): FormulaAst {
+    let left = this.parseMultiplicative();
+    while (this.isOp("+", "-")) {
+      const opTok = this.consume() as Extract<Token, { kind: "op" }>;
+      const right = this.parseMultiplicative();
+      left = { type: "binaryOp", op: opTok.op, left, right };
+    }
+    return left;
+  }
+
+  private parseMultiplicative(): FormulaAst {
+    let left = this.parseUnary();
+    while (this.isOp("*", "/", "%")) {
+      const opTok = this.consume() as Extract<Token, { kind: "op" }>;
+      const right = this.parseUnary();
+      left = { type: "binaryOp", op: opTok.op, left, right };
+    }
+    return left;
+  }
+
+  private parseUnary(): FormulaAst {
+    if (this.isOp("-")) {
+      this.consume();
+      const operand = this.parseUnary();
+      return { type: "unaryOp", op: "-", operand };
+    }
+    return this.parsePrimary();
+  }
+
+  private parsePrimary(): FormulaAst {
+    const t = this.peek();
+    if (!t) throw new Error("unexpected end of expression");
+    if (t.kind === "num") {
+      this.consume();
+      return { type: "number", value: t.value };
+    }
+    if (t.kind === "id") {
+      this.consume();
+      return { type: "identifier", name: t.name };
+    }
+    if (t.kind === "math") {
+      this.consume();
+      const lparen = this.peek();
+      if (!lparen || lparen.kind !== "lparen") {
+        throw new Error(`expected '(' after ${t.fn} at position ${t.pos}`);
+      }
+      this.consume();
+      const args: FormulaAst[] = [];
+      if (this.peek()?.kind !== "rparen") {
+        args.push(this.parseTernary());
+        while (this.peek()?.kind === "comma") {
+          this.consume();
+          args.push(this.parseTernary());
+        }
+      }
+      const rparen = this.peek();
+      if (!rparen || rparen.kind !== "rparen") {
+        throw new Error(`expected ')' to close ${t.fn} at position ${t.pos}`);
+      }
+      this.consume();
+      return { type: "call", fn: t.fn, args };
+    }
+    if (t.kind === "lparen") {
+      this.consume();
+      const inner = this.parseTernary();
+      const rparen = this.peek();
+      if (!rparen || rparen.kind !== "rparen") {
+        throw new Error(`unmatched '(' at position ${t.pos}`);
+      }
+      this.consume();
+      return inner;
+    }
+    throw new Error(`unexpected token '${t.kind}' at position ${t.pos}`);
+  }
+}
+
+/**
+ * expression 文字列を parse して AST に変換する。 syntax error は Error を throw する。
+ * 空文字列は Error。
+ */
+export function parseFormula(expression: string): FormulaAst {
+  const tokens = tokenize(expression);
+  if (tokens.length === 0) {
+    throw new Error("empty formula expression");
+  }
+  return new Parser(tokens).parse();
+}
+
+/**
+ * AST 内で参照される identifier (signal 名) を全て収集する。 evaluator が signal 経由で
+ * runtime value を lookup する時の識別子リスト作成に使う。
+ */
+export function extractIdentifiers(ast: FormulaAst, out: Set<string> = new Set()): Set<string> {
+  switch (ast.type) {
+    case "number":
+      break;
+    case "identifier":
+      out.add(ast.name);
+      break;
+    case "binaryOp":
+      extractIdentifiers(ast.left, out);
+      extractIdentifiers(ast.right, out);
+      break;
+    case "unaryOp":
+      extractIdentifiers(ast.operand, out);
+      break;
+    case "ternary":
+      extractIdentifiers(ast.condition, out);
+      extractIdentifiers(ast.whenTrue, out);
+      extractIdentifiers(ast.whenFalse, out);
+      break;
+    case "call":
+      for (const arg of ast.args) {
+        extractIdentifiers(arg, out);
+      }
+      break;
+  }
+  return out;
+}

package/src/index.ts

@@ -0,0 +1,284 @@
+// reactive primitives (signal / computed / effect / batch / untrack) — base 機能 (CAR #242)、
+// interactive / animation 系 primitive (input widget / formula / event handler) の依存基盤。
+// Preact signals 相当の pull-based reactive graph、 zero runtime deps。
+export { signal, computed, effect, batch, untrack } from "./reactive";
+export type { Signal, Computed } from "./reactive";
+
+// input widget primitive (CAR #243) — builder chain `.input.slider() / .number() / .dropdown() / .toggle()` で
+// 追加、 consumer app 側 HTML widget と signal 経由で bind する。 cdl 自身は widget を描画せず metadata のみ。
+export { createInputSignals, inputDefaultValue } from "./input-signals";
+export type { InputChain } from "./builder";
+export type { CdlInput } from "./types";
+
+// formula primitive (CAR #244) — builder chain `.formula(id, "gasBase * 2")` で safe subset の
+// algebraic expression を追加、 createFormulaComputeds(diagram, signals) で computed を得て
+// signal と reactive bind する (Step 2 の computed 経路に統合)。
+export {
+  parseFormula,
+  extractIdentifiers,
+  evaluate as evaluateFormula,
+  createFormulaComputeds,
+} from "./formula";
+export type { FormulaAst, FormulaContext, BinaryOp, MathFnName } from "./formula";
+export type { CdlFormula } from "./types";
+
+// scroll-driven trigger (CAR #245) — builder chain `.animation.scroll(id, opts)` で scroll trigger を
+// 追加、 createScrollProgressSignals(diagram) で { progress signal, attach(element), detach } を得て
+// DOM element に IntersectionObserver 経由で bind、 signal.value で 0..1 progress を read。
+export {
+  createScrollProgressSignals,
+  createScrollProgressHandle,
+  computeScrollProgress,
+} from "./scroll-trigger";
+export type { ScrollProgressHandle } from "./scroll-trigger";
+export type { AnimationChain } from "./builder";
+export type { CdlScrollTrigger } from "./types";
+
+// event handler primitive (CAR #246) — builder chain `.on.click(target, handlerId)` / `.on.hover(...)` で
+// DOM event を bind、 attachEventHandlers(root, diagram, handlers) で consumer 関数 map と紐付ける。
+// handler 内で signal 更新 → SVG reactive update の flow に統合。
+export { attachEventHandlers, resolveTarget, resolveTargetAll } from "./event-handler";
+export type { InteractiveHandlerMap, InteractiveSignalsAccessor } from "./render/interactive-panel";
+export {
+  hasInteractivePrimitives,
+  computeInputSignalKey,
+  computeFormulaKey,
+  computeScrollTriggerKey,
+  computeEventBindingKey,
+  createInteractiveSignalsAccessor,
+} from "./render/interactive-panel";
+export { assertNever } from "./assert-never";
+export type { CdlEventHandler, EventAttachHandle } from "./event-handler";
+export type { EventChain } from "./builder";
+export type { CdlEventBinding, CdlEventTarget, CdlEventKind } from "./types";
+
+export { diagram } from "./builder";
+export type { DiagramBuilder, PhaseBuilder } from "./builder";
+export { compile } from "./compile";
+export { layout } from "./layout";
+export { validate } from "./validate";
+export { countEdgeCrossings, visualValidate, visualValidateLaid, visualValidateAll } from "./visual-validate";
+export type {
+  Violation,
+  VisualAxis,
+  VisualValidationReport,
+  SweepReport,
+  ValidateOptions,
+  ValidationProfile,
+} from "./visual-validate";
+// edge label の文字仕様。 下流が主題で色を上書きする時、 「その文字に何 :1 が要るか」 は
+// 大きさと太さで決まる。 下流が 22 / 19 / 700 を書き写すと、 engine 側を変えた時に下流の
+// 検査だけが古い前提で測り続ける。
+export {
+  EDGE_LABEL_TEXT,
+  WCAG_AA_LARGE,
+  WCAG_AA_NORMAL,
+  isLargeText,
+  requiredContrastRatio,
+} from "./label-text";
+export type { EdgeLabelLine, EdgeLabelTextSpec } from "./label-text";
+export { layoutWithValidation } from "./layout-with-validation";
+export type { LayoutWithValidationOptions, LayoutWithValidationResult } from "./layout-with-validation";
+export {
+  pointRectEdgeDistance,
+  rectRectOverlapArea,
+  rectRectClearance,
+  segmentsIntersect,
+} from "./layout/geometry";
+export type { Segment as GeometrySegment, Rect as GeometryRect } from "./layout/geometry";
+export { verifyDiagramDom, verifyAllDiagramsDom, cdlAdapter } from "./dom-verify";
+// 描画されない計測用の目印を取る selector。 consumer (dragon 等) も同じ要素を掴む必要があるので
+// 公開する。 文字列を写すと、 こちらが目印を変えた時に consumer が黙って何も掴まなくなる。
+export { STAGE_SVG_SELECTOR, NODE_FRAME_SELECTOR } from "./dom-verify";
+export type { Discrepancy, DiscrepancyKind, VerifyOptions, DomVerifyReport, PageLike } from "./dom-verify";
+// 目 v4 library 化前段 ... GenericDiagramSpec / DiagramAdapter 型 + 将来の独立 publish 用 core
+export type {
+  GenericDiagramSpec,
+  GenericDiscrepancy,
+  GenericDiscrepancyKind,
+  GenericVerifyOptions,
+  DiagramAdapter,
+} from "./dom-verify-core";
+// 目 v5 author intent verifier (作者意図 ↔ 実画面 一致確認)
+export { verifyAuthorIntent, verifyAuthorIntentAll } from "./author-intent-verify";
+export type {
+  IntentDiscrepancy,
+  IntentDiscrepancyKind,
+  AuthorIntentOptions,
+  AuthorIntentReport,
+} from "./author-intent-verify";
+export { CdlDiagramView } from "./render";
+export { CdlDiagramThumbnail } from "./thumbnail";
+// px-projection = world 座標 → DOM px 変換 SSOT (pixel-perfect assertion 用)
+export {
+  computeViewportScale,
+  worldToPx,
+  pxToWorld,
+  projectNode,
+  projectEdgeLabel,
+  projectPathSegment,
+  bboxClearance,
+  pointToSegmentDistance,
+} from "./layout/px-projection";
+// clearance / distance SSOT 定数 (world unit)
+export {
+  CLEARANCE_NODE_LABEL,
+  CLEARANCE_LANE_LABEL,
+  CLEARANCE_LABEL_LABEL,
+  CLEARANCE_PATH_LABEL,
+  DIST_LABEL_PATH_MIN,
+  DIST_LABEL_PATH_MAX,
+  TARGET_LABEL_PATH_DIST,
+  ARROW_ANGLE_MAX_DEG,
+  FAN_GAP,
+  DETOUR_GAP,
+} from "./layout/clearance-constants";
+// spec SSOT = positive-check axis の目標値 SSOT (CAR-421 追加、 clearance-constants.ts と分離)
+export {
+  LABEL_TO_PATH_CLEARANCE,
+  // CAR-468 追加 = routePath() init labelY SSOT (LABEL_TO_PATH_CLEARANCE + pill h/2 = 34 world、 CAR-630 で 26 → 34 復帰)
+  LABEL_INIT_CLEARANCE,
+  // CAR-518 追加 = dotted-flow edge label init clearance (marker glow radius 分拡張、 62 world、 CAR-630 で 54 → 62 復帰)
+  LABEL_INIT_CLEARANCE_DOTTED_FLOW,
+  MARKER_GLOW_RADIUS,
+  labelInitClearance,
+  EDGE_STUB_OUT,
+  DETOUR_SLOT_GAP,
+  MIN_ROW_ALIGNMENT_TOLERANCE,
+  MIN_COLUMN_ALIGNMENT_TOLERANCE,
+  SPEC_CLEARANCE_POLICY,
+  requiredSpecClearance,
+  CHAIN_SHIFT_MAX_ITER,
+  CHAIN_MIN_CLEARANCE,
+  CHAIN_SHIFT_MAX_ACCUMULATED,
+  // CAR-422 追加 = 5 axis の目標値 SSOT
+  ARROW_ENDPOINT_CENTER_TOL,
+  ROW_GAP_VARIANCE_TOL,
+  COLUMN_GAP_VARIANCE_TOL,
+  LANE_BORDER_CLEARANCE_TOL,
+  // CAR-424 追加 = near-collision policy SSOT (旧 collisions.ts CLEARANCE_POLICY を集約)
+  NEAR_COLLISION_POLICY,
+  NEAR_COLLISION_DEFAULT_MIN,
+  requiredNearClearance,
+  // #387 追加 = 下流が「この種別に rows を持たせてよいか」 「行が収まる寸法はいくつか」 を
+  // engine と同じ式で決められるようにする。 baseline / 行送り / descender は内部実装値なので
+  // 出さない (出すと下流が式を組み直せてしまい、 SSOT から逸脱する余地ができる)。
+  rendersRows,
+  requiredRowsHeight,
+} from "./layout/spec";
+// #387 追加 = rows の内容から必要 width を出す。 下流が preset の固定 w を rows に合わせて
+// 広げる際に、 engine と同じ式を使えるようにする。
+export { requiredRowsWidth } from "./kinds/row-align";
+// chain 伝搬 shift resolver (CAR-421 追加、 opt-in export)
+// CAR-426 で edge-label 用の resolveEdgeLabelOverlapsWithChain を追加、 label 層の
+// chain 伝搬解消を担当 (node 層は resolveOverlapsWithChain と役割分担)。
+// CAR-482 で resolveEdgeLabelOverlapsWithChainAndPropagate を追加、 node / lane-label 連鎖 shift 拡張版。
+export {
+  resolveOverlapsWithChain,
+  resolveEdgeLabelOverlapsWithChain,
+  resolveEdgeLabelOverlapsWithChainAndPropagate,
+} from "./layout/collisions";
+// predict-bbox = engine 予測 bbox の world 単位計算 SSOT (副次係数 COEFF 撤廃用)
+export {
+  predictLabelBBoxWorld,
+  predictNodeBBoxWorld,
+  FONT_RENDER_TOLERANCE_WORLD,
+  LABEL_SIZE_TOLERANCE_WORLD,
+  bboxDiffWorld,
+} from "./layout/predict-bbox";
+export { swimlane, flow, sequence, topology, er, stateMachine, infrastructure, classDiagram, tree, userJourney, mindMap, mindMapRadial, funnel, quadrant, chart, gantt, flowchart, network, stateMachine2 } from "./presets";
+// Text DSL は @cardenelabs/dragon に切出済 (cdl は engine only)
+export type {
+  SwimlanePreset,
+  FlowPreset,
+  FlowBuilder,
+  FlowStepInput,
+  SequencePreset,
+  SequenceBuilder,
+  SequenceStep,
+  TopologyPreset,
+  TopologyBuilder,
+  TopologyGroupBuilder,
+  TopologyContainer,
+  TopologyConnection,
+  ErPreset,
+  ErBuilder,
+  ErEntity,
+  ErRelation,
+  ErRelationCardinality,
+  StateMachinePreset,
+  StateMachineBuilder,
+  FsmState,
+  FsmTransition,
+  InfrastructurePreset,
+  InfrastructureBuilder,
+  InfraNode,
+  InfraConnection,
+  ClassDiagramPreset,
+  ClassDiagramBuilder,
+  UmlClass,
+  UmlRelation,
+  ClassRelationType,
+  TreePreset,
+  TreeBuilder,
+  TreeNode,
+  UserJourneyPreset,
+  UserJourneyBuilder,
+  JourneyStep,
+  JourneyEmotion,
+  MindMapPreset,
+  MindMapBuilder,
+  MindBranch,
+  MindMapRadialPreset,
+  MindMapRadialBuilder,
+  MindMapRadialBranch,
+  FunnelPreset,
+  FunnelBuilder,
+  FunnelStage,
+  QuadrantPreset,
+  QuadrantBuilder,
+  QuadrantItem,
+  QuadrantQuadrantLabel,
+  ChartPreset,
+  ChartBuilder,
+  ChartDatum,
+  ChartType,
+  GanttPreset,
+  GanttBuilder,
+  GanttTask,
+  FlowchartPreset,
+  FlowchartBuilder,
+  FlowchartNode,
+  FlowchartEdge,
+  FlowchartNodeShape,
+  NetworkPreset,
+  NetworkBuilder,
+  NetworkDevice,
+  NetworkLink,
+  NetworkDeviceKind,
+  StateMachine2Preset,
+  StateMachine2Builder,
+  FsmStateNested,
+  FsmTransitionExt,
+} from "./presets";
+export type {
+  CdlDiagram,
+  CdlEdge,
+  CdlLane,
+  CdlNode,
+  CdlPhase,
+  CdlState,
+  EdgeStyle,
+  LaidDiagram,
+  LaidEdge,
+  LaidLane,
+  LaidNode,
+  NodeKind,
+  Side,
+  Tone,
+} from "./types";
+// 値としての tone 一覧。 downstream (dragon の parser 等) が受理できる色名の集合を
+// 手書きせずに済ませるため公開する。
+// 値としての tone / kind 一覧。 downstream (dragon の記法一覧 / parser 等) が
+// 受理できる値の集合を手書きせずに済ませるため公開する。
+export { TONES, NODE_KINDS } from "./types";