@diagrammo/dgmo 0.0.1

package/dist/index.d.cts

@@ -0,0 +1,685 @@
+import { ChartConfiguration } from 'chart.js';
+import { EChartsOption } from 'echarts';
+import * as d3Scale from 'd3-scale';
+
+/**
+ * Framework identifiers used by the .dgmo router.
+ * Maps to the existing preview components and export paths.
+ */
+type DgmoFramework = 'chartjs' | 'echart' | 'd3' | 'mermaid';
+/**
+ * Maps every supported chart type string to its backing framework.
+ *
+ * Chart.js: standard chart types (bar, line, pie, etc.)
+ * ECharts:  scatter, flow/relationship diagrams, math, heatmap
+ * D3:       slope, wordcloud, arc diagram, timeline
+ */
+declare const DGMO_CHART_TYPE_MAP: Record<string, DgmoFramework>;
+/**
+ * Returns the framework for a given chart type, or `null` if unknown.
+ */
+declare function getDgmoFramework(chartType: string): DgmoFramework | null;
+/**
+ * Extracts the `chart:` type value from raw file content.
+ * Falls back to inference when no explicit `chart:` line is found
+ * (e.g. content containing `->` is inferred as `sequence`).
+ */
+declare function parseDgmoChartType(content: string): string | null;
+
+/**
+ * Color definitions for a single mode (light or dark).
+ * 10 semantic UI colors + 9 named accent colors = 19 total.
+ */
+interface PaletteColors {
+    /** Main background (#eceff4 light / #2e3440 dark for Nord) */
+    bg: string;
+    /** Cards, panels (#e5e9f0 / #3b4252) */
+    surface: string;
+    /** Popovers, dropdowns (#e5e9f0 / #434c5e) */
+    overlay: string;
+    /** Borders, dividers, muted (#d8dee9 / #4c566a) */
+    border: string;
+    /** Primary text (#2e3440 / #eceff4) */
+    text: string;
+    /** Secondary/diminished text (#4c566a / #d8dee9) */
+    textMuted: string;
+    /** Primary accent — buttons, links */
+    primary: string;
+    /** Secondary accent */
+    secondary: string;
+    /** Tertiary accent */
+    accent: string;
+    /** Error/danger */
+    destructive: string;
+    /**
+     * Used for: inline annotations (red), pie charts, cScale,
+     * series rotation, journey actors, Gantt tasks.
+     */
+    colors: {
+        red: string;
+        orange: string;
+        yellow: string;
+        green: string;
+        blue: string;
+        purple: string;
+        teal: string;
+        cyan: string;
+        gray: string;
+    };
+}
+/**
+ * Complete palette definition. One object per color scheme.
+ * This is what palette authors create — the single artifact for NFR1.
+ */
+interface PaletteConfig {
+    /** Registry key: 'nord', 'solarized', 'catppuccin' */
+    id: string;
+    /** Display name: 'Nord', 'Solarized', 'Catppuccin' */
+    name: string;
+    /** Light mode color definitions */
+    light: PaletteColors;
+    /** Dark mode color definitions */
+    dark: PaletteColors;
+}
+
+/** Validate that a hex string is well-formed (#RGB or #RRGGBB). */
+declare function isValidHex(value: string): boolean;
+/**
+ * Register a palette. Called at module initialization.
+ * Validates that all 19 color fields per mode are present and valid hex.
+ * Throws on malformed palettes to catch errors at startup, not at render time.
+ */
+declare function registerPalette(palette: PaletteConfig): void;
+/** Get palette by id. Returns Nord if id is unrecognized (FR10). */
+declare function getPalette(id: string): PaletteConfig;
+/** List all registered palettes (for the selector UI). */
+declare function getAvailablePalettes(): PaletteConfig[];
+
+/** Convert hex (#RRGGBB or #RGB) to { h, s, l } with h in degrees, s/l as percentages. */
+declare function hexToHSL(hex: string): {
+    h: number;
+    s: number;
+    l: number;
+};
+/** Convert { h (degrees), s (%), l (%) } back to #RRGGBB hex string. */
+declare function hslToHex(h: number, s: number, l: number): string;
+/** Convert hex to "H S% L%" string for CSS custom properties. */
+declare function hexToHSLString(hex: string): string;
+/**
+ * Derive a muted (desaturated, darkened) variant of a color.
+ * Used by the Mermaid theme generator for dark-mode fills.
+ *
+ * Algorithm: cap saturation at 35% and lightness at 36%.
+ */
+declare function mute(hex: string): string;
+/**
+ * Blend a color toward white (light mode quadrant fills).
+ * amount: 0 = original, 1 = white
+ */
+declare function tint(hex: string, amount: number): string;
+/**
+ * Blend a color toward a dark base (dark mode quadrant fills).
+ * amount: 0 = original, 1 = base
+ */
+declare function shade(hex: string, base: string, amount: number): string;
+/**
+ * Pick a text color that contrasts against `bg`.
+ * Returns `darkText` when background is light (luminance > 0.179),
+ * `lightText` when background is dark.
+ * Threshold 0.179 is the standard WCAG midpoint for the contrast flip.
+ */
+declare function contrastText(bg: string, lightText: string, darkText: string): string;
+/** Derive the 8-color series rotation from a palette's named colors. */
+declare function getSeriesColors(palette: PaletteColors): string[];
+
+declare const nordPalette: PaletteConfig;
+
+declare const solarizedPalette: PaletteConfig;
+
+declare const catppuccinPalette: PaletteConfig;
+
+declare const rosePinePalette: PaletteConfig;
+
+declare const gruvboxPalette: PaletteConfig;
+
+declare const tokyoNightPalette: PaletteConfig;
+
+declare const oneDarkPalette: PaletteConfig;
+
+declare const boldPalette: PaletteConfig;
+
+/**
+ * Generates ~121 Mermaid theme variables from palette tokens.
+ * Replaces the hardcoded lightThemeVars/darkThemeVars objects.
+ *
+ * Dark mode fills use `mute()` to derive desaturated variants
+ * that are readable with light text.
+ */
+declare function buildMermaidThemeVars(colors: PaletteColors, isDark: boolean): Record<string, string>;
+/**
+ * Generates custom CSS overrides for Mermaid SVGs.
+ * Handles git graph label backgrounds and dark-mode text readability.
+ */
+declare function buildThemeCSS(palette: PaletteColors, isDark: boolean): string;
+
+type ChartJsChartType = 'bar' | 'line' | 'pie' | 'doughnut' | 'area' | 'polar-area' | 'radar' | 'bar-stacked';
+interface ChartJsDataPoint {
+    label: string;
+    value: number;
+    extraValues?: number[];
+    color?: string;
+    lineNumber: number;
+}
+interface ParsedChartJs {
+    type: ChartJsChartType;
+    title?: string;
+    series?: string;
+    xlabel?: string;
+    ylabel?: string;
+    seriesNames?: string[];
+    seriesNameColors?: (string | undefined)[];
+    orientation?: 'horizontal' | 'vertical';
+    color?: string;
+    label?: string;
+    data: ChartJsDataPoint[];
+    error?: string;
+}
+
+/**
+ * Parses the simple chartjs text format into a structured object.
+ *
+ * Format:
+ * ```
+ * chart: bar
+ * title: My Chart
+ * series: Revenue
+ *
+ * Jan: 120
+ * Feb: 200
+ * Mar: 150
+ * ```
+ */
+declare function parseChartJs(content: string, palette?: PaletteColors): ParsedChartJs;
+/**
+ * Converts parsed chartjs data to a Chart.js configuration object.
+ */
+declare function buildChartJsConfig(parsed: ParsedChartJs, palette: PaletteColors, _isDark: boolean): ChartConfiguration;
+
+type EChartsChartType = 'sankey' | 'chord' | 'function' | 'scatter' | 'heatmap' | 'funnel';
+interface EChartsDataPoint {
+    label: string;
+    value: number;
+    color?: string;
+    lineNumber: number;
+}
+interface ParsedSankeyLink {
+    source: string;
+    target: string;
+    value: number;
+    lineNumber: number;
+}
+interface ParsedFunction {
+    name: string;
+    expression: string;
+    color?: string;
+    lineNumber: number;
+}
+interface ParsedScatterPoint {
+    name: string;
+    x: number;
+    y: number;
+    size?: number;
+    color?: string;
+    category?: string;
+    lineNumber: number;
+}
+interface ParsedHeatmapRow {
+    label: string;
+    values: number[];
+    lineNumber: number;
+}
+interface ParsedEChart {
+    type: EChartsChartType;
+    title?: string;
+    series?: string;
+    seriesNames?: string[];
+    seriesNameColors?: (string | undefined)[];
+    data: EChartsDataPoint[];
+    links?: ParsedSankeyLink[];
+    functions?: ParsedFunction[];
+    scatterPoints?: ParsedScatterPoint[];
+    heatmapRows?: ParsedHeatmapRow[];
+    columns?: string[];
+    rows?: string[];
+    xRange?: {
+        min: number;
+        max: number;
+    };
+    xlabel?: string;
+    ylabel?: string;
+    sizelabel?: string;
+    showLabels?: boolean;
+    categoryColors?: Record<string, string>;
+    error?: string;
+}
+
+/**
+ * Parses the simple echart text format into a structured object.
+ *
+ * Format:
+ * ```
+ * chart: bar
+ * title: My Chart
+ * series: Revenue
+ *
+ * Jan: 120
+ * Feb: 200
+ * Mar: 150
+ * ```
+ */
+declare function parseEChart(content: string, palette?: PaletteColors): ParsedEChart;
+/**
+ * Converts parsed echart data to ECharts option object.
+ */
+declare function buildEChartsOption(parsed: ParsedEChart, palette: PaletteColors, _isDark: boolean): EChartsOption;
+
+type D3ChartType = 'slope' | 'wordcloud' | 'arc' | 'timeline' | 'venn' | 'quadrant' | 'sequence';
+interface D3DataItem {
+    label: string;
+    values: number[];
+    color: string | null;
+    lineNumber: number;
+}
+interface WordCloudWord {
+    text: string;
+    weight: number;
+    lineNumber: number;
+}
+type WordCloudRotate = 'none' | 'mixed' | 'angled';
+interface WordCloudOptions {
+    rotate: WordCloudRotate;
+    max: number;
+    minSize: number;
+    maxSize: number;
+}
+interface ArcLink {
+    source: string;
+    target: string;
+    value: number;
+    color: string | null;
+    lineNumber: number;
+}
+type ArcOrder = 'appearance' | 'name' | 'group' | 'degree';
+interface ArcNodeGroup {
+    name: string;
+    nodes: string[];
+    color: string | null;
+    lineNumber: number;
+}
+type TimelineSort = 'time' | 'group';
+interface TimelineEvent {
+    date: string;
+    endDate: string | null;
+    label: string;
+    group: string | null;
+    lineNumber: number;
+    uncertain?: boolean;
+}
+interface TimelineGroup {
+    name: string;
+    color: string | null;
+    lineNumber: number;
+}
+interface TimelineEra {
+    startDate: string;
+    endDate: string;
+    label: string;
+    color: string | null;
+}
+interface TimelineMarker {
+    date: string;
+    label: string;
+    color: string | null;
+    lineNumber: number;
+}
+interface VennSet {
+    name: string;
+    size: number;
+    color: string | null;
+    label: string | null;
+    lineNumber: number;
+}
+interface VennOverlap {
+    sets: string[];
+    size: number;
+    label: string | null;
+    lineNumber: number;
+}
+interface QuadrantLabel$1 {
+    text: string;
+    color: string | null;
+    lineNumber: number;
+}
+interface QuadrantPoint {
+    label: string;
+    x: number;
+    y: number;
+    lineNumber: number;
+}
+interface QuadrantLabels {
+    topRight: QuadrantLabel$1 | null;
+    topLeft: QuadrantLabel$1 | null;
+    bottomLeft: QuadrantLabel$1 | null;
+    bottomRight: QuadrantLabel$1 | null;
+}
+interface ParsedD3 {
+    type: D3ChartType | null;
+    title: string | null;
+    orientation: 'horizontal' | 'vertical';
+    periods: string[];
+    data: D3DataItem[];
+    words: WordCloudWord[];
+    cloudOptions: WordCloudOptions;
+    links: ArcLink[];
+    arcOrder: ArcOrder;
+    arcNodeGroups: ArcNodeGroup[];
+    timelineEvents: TimelineEvent[];
+    timelineGroups: TimelineGroup[];
+    timelineEras: TimelineEra[];
+    timelineMarkers: TimelineMarker[];
+    timelineSort: TimelineSort;
+    timelineScale: boolean;
+    timelineSwimlanes: boolean;
+    vennSets: VennSet[];
+    vennOverlaps: VennOverlap[];
+    vennShowValues: boolean;
+    quadrantLabels: QuadrantLabels;
+    quadrantPoints: QuadrantPoint[];
+    quadrantXAxis: [string, string] | null;
+    quadrantXAxisLineNumber: number | null;
+    quadrantYAxis: [string, string] | null;
+    quadrantYAxisLineNumber: number | null;
+    quadrantTitleLineNumber: number | null;
+    error: string | null;
+}
+
+/**
+ * Converts a date string (YYYY, YYYY-MM, YYYY-MM-DD) to a fractional year number.
+ */
+declare function parseTimelineDate(s: string): number;
+/**
+ * Adds a duration to a date string and returns the resulting date string.
+ * Supports: d (days), w (weeks), m (months), y (years)
+ * Supports decimals up to 2 places (e.g., 1.25y = 1 year 3 months)
+ * Preserves the precision of the input date (YYYY, YYYY-MM, or YYYY-MM-DD).
+ */
+declare function addDurationToDate(startDate: string, amount: number, unit: 'd' | 'w' | 'm' | 'y'): string;
+/**
+ * Parses D3 chart text format into structured data.
+ */
+declare function parseD3(content: string, palette?: PaletteColors): ParsedD3;
+/**
+ * Renders a slope chart into the given container using D3.
+ */
+declare function renderSlopeChart(container: HTMLDivElement, parsed: ParsedD3, palette: PaletteColors, isDark: boolean, onClickItem?: (lineNumber: number) => void): void;
+/**
+ * Orders arc diagram nodes based on the selected ordering strategy.
+ */
+declare function orderArcNodes(links: ArcLink[], order: ArcOrder, groups: ArcNodeGroup[]): string[];
+/**
+ * Renders an arc diagram into the given container using D3.
+ */
+declare function renderArcDiagram(container: HTMLDivElement, parsed: ParsedD3, palette: PaletteColors, _isDark: boolean, onClickItem?: (lineNumber: number) => void): void;
+/**
+ * Converts a DSL date string (YYYY, YYYY-MM, YYYY-MM-DD) to a human-readable label.
+ *   '1718'       → '1718'
+ *   '1718-05'    → 'May 1718'
+ *   '1718-05-22' → 'May 22, 1718'
+ */
+declare function formatDateLabel(dateStr: string): string;
+/**
+ * Computes adaptive tick marks for a timeline scale.
+ * - Multi-year spans → year ticks
+ * - Within ~1 year → month ticks
+ * - Within ~3 months → week ticks (1st, 8th, 15th, 22nd)
+ *
+ * Optional boundary parameters add ticks at exact data start/end:
+ * - boundaryStart/boundaryEnd: numeric date values
+ * - boundaryStartLabel/boundaryEndLabel: formatted labels for those dates
+ */
+declare function computeTimeTicks(domainMin: number, domainMax: number, scale: d3Scale.ScaleLinear<number, number>, boundaryStart?: number, boundaryEnd?: number, boundaryStartLabel?: string, boundaryEndLabel?: string): {
+    pos: number;
+    label: string;
+}[];
+/**
+ * Renders a timeline chart into the given container using D3.
+ * Supports horizontal (default) and vertical orientation.
+ */
+declare function renderTimeline(container: HTMLDivElement, parsed: ParsedD3, palette: PaletteColors, isDark: boolean, onClickItem?: (lineNumber: number) => void): void;
+/**
+ * Renders a word cloud into the given container using d3-cloud.
+ */
+declare function renderWordCloud(container: HTMLDivElement, parsed: ParsedD3, palette: PaletteColors, _isDark: boolean, onClickItem?: (lineNumber: number) => void): void;
+declare function renderVenn(container: HTMLDivElement, parsed: ParsedD3, palette: PaletteColors, isDark: boolean, onClickItem?: (lineNumber: number) => void): void;
+/**
+ * Renders a quadrant chart using D3.
+ * Displays 4 colored quadrant regions, axis labels, quadrant labels, and data points.
+ */
+declare function renderQuadrant(container: HTMLDivElement, parsed: ParsedD3, palette: PaletteColors, isDark: boolean, onClickItem?: (lineNumber: number) => void): void;
+/**
+ * Renders a D3 chart to an SVG string for export.
+ * Creates a detached DOM element, renders into it, extracts the SVG, then cleans up.
+ */
+declare function renderD3ForExport(content: string, theme: 'light' | 'dark' | 'transparent', palette?: PaletteColors): Promise<string>;
+
+/**
+ * Participant types that can be declared via "Name is a type" syntax.
+ */
+type ParticipantType = 'default' | 'service' | 'database' | 'actor' | 'queue' | 'cache' | 'gateway' | 'external' | 'networking' | 'frontend';
+/**
+ * A declared or inferred participant in the sequence diagram.
+ */
+interface SequenceParticipant {
+    /** Internal identifier (e.g. "AuthService") */
+    id: string;
+    /** Display label — uses aka alias if provided, otherwise id */
+    label: string;
+    /** Participant shape type */
+    type: ParticipantType;
+    /** Source line number (1-based) */
+    lineNumber: number;
+    /** Explicit layout position override (0-based from left, negative from right) */
+    position?: number;
+}
+/**
+ * A message between two participants.
+ * Placeholder for future stories — included in the interface now for completeness.
+ */
+interface SequenceMessage {
+    from: string;
+    to: string;
+    label: string;
+    returnLabel?: string;
+    lineNumber: number;
+    async?: boolean;
+}
+/**
+ * A conditional or loop block in the sequence diagram.
+ */
+interface SequenceBlock {
+    kind: 'block';
+    type: 'if' | 'loop' | 'parallel';
+    label: string;
+    children: SequenceElement[];
+    elseChildren: SequenceElement[];
+    lineNumber: number;
+}
+/**
+ * A labeled horizontal divider between message phases.
+ */
+interface SequenceSection {
+    kind: 'section';
+    label: string;
+    color?: string;
+    lineNumber: number;
+}
+type SequenceElement = SequenceMessage | SequenceBlock | SequenceSection;
+declare function isSequenceBlock(el: SequenceElement): el is SequenceBlock;
+/**
+ * A named group of participants rendered as a labeled box.
+ */
+interface SequenceGroup {
+    name: string;
+    color?: string;
+    participantIds: string[];
+    lineNumber: number;
+}
+/**
+ * Parsed result from a .dgmo sequence diagram.
+ */
+interface ParsedSequenceDgmo {
+    title: string | null;
+    participants: SequenceParticipant[];
+    messages: SequenceMessage[];
+    elements: SequenceElement[];
+    groups: SequenceGroup[];
+    sections: SequenceSection[];
+    options: Record<string, string>;
+    error: string | null;
+}
+/**
+ * Parse a .dgmo file with `chart: sequence` into a structured representation.
+ */
+declare function parseSequenceDgmo(content: string): ParsedSequenceDgmo;
+/**
+ * Detect whether raw content looks like a sequence diagram.
+ * Used by the chart type inference logic.
+ */
+declare function looksLikeSequence(content: string): boolean;
+
+/**
+ * Infer participant type from a name using the ordered rules table.
+ * Returns 'default' if no rule matches.
+ */
+declare function inferParticipantType(name: string): ParticipantType;
+/**
+ * Number of rules in the table. Exported for test assertions.
+ */
+declare const RULE_COUNT: number;
+
+interface QuadrantLabel {
+    text: string;
+    color: string | null;
+    lineNumber: number;
+}
+interface ParsedQuadrant {
+    title: string | null;
+    titleLineNumber: number | null;
+    xAxis: [string, string] | null;
+    xAxisLineNumber: number | null;
+    yAxis: [string, string] | null;
+    yAxisLineNumber: number | null;
+    quadrants: {
+        topRight: QuadrantLabel | null;
+        topLeft: QuadrantLabel | null;
+        bottomLeft: QuadrantLabel | null;
+        bottomRight: QuadrantLabel | null;
+    };
+    points: {
+        label: string;
+        x: number;
+        y: number;
+        lineNumber: number;
+    }[];
+    error: string | null;
+}
+/**
+ * Parses a .dgmo quadrant document into a structured object.
+ * Lines are processed sequentially; unknown lines are silently skipped.
+ */
+declare function parseQuadrant(content: string): ParsedQuadrant;
+/**
+ * Generates valid Mermaid quadrantChart syntax from a parsed quadrant.
+ * Returns a string ready for the Mermaid renderer.
+ */
+declare function buildMermaidQuadrant(parsed: ParsedQuadrant, options?: {
+    isDark?: boolean;
+    textColor?: string;
+    mutedTextColor?: string;
+}): string;
+
+interface RenderStep {
+    type: 'call' | 'return';
+    from: string;
+    to: string;
+    label: string;
+    messageIndex: number;
+    async?: boolean;
+}
+/**
+ * Build an ordered render sequence from flat messages.
+ * Uses a call stack to infer where returns should be placed:
+ * returns appear after all nested sub-calls complete.
+ */
+declare function buildRenderSequence(messages: SequenceMessage[]): RenderStep[];
+interface Activation {
+    participantId: string;
+    startStep: number;
+    endStep: number;
+    depth: number;
+}
+/**
+ * Compute activation rectangles from render steps.
+ * Each call pushes onto the callee's stack; each return pops it.
+ */
+declare function computeActivations(steps: RenderStep[]): Activation[];
+/**
+ * Reorder participants based on explicit `position` overrides.
+ * Positive positions are 0-based from the left; negative positions count from the right (-1 = last).
+ * Unpositioned participants maintain their relative order, filling remaining slots.
+ */
+declare function applyPositionOverrides(participants: SequenceParticipant[]): SequenceParticipant[];
+/**
+ * Reorder participants so that members of the same group are adjacent.
+ * Groups appear in declaration order, followed by ungrouped participants.
+ */
+declare function applyGroupOrdering(participants: SequenceParticipant[], groups: SequenceGroup[]): SequenceParticipant[];
+/**
+ * Render a sequence diagram into the given container element.
+ */
+declare function renderSequenceDiagram(container: HTMLDivElement, parsed: ParsedSequenceDgmo, palette: PaletteColors, isDark: boolean, _onNavigateToLine?: (line: number) => void): void;
+
+/** Complete 16-entry Nord palette. */
+declare const nord: {
+    nord0: string;
+    nord1: string;
+    nord2: string;
+    nord3: string;
+    nord4: string;
+    nord5: string;
+    nord6: string;
+    nord7: string;
+    nord8: string;
+    nord9: string;
+    nord10: string;
+    nord11: string;
+    nord12: string;
+    nord13: string;
+    nord14: string;
+    nord15: string;
+};
+/** Color name → Nord hex for inline `(color)` annotations. */
+declare const colorNames: Record<string, string>;
+/**
+ * Resolves a color name or hex code to a valid CSS color.
+ * When a palette is provided, named colors resolve against its color map first.
+ * Hex codes (e.g. "#ff0000") are passed through regardless of palette (FR8).
+ * Unknown names are returned as-is.
+ */
+declare function resolveColor(color: string, palette?: {
+    colors: Record<string, string>;
+}): string;
+/** @deprecated Use getSeriesColors(palette) from '@/lib/palettes' instead. */
+declare const seriesColors: string[];
+
+export { type Activation, type ArcLink, type ArcNodeGroup, type ChartJsChartType, type ChartJsDataPoint, type D3ChartType, DGMO_CHART_TYPE_MAP, type DgmoFramework, type EChartsChartType, type PaletteColors, type PaletteConfig, type ParsedChartJs, type ParsedD3, type ParsedEChart, type ParsedQuadrant, type ParsedSequenceDgmo, type ParticipantType, RULE_COUNT, type RenderStep, type SequenceBlock, type SequenceElement, type SequenceGroup, type SequenceMessage, type SequenceParticipant, type SequenceSection, addDurationToDate, applyGroupOrdering, applyPositionOverrides, boldPalette, buildChartJsConfig, buildEChartsOption, buildMermaidQuadrant, buildMermaidThemeVars, buildRenderSequence, buildThemeCSS, catppuccinPalette, colorNames, computeActivations, computeTimeTicks, contrastText, formatDateLabel, getAvailablePalettes, getDgmoFramework, getPalette, getSeriesColors, gruvboxPalette, hexToHSL, hexToHSLString, hslToHex, inferParticipantType, isSequenceBlock, isValidHex, looksLikeSequence, mute, nord, nordPalette, oneDarkPalette, orderArcNodes, parseChartJs, parseD3, parseDgmoChartType, parseEChart, parseQuadrant, parseSequenceDgmo, parseTimelineDate, registerPalette, renderArcDiagram, renderD3ForExport, renderQuadrant, renderSequenceDiagram, renderSlopeChart, renderTimeline, renderVenn, renderWordCloud, resolveColor, rosePinePalette, seriesColors, shade, solarizedPalette, tint, tokyoNightPalette };