@likec4/core 0.37.1 → 0.41.0

package/dist/esm/types/index.d.ts

@@ -0,0 +1,11 @@
+export * from './opaque';
+export * from './_common';
+export * from './theme';
+export * from './element';
+export * from './relation';
+export * from './model';
+export * from './view';
+export * from './expression';
+export * from './computed-view';
+export * from './diagram';
+export * as Expr from './expression';

package/dist/esm/types/model.d.ts

@@ -0,0 +1,14 @@
+import type { ComputedView } from './computed-view';
+import type { Element, Fqn } from './element';
+import type { Relation, RelationID } from './relation';
+import type { ElementView, ViewID } from './view';
+export interface LikeC4RawModel {
+    elements: Record<Fqn, Element>;
+    relations: Record<RelationID, Relation>;
+    views: Record<ViewID, ElementView>;
+}
+export interface LikeC4Model {
+    elements: Record<Fqn, Element>;
+    relations: Record<RelationID, Relation>;
+    views: Record<ViewID, ComputedView>;
+}

package/dist/esm/types/opaque.d.ts

@@ -0,0 +1,102 @@
+declare const tag: unique symbol;
+type Tagged<Token> = {
+    readonly [tag]: Token;
+};
+/**
+Create an opaque type, which hides its internal details from the public, and can only be created by being used explicitly.
+
+The generic type parameter can be anything. It doesn't have to be an object.
+
+[Read more about opaque types.](https://codemix.com/opaque-types-in-javascript/)
+
+There have been several discussions about adding this feature to TypeScript via the `opaque type` operator, similar to how Flow does it. Unfortunately, nothing has (yet) moved forward:
+    - [Microsoft/TypeScript#202](https://github.com/microsoft/TypeScript/issues/202)
+    - [Microsoft/TypeScript#15408](https://github.com/Microsoft/TypeScript/issues/15408)
+    - [Microsoft/TypeScript#15807](https://github.com/Microsoft/TypeScript/issues/15807)
+
+@example
+```
+import type {Opaque} from 'type-fest';
+
+type AccountNumber = Opaque<number, 'AccountNumber'>;
+type AccountBalance = Opaque<number, 'AccountBalance'>;
+
+// The `Token` parameter allows the compiler to differentiate between types, whereas "unknown" will not. For example, consider the following structures:
+type ThingOne = Opaque<string>;
+type ThingTwo = Opaque<string>;
+
+// To the compiler, these types are allowed to be cast to each other as they have the same underlying type. They are both `string & { __opaque__: unknown }`.
+// To avoid this behaviour, you would instead pass the "Token" parameter, like so.
+type NewThingOne = Opaque<string, 'ThingOne'>;
+type NewThingTwo = Opaque<string, 'ThingTwo'>;
+
+// Now they're completely separate types, so the following will fail to compile.
+function createNewThingOne (): NewThingOne {
+    // As you can see, casting from a string is still allowed. However, you may not cast NewThingOne to NewThingTwo, and vice versa.
+    return 'new thing one' as NewThingOne;
+}
+
+// This will fail to compile, as they are fundamentally different types.
+const thingTwo = createNewThingOne() as NewThingTwo;
+
+// Here's another example of opaque typing.
+function createAccountNumber(): AccountNumber {
+    return 2 as AccountNumber;
+}
+
+function getMoneyForAccount(accountNumber: AccountNumber): AccountBalance {
+    return 4 as AccountBalance;
+}
+
+// This will compile successfully.
+getMoneyForAccount(createAccountNumber());
+
+// But this won't, because it has to be explicitly passed as an `AccountNumber` type.
+getMoneyForAccount(2);
+
+// You can use opaque values like they aren't opaque too.
+const accountNumber = createAccountNumber();
+
+// This will not compile successfully.
+const newAccountNumber = accountNumber + 2;
+
+// As a side note, you can (and should) use recursive types for your opaque types to make them stronger and hopefully easier to type.
+type Person = {
+    id: Opaque<number, Person>;
+    name: string;
+};
+```
+
+@category Type
+*/
+export type Opaque<Type, Token = unknown> = Type & Tagged<Token>;
+/**
+Revert an opaque type back to its original type by removing the readonly `[tag]`.
+
+Why is this necessary?
+
+1. Use an `Opaque` type as object keys
+2. Prevent TS4058 error: "Return type of exported function has or is using name X from external module Y but cannot be named"
+
+@example
+```
+import type {Opaque, UnwrapOpaque} from 'type-fest';
+
+type AccountType = Opaque<'SAVINGS' | 'CHECKING', 'AccountType'>;
+
+const moneyByAccountType: Record<UnwrapOpaque<AccountType>, number> = {
+    SAVINGS: 99,
+    CHECKING: 0.1
+};
+
+// Without UnwrapOpaque, the following expression would throw a type error.
+const money = moneyByAccountType.SAVINGS; // TS error: Property 'SAVINGS' does not exist
+
+// Attempting to pass an non-Opaque type to UnwrapOpaque will raise a type error.
+type WontWork = UnwrapOpaque<string>;
+```
+
+@category Type
+*/
+export type UnwrapOpaque<OpaqueType extends Tagged<unknown>> = OpaqueType extends Opaque<infer Type, OpaqueType[typeof tag]> ? Type : OpaqueType;
+export {};

package/dist/esm/types/relation.d.ts

@@ -0,0 +1,22 @@
+import type { Opaque } from './opaque';
+import type { Fqn, Tag } from './element';
+import type { ThemeColor } from './theme';
+export type RelationID = Opaque<string, 'RelationID'>;
+export type RelationshipKind = Opaque<string, 'RelationshipKind'>;
+export type RelationshipLineType = 'dashed' | 'solid' | 'dotted';
+export type RelationshipArrowType = 'none' | 'normal' | 'onormal' | 'diamond' | 'odiamond' | 'crow' | 'open' | 'vee';
+export declare const DefaultLineStyle = "dashed";
+export declare const DefaultArrowType = "normal";
+export declare const DefaultRelationshipColor = "gray";
+export interface Relation {
+    readonly id: RelationID;
+    readonly source: Fqn;
+    readonly target: Fqn;
+    readonly title: string;
+    readonly tags?: Tag[];
+    readonly kind?: RelationshipKind;
+    readonly color?: ThemeColor;
+    readonly line?: RelationshipLineType;
+    readonly head?: RelationshipArrowType;
+    readonly tail?: RelationshipArrowType;
+}

package/dist/esm/types/relation.js

@@ -0,0 +1,3 @@
+export const DefaultLineStyle = "dashed";
+export const DefaultArrowType = "normal";
+export const DefaultRelationshipColor = "gray";

package/dist/esm/types/theme.d.ts

@@ -0,0 +1,26 @@
+export type ThemeColor = 'amber' | 'blue' | 'gray' | 'slate' | 'green' | 'indigo' | 'muted' | 'primary' | 'red' | 'secondary' | 'sky';
+export type HexColorLiteral = `#${string}`;
+export type ColorLiteral = HexColorLiteral;
+export interface ElementThemeColorValues {
+    fill: ColorLiteral;
+    stroke: ColorLiteral;
+    hiContrast: ColorLiteral;
+    loContrast: ColorLiteral;
+}
+export type ElementThemeColors = {
+    [key in ThemeColor]: ElementThemeColorValues;
+};
+export interface RelationshipThemeColorValues {
+    lineColor: ColorLiteral;
+    labelBgColor: ColorLiteral;
+    labelColor: ColorLiteral;
+}
+export type RelationshipThemeColors = {
+    [key in ThemeColor]: RelationshipThemeColorValues;
+};
+export interface LikeC4Theme {
+    font: 'Helvetica';
+    shadow: ColorLiteral;
+    relationships: RelationshipThemeColors;
+    elements: ElementThemeColors;
+}

package/dist/esm/types/view.d.ts

@@ -0,0 +1,61 @@
+import type { Opaque } from './opaque';
+import type { ElementShape, Fqn, Tag } from './element';
+import type { ElementExpression, Expression } from './expression';
+import type { IconUrl, NonEmptyArray } from './_common';
+import type { ThemeColor } from './theme';
+export type ViewID = Opaque<string, 'ViewID'>;
+export type ViewRuleExpression = {
+    include: Expression[];
+    exclude?: never;
+} | {
+    include?: never;
+    exclude: Expression[];
+};
+export declare function isViewRuleExpression(rule: ViewRule): rule is ViewRuleExpression;
+export interface ViewRuleStyle {
+    targets: ElementExpression[];
+    style: {
+        color?: ThemeColor;
+        shape?: ElementShape;
+        icon?: IconUrl;
+    };
+}
+export declare function isViewRuleStyle(rule: ViewRule): rule is ViewRuleStyle;
+export interface ViewRuleAutoLayout {
+    autoLayout: 'TB' | 'BT' | 'LR' | 'RL';
+}
+export declare function isViewRuleAutoLayout(rule: ViewRule): rule is ViewRuleAutoLayout;
+export type ViewRule = ViewRuleExpression | ViewRuleStyle | ViewRuleAutoLayout;
+export interface BasicElementView {
+    readonly id: ViewID;
+    readonly viewOf?: Fqn;
+    readonly title: string | null;
+    readonly description: string | null;
+    readonly tags: NonEmptyArray<Tag> | null;
+    readonly links: NonEmptyArray<string> | null;
+    readonly rules: ViewRule[];
+    /**
+     * URI to the source file of this view.
+     * Undefined if the view is auto-generated.
+     */
+    readonly docUri?: string;
+    /**
+     * For all views we find common ancestor path.
+     * This is used to generate relative paths, i.e.:
+     * - "" for views in the common ancestor directory (or root)
+     * - "subdir" for views in "<root>/subdir"
+     * - "subdir/subdir1" for views in "<root>/subdir/subdir1"
+     *
+     * Undefined if the view is auto-generated.
+     */
+    readonly relativePath?: string;
+}
+export interface StrictElementView extends BasicElementView {
+    readonly viewOf: Fqn;
+}
+export declare function isStrictElementView(view: ElementView): view is StrictElementView;
+export interface ExtendsElementView extends BasicElementView {
+    readonly extends: ViewID;
+}
+export declare function isExtendsElementView(view: ElementView): view is ExtendsElementView;
+export type ElementView = StrictElementView | ExtendsElementView | BasicElementView;

package/dist/{types → esm/types}/view.js

@@ -1,5 +1,5 @@
 export function isViewRuleExpression(rule) {
-  return "exprs" in rule && "isInclude" in rule;
+  return "include" in rule && Array.isArray(rule.include) || "exclude" in rule && Array.isArray(rule.exclude);
 }
 export function isViewRuleStyle(rule) {
   return "style" in rule && "targets" in rule;

package/dist/esm/utils/fqn.d.ts

@@ -0,0 +1,33 @@
+import type { Element, Fqn } from '../types';
+export declare function nameFromFqn(fqn: Fqn): string;
+export declare function isAncestor<E extends {
+    id: Fqn;
+}>(...args: [ancestor: Fqn, another: Fqn] | [ancestor: E, another: E]): boolean;
+export declare function isSameHierarchy<E extends {
+    id: Fqn;
+}>(one: E | Fqn, another: E | Fqn): boolean;
+export declare function isDescendantOf<E extends {
+    id: Fqn;
+}>(ancestors: E[]): (e: E) => boolean;
+export declare function notDescendantOf(ancestors: Element[]): (e: Element) => boolean;
+export declare function commonAncestor(first: Fqn, second: Fqn): Fqn | null;
+export declare function parentFqn(fqn: Fqn): Fqn | null;
+/**
+ * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
+ * (from closest to root)
+ */
+export declare function ancestorsFqn(fqn: Fqn): Fqn[];
+/**
+ * Compares two fully qualified names (fqns) hierarchically based on their depth.
+ * From parent nodes to leaves
+ *
+ * @param {string} a - The first fqn to compare.
+ * @param {string} b - The second fqn to compare.
+ * @returns {number} - 0 if the fqns have the same depth.
+ *                    - Positive number if a is deeper than b.
+ *                    - Negative number if b is deeper than a.
+ */
+export declare function compareFqnHierarchically(a: string, b: string): number;
+export declare function compareByFqnHierarchically<T extends {
+    id: Fqn;
+}>(a: T, b: T): number;

package/dist/{utils → esm/utils}/fqn.js

@@ -13,10 +13,10 @@ export function isAncestor(...args) {
   const another = isString(args[1]) ? args[1] : args[1].id;
   return another.startsWith(ancestor + ".");
 }
-export function isSameHierarchy(...args) {
-  const one = isString(args[0]) ? args[0] : args[0].id;
-  const another = isString(args[1]) ? args[1] : args[1].id;
-  return one === another || another.startsWith(one + ".") || one.startsWith(another + ".");
+export function isSameHierarchy(one, another) {
+  const first = isString(one) ? one : one.id;
+  const second = isString(another) ? another : another.id;
+  return first === second || second.startsWith(first + ".") || first.startsWith(second + ".");
 }
 export function isDescendantOf(ancestors) {
   const predicates = ancestors.flatMap((a) => [(e) => e.id === a.id, (e) => isAncestor(a, e)]);
@@ -52,6 +52,18 @@ export function parentFqn(fqn) {
   }
   return null;
 }
+export function ancestorsFqn(fqn) {
+  const path = fqn.split(".");
+  path.pop();
+  if (path.length === 0) {
+    return [];
+  }
+  return path.reduce((acc, _, idx) => {
+    const ancestor = path.slice(0, idx + 1).join(".");
+    acc.unshift(ancestor);
+    return acc;
+  }, []);
+}
 export function compareFqnHierarchically(a, b) {
   const depthA = a.split(".").length;
   const depthB = b.split(".").length;

package/dist/esm/utils/guards.d.ts

@@ -0,0 +1,4 @@
+import type { NonEmptyArray } from '../types';
+export { hasAtLeast } from 'remeda';
+export declare function isString(value: unknown): value is string;
+export declare function isNonEmptyArray<A>(arr: ArrayLike<A>): arr is NonEmptyArray<A>;

package/dist/esm/utils/guards.js

@@ -0,0 +1,7 @@
+export { hasAtLeast } from "remeda";
+export function isString(value) {
+  return value != null && typeof value === "string";
+}
+export function isNonEmptyArray(arr) {
+  return arr.length > 0;
+}

package/dist/esm/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from './fqn';
+export * from './guards';
+export * from './relations';

package/dist/{utils → esm/utils}/index.js

@@ -1,4 +1,3 @@
 export * from "./fqn.js";
 export * from "./guards.js";
-export * from "./compute-node-levels.js";
 export * from "./relations.js";

package/dist/esm/utils/relations.d.ts

@@ -0,0 +1,25 @@
+import type { Fqn } from '../types';
+type Relation = {
+    source: string;
+    target: string;
+};
+type RelationPredicate = (rel: Relation) => boolean;
+export declare const compareRelations: <T extends {
+    source: string;
+    target: string;
+}>(a: T, b: T) => number;
+export declare const Relations: {
+    readonly isInside: (parent: Fqn) => RelationPredicate;
+    readonly isBetween: (source: Fqn, target: Fqn) => RelationPredicate;
+    readonly isAnyBetween: (source: Fqn, target: Fqn) => RelationPredicate;
+    readonly isIncoming: (target: Fqn) => RelationPredicate;
+    readonly isOutgoing: (source: Fqn) => RelationPredicate;
+    readonly isAnyInOut: (source: Fqn) => RelationPredicate;
+    readonly hasRelation: <R extends {
+        source: Fqn;
+        target: Fqn;
+    }>(rel: R) => <E extends {
+        id: Fqn;
+    }>(element: E) => boolean;
+};
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@likec4/core",
-  "version": "0.37.1",
+  "version": "0.41.0",
   "license": "MIT",
   "homepage": "https://likec4.dev",
   "author": "Denis Davydkov <denis@davydkov.com>",
@@ -11,105 +11,88 @@
   },
   "bugs": "https://github.com/likec4/likec4/issues",
   "scripts": {
-    "compile": "tsc --noEmit",
-    "build": "tsc",
-    "prepack": "unbuild",
-    "dev": "tsc --watch",
+    "typecheck": "tsc --noEmit",
+    "build": "unbuild",
+    "prepack": "run clean && run build",
     "lint": "run -T eslint src/ --fix",
     "test": "run -T vitest run",
-    "test:watch": "run -T vitest",
     "clean": "run -T rimraf dist"
   },
   "files": [
-    "dist"
+    "dist",
+    "!**/*.spec.*",
+    "!**/*.map"
   ],
   "type": "module",
   "sideEffects": false,
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
-    },
-    "./types": {
       "types": "./dist/types/index.d.ts",
-      "import": "./dist/types/index.js",
-      "require": "./dist/types/index.cjs"
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js"
     },
     "./colors": {
-      "types": "./dist/colors.d.ts",
-      "import": "./dist/colors.js",
-      "require": "./dist/colors.cjs"
+      "types": "./dist/types/colors/index.d.ts",
+      "import": "./dist/esm/colors/index.js",
+      "require": "./dist/cjs/colors/index.js"
     },
-    "./errors": {
-      "types": "./dist/errors/index.d.ts",
-      "import": "./dist/errors/index.js",
-      "require": "./dist/errors/index.cjs"
+    "./types": {
+      "types": "./dist/types/types/index.d.ts",
+      "import": "./dist/esm/types/index.js",
+      "require": "./dist/cjs/types/index.js"
     },
     "./utils": {
-      "types": "./dist/utils/index.d.ts",
-      "import": "./dist/utils/index.js",
-      "require": "./dist/utils/index.cjs"
-    },
-    "./compute-view": {
-      "types": "./dist/compute-view/index.d.ts",
-      "import": "./dist/compute-view/index.js",
-      "require": "./dist/compute-view/index.cjs"
+      "types": "./dist/types/utils/index.d.ts",
+      "import": "./dist/esm/utils/index.js",
+      "require": "./dist/cjs/utils/index.js"
     }
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
     "access": "public",
-    "main": "./dist/index.cjs",
-    "module": "./dist/index.js",
-    "types": "./dist/index.d.ts",
+    "main": "./dist/cjs/index.js",
+    "module": "./dist/esm/index.js",
+    "types": "./dist/types/index.d.ts",
     "exports": {
       ".": {
-        "types": "./dist/index.d.ts",
-        "import": "./dist/index.js",
-        "require": "./dist/index.cjs"
-      },
-      "./types": {
         "types": "./dist/types/index.d.ts",
-        "import": "./dist/types/index.js",
-        "require": "./dist/types/index.cjs"
+        "import": "./dist/esm/index.js",
+        "require": "./dist/cjs/index.js"
       },
       "./colors": {
-        "types": "./dist/colors.d.ts",
-        "import": "./dist/colors.js",
-        "require": "./dist/colors.cjs"
+        "types": "./dist/types/colors/index.d.ts",
+        "import": "./dist/esm/colors/index.js",
+        "require": "./dist/cjs/colors/index.js"
       },
-      "./errors": {
-        "types": "./dist/errors/index.d.ts",
-        "import": "./dist/errors/index.js",
-        "require": "./dist/errors/index.cjs"
+      "./types": {
+        "types": "./dist/types/types/index.d.ts",
+        "import": "./dist/esm/types/index.js",
+        "require": "./dist/cjs/types/index.js"
       },
       "./utils": {
-        "types": "./dist/utils/index.d.ts",
-        "import": "./dist/utils/index.js",
-        "require": "./dist/utils/index.cjs"
-      },
-      "./compute-view": {
-        "types": "./dist/compute-view/index.d.ts",
-        "import": "./dist/compute-view/index.js",
-        "require": "./dist/compute-view/index.cjs"
+        "types": "./dist/types/utils/index.d.ts",
+        "import": "./dist/esm/utils/index.js",
+        "require": "./dist/cjs/utils/index.js"
       }
     }
   },
   "dependencies": {
-    "@dagrejs/graphlib": "^2.1.13",
     "rambdax": "^9.1.1",
-    "remeda": "^1.24.0",
+    "remeda": "^1.27.1",
     "safe-stable-stringify": "^2.4.3",
     "ts-custom-error": "^3.3.1"
   },
   "devDependencies": {
+    "execa": "^8.0.1",
     "typescript": "^5.2.2",
     "unbuild": "^2.0.0",
-    "vitest": "^0.34.4"
+    "vitest": "^0.34.6"
+  },
+  "packageManager": "yarn@3.6.4",
+  "volta": {
+    "extends": "../../package.json"
   },
-  "packageManager": "yarn@3.6.3"
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/types/index.d.ts"
 }

package/dist/colors.cjs

@@ -1,124 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.defaultTheme = exports.RelationColors = exports.Colors = void 0;
-const blue = {
-  // fill: colors.blue[500],
-  // stroke: colors.blue[600],
-  // hiContrast: colors.blue[50],
-  // loContrast: colors.blue[100],
-  fill: "#3b82f6",
-  stroke: "#2563eb",
-  hiContrast: "#eff6ff",
-  loContrast: "#dbeafe"
-};
-const sky = {
-  // fill: colors.sky[600],
-  // stroke: colors.sky[700],
-  // hiContrast: colors.sky[50],
-  // loContrast: colors.sky[100],
-  fill: "#0284c7",
-  stroke: "#0369a1",
-  hiContrast: "#f0f9ff",
-  loContrast: "#e0f2fe"
-};
-const slate = {
-  // fill: colors.slate[500],
-  // stroke: colors.slate[600],
-  // hiContrast: colors.slate[50],
-  // loContrast: colors.slate[200],
-  fill: "#64748b",
-  stroke: "#475569",
-  hiContrast: "#f8fafc",
-  loContrast: "#e2e8f0"
-};
-const RelationColors = {
-  // lineColor: colors.neutral[400],
-  // labelColor: colors.neutral[300],
-  lineColor: "#a3a3a3",
-  labelColor: "#d4d4d4"
-};
-exports.RelationColors = RelationColors;
-const Colors = {
-  primary: blue,
-  blue,
-  secondary: sky,
-  sky,
-  muted: slate,
-  slate,
-  gray: {
-    // fill: colors.neutral[500],
-    // stroke: colors.neutral[600],
-    // hiContrast: colors.neutral[50],
-    // loContrast: colors.neutral[200],
-    fill: "#737373",
-    stroke: "#525252",
-    hiContrast: "#fafafa",
-    loContrast: "#e5e5e5"
-  },
-  red: {
-    // fill: colors.red[500],
-    // stroke: colors.red[600],
-    // hiContrast: colors.red[50],
-    // loContrast: colors.red[200],
-    fill: "#ef4444",
-    stroke: "#dc2626",
-    // hiContrast: '#fef2f2',
-    // loContrast: '#fecaca',
-    hiContrast: "#111827",
-    // colors.gray[900],
-    loContrast: "#1f2937"
-    // colors.gray[800],
-  },
-
-  green: {
-    // fill: colors.green[600],
-    // stroke: colors.green[700],
-    // hiContrast: colors.green[50],
-    // loContrast: colors.green[200],
-    fill: "#16a34a",
-    stroke: "#15803d",
-    hiContrast: "#111827",
-    // colors.gray[900],
-    // hiContrast: '#f0fdf4',
-    loContrast: "#1f2937"
-    // colors.gray[800],
-    // loContrast: '#bbf7d0'
-  },
-
-  amber: {
-    // fill: colors.amber[600],
-    // stroke: colors.amber[700],
-    // hiContrast: colors.amber[50],
-    // loContrast: colors.amber[200],
-    fill: "#d97706",
-    stroke: "#b45309",
-    // hiContrast: '#fffbeb',
-    // loContrast: '#fde68a',
-    hiContrast: "#111827",
-    // colors.gray[900],
-    loContrast: "#1f2937"
-    // colors.gray[800],
-  },
-
-  indigo: {
-    // fill: colors.indigo[500],
-    // stroke: colors.indigo[600],
-    // hiContrast: colors.indigo[50],
-    // loContrast: colors.indigo[200],
-    fill: "#6366f1",
-    stroke: "#4f46e5",
-    hiContrast: "#eef2ff",
-    loContrast: "#c7d2fe"
-  }
-};
-exports.Colors = Colors;
-const defaultTheme = {
-  font: "Helvetica",
-  shadow: "#0a0a0a",
-  relation: RelationColors,
-  colors: Colors
-};
-exports.defaultTheme = defaultTheme;