@antv/gpt-vis 0.6.1 → 1.0.0-beta.2

package/dist/cjs/index.d.ts

@@ -1,13 +1,57 @@
-/********** export chart **********/
-export * from './export';
-/********** export types **********/
-export * from './types';
-/********** export render **********/
-export * from './render';
-/********** export GPTVis **********/
-export { withChartCode, withDefaultChartCode } from './ChartCodeRender';
-export type { CodeBlockComponent, ErrorRender, WithChartCodeOptions } from './ChartCodeRender/type';
-export { default as ConfigProvider, type ConfigProviderProps } from './ConfigProvider';
-export { default as GPTVis, type GPTVisProps } from './GPTVis';
-export { default as GPTVisLite, useEventPublish, type GPTVisLiteProps } from './GPTVis/Lite';
-export { default as version } from './version';
+export { GPTVis } from './gpt-vis';
+export type { GPTVisConfig } from './gpt-vis';
+export { isVisSyntax, parse } from './syntax';
+export type { ParsedConfig } from './syntax';
+export type { VisualizationOptions } from './types';
+export { Area } from './vis/area';
+export type { AreaConfig, AreaDataItem } from './vis/area';
+export { Bar } from './vis/bar';
+export type { BarConfig, BarDataItem } from './vis/bar';
+export { Boxplot } from './vis/boxplot';
+export type { BoxplotConfig, BoxplotDataItem } from './vis/boxplot';
+export { Column } from './vis/column';
+export type { ColumnConfig, ColumnDataItem } from './vis/column';
+export { DualAxes } from './vis/dual-axes';
+export type { DualAxesConfig, DualAxesSeriesItem } from './vis/dual-axes';
+export { FishboneDiagram } from './vis/fishbone-diagram';
+export type { FishboneDiagramConfig, FishboneDiagramInstance, FishboneNode, } from './vis/fishbone-diagram';
+export { FlowDiagram } from './vis/flow-diagram';
+export type { FlowDiagramConfig } from './vis/flow-diagram';
+export { Funnel } from './vis/funnel';
+export type { FunnelConfig, FunnelDataItem } from './vis/funnel';
+export { Histogram } from './vis/histogram';
+export type { HistogramConfig } from './vis/histogram';
+export { IndentedTree } from './vis/indented-tree';
+export type { IndentedTreeConfig, IndentedTreeData, IndentedTreeInstance, } from './vis/indented-tree';
+export { Line } from './vis/line';
+export type { LineConfig, LineDataItem } from './vis/line';
+export { Liquid } from './vis/liquid';
+export type { LiquidConfig } from './vis/liquid';
+export { Mindmap } from './vis/mindmap';
+export type { MindMapProps, MindmapConfig, MindmapData } from './vis/mindmap';
+export { NetworkGraph } from './vis/network-graph';
+export type { NetworkGraphConfig, NetworkGraphData, NetworkGraphEdge, NetworkGraphNode, } from './vis/network-graph';
+export { OrganizationChart } from './vis/organization-chart';
+export type { OrganizationChartConfig, OrganizationChartData } from './vis/organization-chart';
+export { Pie } from './vis/pie';
+export type { PieConfig } from './vis/pie';
+export { Radar } from './vis/radar';
+export type { RadarConfig, RadarDataItem } from './vis/radar';
+export { Sankey } from './vis/sankey';
+export type { SankeyConfig, SankeyDataItem } from './vis/sankey';
+export { Scatter } from './vis/scatter';
+export type { ScatterConfig, ScatterDataItem } from './vis/scatter';
+export { Summary } from './vis/summary';
+export type { SummaryConfig } from './vis/summary';
+export { Table } from './vis/table';
+export type { TableConfig } from './vis/table';
+export { Treemap } from './vis/treemap';
+export type { TreemapConfig, TreemapDataItem } from './vis/treemap';
+export { Venn } from './vis/venn';
+export type { VennConfig, VennDataItem } from './vis/venn';
+export { Violin } from './vis/violin';
+export type { ViolinConfig, ViolinDataItem } from './vis/violin';
+export { Waterfall } from './vis/waterfall';
+export type { WaterfallConfig, WaterfallDataItem } from './vis/waterfall';
+export { WordCloud } from './vis/word-cloud';
+export type { WordCloudConfig, WordCloudDataItem } from './vis/word-cloud';

package/dist/cjs/index.js

@@ -1,8 +1,6 @@
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -16,47 +14,99 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  ConfigProvider: () => import_ConfigProvider.default,
-  GPTVis: () => import_GPTVis.default,
-  GPTVisLite: () => import_Lite.default,
-  useEventPublish: () => import_Lite.useEventPublish,
-  version: () => import_version.default,
-  withChartCode: () => import_ChartCodeRender.withChartCode,
-  withDefaultChartCode: () => import_ChartCodeRender.withDefaultChartCode
+  Area: () => import_area.Area,
+  Bar: () => import_bar.Bar,
+  Boxplot: () => import_boxplot.Boxplot,
+  Column: () => import_column.Column,
+  DualAxes: () => import_dual_axes.DualAxes,
+  FishboneDiagram: () => import_fishbone_diagram.FishboneDiagram,
+  FlowDiagram: () => import_flow_diagram.FlowDiagram,
+  Funnel: () => import_funnel.Funnel,
+  GPTVis: () => import_gpt_vis.GPTVis,
+  Histogram: () => import_histogram.Histogram,
+  IndentedTree: () => import_indented_tree.IndentedTree,
+  Line: () => import_line.Line,
+  Liquid: () => import_liquid.Liquid,
+  Mindmap: () => import_mindmap.Mindmap,
+  NetworkGraph: () => import_network_graph.NetworkGraph,
+  OrganizationChart: () => import_organization_chart.OrganizationChart,
+  Pie: () => import_pie.Pie,
+  Radar: () => import_radar.Radar,
+  Sankey: () => import_sankey.Sankey,
+  Scatter: () => import_scatter.Scatter,
+  Summary: () => import_summary.Summary,
+  Table: () => import_table.Table,
+  Treemap: () => import_treemap.Treemap,
+  Venn: () => import_venn.Venn,
+  Violin: () => import_violin.Violin,
+  Waterfall: () => import_waterfall.Waterfall,
+  WordCloud: () => import_word_cloud.WordCloud,
+  isVisSyntax: () => import_syntax.isVisSyntax,
+  parse: () => import_syntax.parse
 });
 module.exports = __toCommonJS(src_exports);
-__reExport(src_exports, require("./export"), module.exports);
-__reExport(src_exports, require("./types"), module.exports);
-__reExport(src_exports, require("./render"), module.exports);
-var import_ChartCodeRender = require("./ChartCodeRender");
-var import_ConfigProvider = __toESM(require("./ConfigProvider"));
-var import_GPTVis = __toESM(require("./GPTVis"));
-var import_Lite = __toESM(require("./GPTVis/Lite"));
-var import_version = __toESM(require("./version"));
+var import_gpt_vis = require("./gpt-vis");
+var import_syntax = require("./syntax");
+var import_area = require("./vis/area");
+var import_bar = require("./vis/bar");
+var import_boxplot = require("./vis/boxplot");
+var import_column = require("./vis/column");
+var import_dual_axes = require("./vis/dual-axes");
+var import_fishbone_diagram = require("./vis/fishbone-diagram");
+var import_flow_diagram = require("./vis/flow-diagram");
+var import_funnel = require("./vis/funnel");
+var import_histogram = require("./vis/histogram");
+var import_indented_tree = require("./vis/indented-tree");
+var import_line = require("./vis/line");
+var import_liquid = require("./vis/liquid");
+var import_mindmap = require("./vis/mindmap");
+var import_network_graph = require("./vis/network-graph");
+var import_organization_chart = require("./vis/organization-chart");
+var import_pie = require("./vis/pie");
+var import_radar = require("./vis/radar");
+var import_sankey = require("./vis/sankey");
+var import_scatter = require("./vis/scatter");
+var import_summary = require("./vis/summary");
+var import_table = require("./vis/table");
+var import_treemap = require("./vis/treemap");
+var import_venn = require("./vis/venn");
+var import_violin = require("./vis/violin");
+var import_waterfall = require("./vis/waterfall");
+var import_word_cloud = require("./vis/word-cloud");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ConfigProvider,
+  Area,
+  Bar,
+  Boxplot,
+  Column,
+  DualAxes,
+  FishboneDiagram,
+  FlowDiagram,
+  Funnel,
   GPTVis,
-  GPTVisLite,
-  useEventPublish,
-  version,
-  withChartCode,
-  withDefaultChartCode,
-  ...require("./export"),
-  ...require("./types"),
-  ...require("./render")
+  Histogram,
+  IndentedTree,
+  Line,
+  Liquid,
+  Mindmap,
+  NetworkGraph,
+  OrganizationChart,
+  Pie,
+  Radar,
+  Sankey,
+  Scatter,
+  Summary,
+  Table,
+  Treemap,
+  Venn,
+  Violin,
+  Waterfall,
+  WordCloud,
+  isVisSyntax,
+  parse
 });

package/dist/cjs/syntax/index.d.ts

@@ -0,0 +1,2 @@
+export { isVisSyntax, parse } from './parser';
+export type { ParsedConfig } from './parser';

package/dist/cjs/{Text/mini-charts/hooks → syntax}/index.js

@@ -16,14 +16,16 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/Text/mini-charts/hooks/index.ts
-var hooks_exports = {};
-__export(hooks_exports, {
-  useSvgWrapper: () => import_useSvgWrapper.useSvgWrapper
+// src/syntax/index.ts
+var syntax_exports = {};
+__export(syntax_exports, {
+  isVisSyntax: () => import_parser.isVisSyntax,
+  parse: () => import_parser.parse
 });
-module.exports = __toCommonJS(hooks_exports);
-var import_useSvgWrapper = require("./useSvgWrapper");
+module.exports = __toCommonJS(syntax_exports);
+var import_parser = require("./parser");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  useSvgWrapper
+  isVisSyntax,
+  parse
 });

package/dist/cjs/syntax/parser.d.ts

@@ -0,0 +1,82 @@
+/**
+ * GPT-Vis Syntax Parser
+ *
+ * Parses a markdown-like syntax for visualization configurations.
+ *
+ * Syntax rules:
+ * - `vis [chartType]` - Defines the chart type (required first line)
+ * - `data` - Starts a data array section
+ * - `  - key value` - Array item with key-value pairs
+ * - `  - value` - Simple array item (for flat arrays like histogram data)
+ * - `  - "value with spaces"` - Quoted string item; single or double quotes both supported.
+ *                               Quotes are required when the value contains spaces; optional otherwise.
+ *                               Quoted values are never coerced to numbers or booleans.
+ * - `key: value` or `key value` - Top-level key-value pair
+ * - `style` - Starts a style object section
+ * - `palette` inside `style` uses array syntax with dash-prefixed items
+ * - `children` - Nested array for hierarchical data (mind-map, treemap, etc.)
+ *
+ * @example
+ * ```
+ * vis pie
+ * data
+ *   - category 分类一
+ *     value 27
+ *   - category 分类二
+ *     value 25
+ * innerRadius: 0.6
+ * style
+ *   backgroundColor #333
+ *   palette
+ *     - #ff5a5f
+ *     - #1fb6ff
+ *     - #13ce66
+ * ```
+ *
+ * @example Simple array (histogram)
+ * ```
+ * vis histogram
+ * data
+ *   - 78
+ *   - 88
+ *   - 60
+ * binNumber 5
+ * ```
+ *
+ * @example Quoted string values (values containing spaces)
+ * ```
+ * vis dual-axes
+ * categories
+ *   - "North America"
+ *   - '东南 亚'
+ *   - 欧洲
+ * ```
+ *
+ * @example Hierarchical data (mind-map)
+ * ```
+ * vis mind-map
+ * data
+ *   - name 项目计划
+ *     children
+ *       - name 研究阶段
+ *         children
+ *           - name 市场调研
+ *           - name 技术可行性分析
+ *       - name 开发阶段
+ * ```
+ */
+/**
+ * Parsed chart configuration result
+ */
+export interface ParsedConfig {
+    type: string;
+    [key: string]: unknown;
+}
+/**
+ * Parse the visualization syntax string into a configuration object
+ */
+export declare function parse(syntax: string): ParsedConfig;
+/**
+ * Check if a val is a valid visualization syntax
+ */
+export declare function isVisSyntax(input: any): boolean;

package/dist/cjs/syntax/parser.js

@@ -0,0 +1,348 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/syntax/parser.ts
+var parser_exports = {};
+__export(parser_exports, {
+  isVisSyntax: () => isVisSyntax,
+  parse: () => parse
+});
+module.exports = __toCommonJS(parser_exports);
+var ARRAY_SECTIONS = /* @__PURE__ */ new Set(["data", "categories", "series", "children", "nodes", "edges"]);
+var OBJECT_SECTIONS = /* @__PURE__ */ new Set(["style"]);
+function isQuotedString(s) {
+  if (s.length < 2)
+    return false;
+  const quote = s[0];
+  if (quote !== '"' && quote !== "'")
+    return false;
+  return s.endsWith(quote) && s.indexOf(quote, 1) === s.length - 1;
+}
+function parseValue(value) {
+  const trimmed = value.trim();
+  if (trimmed === "") {
+    return "";
+  }
+  if (isQuotedString(trimmed)) {
+    return trimmed.slice(1, -1);
+  }
+  if (trimmed === "true")
+    return true;
+  if (trimmed === "false")
+    return false;
+  const num = Number(trimmed);
+  if (!isNaN(num) && trimmed !== "") {
+    return num;
+  }
+  return trimmed;
+}
+function parseKeyValue(raw) {
+  const text = raw.trim();
+  if (!text)
+    return null;
+  const match = text.match(/^([^:\s=]+)\s*[:=]\s*(.*)$/);
+  if (match) {
+    return { key: match[1], value: match[2] };
+  }
+  const matchSpace = text.match(/^([^\s]+)\s+(.*)$/);
+  if (matchSpace) {
+    return { key: matchSpace[1], value: matchSpace[2] };
+  }
+  return { key: text, value: "" };
+}
+function isSimpleValue(line) {
+  const trimmed = line.trim();
+  if (isQuotedString(trimmed)) {
+    return true;
+  }
+  const hasKeyValue = parseKeyValue(trimmed);
+  if (hasKeyValue && hasKeyValue.value !== "") {
+    return false;
+  }
+  return true;
+}
+var TAB_INDENT_WIDTH = 2;
+function getIndentLevel(line) {
+  const match = line.match(/^([\t ]*)/);
+  if (!match)
+    return 0;
+  let w = 0;
+  for (const ch of match[1]) {
+    w += ch === "	" ? TAB_INDENT_WIDTH : 1;
+  }
+  return w;
+}
+function isArrayItemLine(line) {
+  return line.trim().startsWith("-");
+}
+function parseArrayItemLine(line) {
+  return line.trim().replace(/^-\s*/, "");
+}
+function isKnownSection(key) {
+  return ARRAY_SECTIONS.has(key) || OBJECT_SECTIONS.has(key);
+}
+function parseLines(syntax) {
+  const lines = syntax.split("\n");
+  const result = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (trimmed === "") {
+      continue;
+    }
+    result.push({
+      line,
+      trimmed,
+      indent: getIndentLevel(line),
+      lineNumber: i
+    });
+  }
+  return result;
+}
+function parseTreeNode(lines, startIndex, baseIndent) {
+  const node = {};
+  let i = startIndex;
+  while (i < lines.length) {
+    const { trimmed, indent } = lines[i];
+    if (indent <= baseIndent)
+      break;
+    const kv = parseKeyValue(trimmed);
+    if (kv) {
+      if (kv.key === "children" && kv.value === "") {
+        const { items: childItems, nextIndex } = parseArraySection(lines, i + 1, indent);
+        node.children = childItems;
+        i = nextIndex;
+        continue;
+      } else {
+        node[kv.key] = parseValue(kv.value);
+      }
+    }
+    i++;
+  }
+  return { node, nextIndex: i };
+}
+function parseArraySection(lines, startIndex, baseIndent) {
+  const items = [];
+  let currentItem = null;
+  let isSimpleArray = false;
+  let i = startIndex;
+  let firstItemIndent = -1;
+  while (i < lines.length) {
+    const { trimmed, indent } = lines[i];
+    if (indent <= baseIndent && !isArrayItemLine(trimmed)) {
+      break;
+    }
+    if (isArrayItemLine(trimmed) && indent < baseIndent) {
+      break;
+    }
+    const isThisLevelItem = isArrayItemLine(trimmed) && (firstItemIndent === -1 || indent === firstItemIndent);
+    if (isThisLevelItem) {
+      if (firstItemIndent === -1) {
+        firstItemIndent = indent;
+      }
+      if (currentItem !== null && !isSimpleArray) {
+        items.push(currentItem);
+      }
+      const itemContent = parseArrayItemLine(trimmed);
+      if (itemContent) {
+        if (isSimpleValue(itemContent)) {
+          isSimpleArray = true;
+          items.push(parseValue(itemContent));
+          currentItem = null;
+        } else {
+          currentItem = {};
+          const kv = parseKeyValue(itemContent);
+          if (kv) {
+            currentItem[kv.key] = parseValue(kv.value);
+          }
+        }
+      } else {
+        currentItem = {};
+      }
+      i++;
+      continue;
+    }
+    if (isArrayItemLine(trimmed) && firstItemIndent !== -1 && indent !== firstItemIndent) {
+      if (indent < firstItemIndent && indent > baseIndent && currentItem !== null && !isSimpleArray) {
+        items.push(currentItem);
+        const itemContent = parseArrayItemLine(trimmed);
+        currentItem = {};
+        const kv = parseKeyValue(itemContent);
+        if (kv) {
+          currentItem[kv.key] = parseValue(kv.value);
+        }
+        firstItemIndent = indent;
+        i++;
+        continue;
+      }
+      if (indent > firstItemIndent && currentItem !== null && !isSimpleArray) {
+        items.push(currentItem);
+        const itemContent = parseArrayItemLine(trimmed);
+        currentItem = {};
+        const kv = parseKeyValue(itemContent);
+        if (kv) {
+          currentItem[kv.key] = parseValue(kv.value);
+        }
+        firstItemIndent = indent;
+        i++;
+        continue;
+      }
+      i++;
+      continue;
+    }
+    if (currentItem !== null && !isSimpleArray) {
+      const kv = parseKeyValue(trimmed);
+      if (kv) {
+        if (kv.key === "children" && kv.value === "") {
+          const { items: childItems, nextIndex } = parseArraySection(lines, i + 1, indent);
+          currentItem.children = childItems;
+          i = nextIndex;
+          continue;
+        }
+        if (kv.key === "data" && kv.value === "") {
+          const { items: nestedData, nextIndex } = parseArraySection(lines, i + 1, indent);
+          currentItem.data = nestedData;
+          i = nextIndex;
+          continue;
+        }
+        currentItem[kv.key] = parseValue(kv.value);
+      }
+    }
+    i++;
+  }
+  if (currentItem !== null && !isSimpleArray) {
+    items.push(currentItem);
+  }
+  return { items, nextIndex: i };
+}
+function parse(syntax) {
+  const lines = parseLines(syntax);
+  const result = { type: "" };
+  let i = 0;
+  while (i < lines.length) {
+    const { trimmed, indent } = lines[i];
+    if (trimmed.startsWith("vis ")) {
+      const chartType = trimmed.substring(4).trim();
+      result.type = chartType;
+      i++;
+      continue;
+    }
+    const isSectionHeader = /^[a-zA-Z_][a-zA-Z0-9_-]*$/.test(trimmed) && indent === 0 && isKnownSection(trimmed);
+    if (isSectionHeader) {
+      if (ARRAY_SECTIONS.has(trimmed)) {
+        const sectionName = trimmed;
+        const nextIndex = i + 1;
+        let hasSubSections = false;
+        if (nextIndex < lines.length && lines[nextIndex].indent > indent) {
+          const nextTrimmed = lines[nextIndex].trimmed;
+          hasSubSections = /^[a-zA-Z_][a-zA-Z0-9_-]*$/.test(nextTrimmed) && !isArrayItemLine(nextTrimmed);
+        }
+        if (hasSubSections) {
+          const dataObj = {};
+          i++;
+          while (i < lines.length && lines[i].indent > indent) {
+            const subTrimmed = lines[i].trimmed;
+            const subIndent = lines[i].indent;
+            if (/^[a-zA-Z_][a-zA-Z0-9_-]*$/.test(subTrimmed) && !isArrayItemLine(subTrimmed)) {
+              const { items: subItems, nextIndex: subNext } = parseArraySection(
+                lines,
+                i + 1,
+                subIndent
+              );
+              dataObj[subTrimmed] = subItems;
+              i = subNext;
+            } else {
+              i++;
+            }
+          }
+          result[sectionName] = dataObj;
+          continue;
+        }
+        let isTreeRoot = false;
+        if (nextIndex < lines.length && lines[nextIndex].indent > indent) {
+          const firstTrimmed = lines[nextIndex].trimmed;
+          if (!isArrayItemLine(firstTrimmed) && !hasSubSections) {
+            isTreeRoot = true;
+          }
+        }
+        if (isTreeRoot) {
+          const { node, nextIndex: treeNext } = parseTreeNode(lines, i + 1, indent);
+          result[sectionName] = node;
+          i = treeNext;
+          continue;
+        }
+        const { items, nextIndex: arrNext } = parseArraySection(lines, i + 1, indent);
+        if (items.length > 0) {
+          result[sectionName] = items;
+        }
+        i = arrNext;
+        continue;
+      } else if (OBJECT_SECTIONS.has(trimmed)) {
+        const sectionName = trimmed;
+        const sectionObj = {};
+        result[sectionName] = sectionObj;
+        const sectionIndent = indent;
+        i++;
+        while (i < lines.length) {
+          const { trimmed: innerTrimmed, indent: innerIndent } = lines[i];
+          if (innerIndent <= sectionIndent) {
+            break;
+          }
+          if (isArrayItemLine(innerTrimmed)) {
+            i++;
+            continue;
+          }
+          const kv = parseKeyValue(innerTrimmed);
+          if (kv) {
+            if (kv.value === "" && i + 1 < lines.length) {
+              const nextLine = lines[i + 1];
+              if (nextLine.indent > innerIndent && isArrayItemLine(nextLine.trimmed)) {
+                const { items, nextIndex } = parseArraySection(lines, i + 1, innerIndent);
+                sectionObj[kv.key] = items;
+                i = nextIndex;
+                continue;
+              }
+            }
+            sectionObj[kv.key] = parseValue(kv.value);
+          }
+          i++;
+        }
+        continue;
+      }
+    }
+    if (indent === 0) {
+      const kv = parseKeyValue(trimmed);
+      if (kv) {
+        result[kv.key] = parseValue(kv.value);
+      }
+    }
+    i++;
+  }
+  return result;
+}
+function isVisSyntax(input) {
+  if (typeof input !== "string")
+    return false;
+  const trimmed = input.trim();
+  return trimmed.startsWith("vis ");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isVisSyntax,
+  parse
+});