ts-graphviz 1.0.0 → 1.0.1

package/lib/ast/index.cjs

@@ -5,8 +5,12 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var utils = require('#lib/utils');
 var common = require('#lib/common');
 
+/**
+ * @group Create AST
+ */
 class Builder {
   options;
+  /** @internal */
   getLocation() {
     return this.options?.locationFunction?.() ?? null;
   }
@@ -24,6 +28,11 @@ class Builder {
   }
 }
 
+/**
+ * @group Create AST
+ */
+const createElement = Builder.prototype.createElement.bind(new Builder());
+
 const EOL = /\r?\n/;
 function joinBy(sep) {
   return (value) => value.join(sep);
@@ -258,16 +267,16 @@ const defaultPlugins$1 = [
   SubgraphPrintPlugin,
 ];
 
+/**
+ * @group Convert AST to DOT
+ */
 class Printer {
   options;
+  /** @internal */
   #plugins = [...defaultPlugins$1];
   constructor(options = {}) {
     this.options = options;
   }
-  use(plugin) {
-    this.#plugins.unshift(plugin);
-    return this;
-  }
   print(ast) {
     const plugins = [...this.#plugins];
     const { indentSize = 2, indentStyle = 'space', endOfLine = 'lf' } = this.options;
@@ -289,547 +298,266 @@ class Printer {
   }
 }
 
-const createElement = Builder.prototype.createElement.bind(new Builder());
-
-function convertAttribute(key, value) {
-  if (typeof value === 'string') {
-    const trimmed = value.trim();
-    const isHTMLLike = /^<.+>$/ms.test(trimmed);
-    if (isHTMLLike) {
-      return createElement(
-        'Attribute',
-        {
-          key: createElement('Literal', { value: key, quoted: false }, []),
-          value: createElement('Literal', { value: trimmed.slice(1, trimmed.length - 1), quoted: 'html' }, []),
-        },
-        [],
-      );
-    } else {
-      return createElement(
-        'Attribute',
-        {
-          key: createElement('Literal', { value: key, quoted: false }, []),
-          value: createElement('Literal', { value: value, quoted: true }, []),
-        },
-        [],
-      );
-    }
+/**
+ * Stringify Graphviz AST Node.
+ *
+ * @param ast Graphviz AST node.
+ * @returns DOT language string.
+ * @group Convert AST to DOT
+ */
+function stringify(ast, options) {
+  const result = new Printer(options).print(ast);
+  if (!result) {
+    throw new Error();
   }
-  return createElement(
-    'Attribute',
-    {
-      key: createElement('Literal', { value: key, quoted: false }, []),
-      value: createElement('Literal', { value: String(value), quoted: false }, []),
-    },
-    [],
-  );
+  return result;
 }
 
-function convertComment(value, kind) {
-  return createElement(
-    'Comment',
-    {
-      kind: kind,
-      value: value,
-    },
-    [],
-  );
+/* eslint-disable */
+function peg$padEnd(str, targetLength, padString) {
+  padString = padString || ' ';
+  if (str.length > targetLength) {
+    return str;
+  }
+  targetLength -= str.length;
+  padString += padString.repeat(targetLength);
+  return str + padString.slice(0, targetLength);
 }
-
-function convertClusterChildren(context, model) {
-  return Array.from(
-    (function* () {
-      for (const [key, value] of model.values) {
-        yield convertAttribute(key, value);
+class SyntaxError$1 extends Error {
+  static buildMessage(expected, found) {
+    function hex(ch) {
+      return ch.charCodeAt(0).toString(16).toUpperCase();
+    }
+    function literalEscape(s) {
+      return s
+        .replace(/\\/g, '\\\\')
+        .replace(/"/g, '\\"')
+        .replace(/\0/g, '\\0')
+        .replace(/\t/g, '\\t')
+        .replace(/\n/g, '\\n')
+        .replace(/\r/g, '\\r')
+        .replace(/[\x00-\x0F]/g, (ch) => '\\x0' + hex(ch))
+        .replace(/[\x10-\x1F\x7F-\x9F]/g, (ch) => '\\x' + hex(ch));
+    }
+    function classEscape(s) {
+      return s
+        .replace(/\\/g, '\\\\')
+        .replace(/\]/g, '\\]')
+        .replace(/\^/g, '\\^')
+        .replace(/-/g, '\\-')
+        .replace(/\0/g, '\\0')
+        .replace(/\t/g, '\\t')
+        .replace(/\n/g, '\\n')
+        .replace(/\r/g, '\\r')
+        .replace(/[\x00-\x0F]/g, (ch) => '\\x0' + hex(ch))
+        .replace(/[\x10-\x1F\x7F-\x9F]/g, (ch) => '\\x' + hex(ch));
+    }
+    function describeExpectation(expectation) {
+      switch (expectation.type) {
+        case 'literal':
+          return '"' + literalEscape(expectation.text) + '"';
+        case 'class':
+          const escapedParts = expectation.parts.map((part) => {
+            return Array.isArray(part) ? classEscape(part[0]) + '-' + classEscape(part[1]) : classEscape(part);
+          });
+          return '[' + (expectation.inverted ? '^' : '') + escapedParts + ']';
+        case 'any':
+          return 'any character';
+        case 'end':
+          return 'end of input';
+        case 'other':
+          return expectation.description;
       }
-      for (const attrs of Object.values(model.attributes)) {
-        if (attrs.size > 0) {
-          if (attrs.comment) {
-            yield convertComment(attrs.comment, context.commentKind);
+    }
+    function describeExpected(expected1) {
+      const descriptions = expected1.map(describeExpectation);
+      let i;
+      let j;
+      descriptions.sort();
+      if (descriptions.length > 0) {
+        for (i = 1, j = 1; i < descriptions.length; i++) {
+          if (descriptions[i - 1] !== descriptions[i]) {
+            descriptions[j] = descriptions[i];
+            j++;
           }
-          yield context.convert(attrs);
         }
+        descriptions.length = j;
       }
-      for (const node of model.nodes) {
-        if (node.comment) {
-          yield convertComment(node.comment, context.commentKind);
-        }
-        yield context.convert(node);
+      switch (descriptions.length) {
+        case 1:
+          return descriptions[0];
+        case 2:
+          return descriptions[0] + ' or ' + descriptions[1];
+        default:
+          return descriptions.slice(0, -1).join(', ') + ', or ' + descriptions[descriptions.length - 1];
       }
-      for (const subgraph of model.subgraphs) {
-        if (subgraph.comment) {
-          yield convertComment(subgraph.comment, context.commentKind);
+    }
+    function describeFound(found1) {
+      return found1 ? '"' + literalEscape(found1) + '"' : 'end of input';
+    }
+    return 'Expected ' + describeExpected(expected) + ' but ' + describeFound(found) + ' found.';
+  }
+  message;
+  expected;
+  found;
+  location;
+  name;
+  constructor(message, expected, found, location) {
+    super();
+    this.message = message;
+    this.expected = expected;
+    this.found = found;
+    this.location = location;
+    this.name = 'SyntaxError';
+    if (typeof Object.setPrototypeOf === 'function') {
+      Object.setPrototypeOf(this, SyntaxError$1.prototype);
+    } else {
+      this.__proto__ = SyntaxError$1.prototype;
+    }
+    if (typeof Error.captureStackTrace === 'function') {
+      Error.captureStackTrace(this, SyntaxError$1);
+    }
+  }
+  format(sources) {
+    let str = 'Error: ' + this.message;
+    if (this.location) {
+      let src = null;
+      let k;
+      for (k = 0; k < sources.length; k++) {
+        if (sources[k].source === this.location.source) {
+          src = sources[k].text.split(/\r\n|\n|\r/g);
+          break;
         }
-        yield context.convert(subgraph);
       }
-      for (const edge of model.edges) {
-        if (edge.comment) {
-          yield convertComment(edge.comment, context.commentKind);
-        }
-        yield context.convert(edge);
+      let s = this.location.start;
+      let loc = this.location.source + ':' + s.line + ':' + s.column;
+      if (src) {
+        let e = this.location.end;
+        let filler = peg$padEnd('', s.line.toString().length, ' ');
+        let line = src[s.line - 1];
+        let last = s.line === e.line ? e.column : line.length + 1;
+        str +=
+          '\n --> ' +
+          loc +
+          '\n' +
+          filler +
+          ' |\n' +
+          s.line +
+          ' | ' +
+          line +
+          '\n' +
+          filler +
+          ' | ' +
+          peg$padEnd('', s.column - 1, ' ') +
+          peg$padEnd('', last - s.column, '^');
+      } else {
+        str += '\n at ' + loc;
       }
-    })(),
-  );
+    }
+    return str;
+  }
 }
-
-const AttributeListPrintPlugin = {
-  match(model) {
-    return model.$$type === 'AttributeList';
-  },
-  convert(context, model) {
-    return createElement(
-      'AttributeList',
-      {
-        kind: model.$$kind,
-      },
-      model.values.map(([key, value]) => convertAttribute(key, value)),
-    );
-  },
-};
-
-const EdgeConvertPlugin = {
-  match(model) {
-    return model.$$type === 'Edge';
-  },
-  convert(context, model) {
-    return createElement(
-      'Edge',
-      {
-        targets: model.targets.map((target) => {
-          if (common.isNodeModel(target)) {
-            return createElement(
-              'NodeRef',
-              {
-                id: createElement(
-                  'Literal',
-                  {
-                    value: target.id,
-                    quoted: true,
-                  },
-                  [],
-                ),
-              },
-              [],
-            );
-          } else if (common.isForwardRefNode(target)) {
-            return createElement(
-              'NodeRef',
-              {
-                id: createElement(
-                  'Literal',
-                  {
-                    value: target.id,
-                    quoted: true,
-                  },
-                  [],
-                ),
-                port: target.port
-                  ? createElement(
-                      'Literal',
-                      {
-                        value: target.port,
-                        quoted: true,
-                      },
-                      [],
-                    )
-                  : undefined,
-                compass: target.compass
-                  ? createElement(
-                      'Literal',
-                      {
-                        value: target.compass,
-                        quoted: true,
-                      },
-                      [],
-                    )
-                  : undefined,
-              },
-              [],
-            );
+function peg$parse(input, options) {
+  options = options !== undefined ? options : {};
+  const peg$FAILED = {};
+  const peg$source = options.grammarSource;
+  const peg$startRuleFunctions = {
+    Dot: peg$parseDot,
+    Graph: peg$parseGraph,
+    Subgraph: peg$parseSubgraph,
+    Node: peg$parseNode,
+    Edge: peg$parseEdge,
+    AttributeList: peg$parseAttributeList,
+    Attribute: peg$parseAttribute,
+    ClusterStatements: peg$parseClusterStatements,
+  };
+  let peg$startRuleFunction = peg$parseDot;
+  const peg$c0 = function (v) {
+    return v;
+  };
+  const peg$c1 = function (c1, graph, c2) {
+    return b.createElement('Dot', {}, [...c1, graph, ...c2]);
+  };
+  const peg$c2 = 'strict';
+  const peg$c3 = peg$literalExpectation('strict', true);
+  const peg$c4 = 'graph';
+  const peg$c5 = peg$literalExpectation('graph', true);
+  const peg$c6 = 'digraph';
+  const peg$c7 = peg$literalExpectation('digraph', true);
+  const peg$c8 = '{';
+  const peg$c9 = peg$literalExpectation('{', false);
+  const peg$c10 = '}';
+  const peg$c11 = peg$literalExpectation('}', false);
+  const peg$c12 = function (_strict, _kind, id, children) {
+    const strict = !!_strict;
+    const kind = _kind.toLowerCase();
+    const directed = kind === 'digraph';
+    for (const edgeop of edgeops) {
+      if (directed) {
+        if (edgeop.operator !== '->') {
+          error(`In digraph, it's necessary to describe with "->" operator to create edge.`, edgeop.location);
+        }
+      } else {
+        if (edgeop.operator !== '--') {
+          error(`In graph, it's necessary to describe with "--" operator to create edge.`, edgeop.location);
+        }
+      }
+    }
+    return b.createElement(
+      'Graph',
+      id !== null
+        ? {
+            id,
+            directed,
+            strict,
           }
-        }),
+        : {
+            directed,
+            strict,
+          },
+      children,
+    );
+  };
+  const peg$c13 = ';';
+  const peg$c14 = peg$literalExpectation(';', false);
+  const peg$c15 = function (keyValue) {
+    return b.createElement(
+      'Attribute',
+      {
+        ...keyValue,
       },
-      [
-        ...(model.attributes.comment ? [convertComment(model.attributes.comment, context.commentKind)] : []),
-        ...model.attributes.values.map(([key, value]) => convertAttribute(key, value)),
-      ],
+      [],
     );
-  },
-};
-
-const GraphConvertPlugin = {
-  match(model) {
-    return model.$$type === 'Graph';
-  },
-  convert(context, model) {
-    return createElement('Dot', {}, [
-      ...(model.comment ? [convertComment(model.comment, context.commentKind)] : []),
-      createElement(
-        'Graph',
-        {
-          directed: model.directed,
-          strict: model.strict,
-          id: model.id
-            ? createElement(
-                'Literal',
-                {
-                  value: model.id,
-                  quoted: true,
-                },
-                [],
-              )
-            : undefined,
-        },
-        convertClusterChildren(context, model),
-      ),
-    ]);
-  },
-};
-
-const NodeConvertPlugin = {
-  match(model) {
-    return model.$$type === 'Node';
-  },
-  convert(context, model) {
-    return createElement(
-      'Node',
+  };
+  const peg$c16 = 'node';
+  const peg$c17 = peg$literalExpectation('node', true);
+  const peg$c18 = 'edge';
+  const peg$c19 = peg$literalExpectation('edge', true);
+  const peg$c20 = function (_kind, children) {
+    return b.createElement(
+      'AttributeList',
       {
-        id: createElement(
-          'Literal',
-          {
-            value: model.id,
-            quoted: true,
-          },
-          [],
-        ),
+        kind: _kind.toLowerCase(),
       },
-      [
-        ...(model.attributes.comment ? [convertComment(model.attributes.comment, context.commentKind)] : []),
-        ...model.attributes.values.map(([key, value]) => convertAttribute(key, value)),
-      ],
+      children,
     );
-  },
-};
-
-const SubgraphConvertPlugin = {
-  match(model) {
-    return model.$$type === 'Subgraph';
-  },
-  convert(context, model) {
-    return createElement(
-      'Subgraph',
+  };
+  const peg$c21 = function (id, rhs, _children) {
+    // @ts-ignore
+    return b.createElement(
+      // @ts-ignore
+      'Edge',
       {
-        id: model.id
-          ? createElement(
-              'Literal',
-              {
-                value: model.id,
-                quoted: true,
-              },
-              [],
-            )
-          : undefined,
+        targets: [id, ...rhs],
       },
-      convertClusterChildren(context, model),
+      _children ?? [],
     );
-  },
-};
-
-const defaultPlugins = [
-  AttributeListPrintPlugin,
-  EdgeConvertPlugin,
-  NodeConvertPlugin,
-  GraphConvertPlugin,
-  SubgraphConvertPlugin,
-];
-
-class Converter {
-  options;
-  #plugins = [...defaultPlugins];
-  constructor(options = {}) {
-    this.options = options;
-  }
-  use(plugin) {
-    this.#plugins.unshift(plugin);
-    return this;
-  }
-  convert(model) {
-    const plugins = [...this.#plugins];
-    const { commentKind = 'Slash' } = this.options;
-    const context = {
-      commentKind,
-      convert(m) {
-        for (const plugin of plugins) {
-          if (plugin.match(m)) {
-            return plugin.convert(context, m);
-          }
-        }
-        throw Error();
-      },
-    };
-    return context.convert(model);
-  }
-}
-
-/**
- * Stringify Graphviz AST Node.
- *
- * @param ast Graphviz AST node.
- * @returns DOT language string.
- */
-function stringify(ast, options) {
-  const result = new Printer(options).print(ast);
-  if (!result) {
-    throw new Error();
-  }
-  return result;
-}
-
-/* eslint-disable */
-function peg$padEnd(str, targetLength, padString) {
-  padString = padString || ' ';
-  if (str.length > targetLength) {
-    return str;
-  }
-  targetLength -= str.length;
-  padString += padString.repeat(targetLength);
-  return str + padString.slice(0, targetLength);
-}
-class SyntaxError extends Error {
-  static buildMessage(expected, found) {
-    function hex(ch) {
-      return ch.charCodeAt(0).toString(16).toUpperCase();
-    }
-    function literalEscape(s) {
-      return s
-        .replace(/\\/g, '\\\\')
-        .replace(/"/g, '\\"')
-        .replace(/\0/g, '\\0')
-        .replace(/\t/g, '\\t')
-        .replace(/\n/g, '\\n')
-        .replace(/\r/g, '\\r')
-        .replace(/[\x00-\x0F]/g, (ch) => '\\x0' + hex(ch))
-        .replace(/[\x10-\x1F\x7F-\x9F]/g, (ch) => '\\x' + hex(ch));
-    }
-    function classEscape(s) {
-      return s
-        .replace(/\\/g, '\\\\')
-        .replace(/\]/g, '\\]')
-        .replace(/\^/g, '\\^')
-        .replace(/-/g, '\\-')
-        .replace(/\0/g, '\\0')
-        .replace(/\t/g, '\\t')
-        .replace(/\n/g, '\\n')
-        .replace(/\r/g, '\\r')
-        .replace(/[\x00-\x0F]/g, (ch) => '\\x0' + hex(ch))
-        .replace(/[\x10-\x1F\x7F-\x9F]/g, (ch) => '\\x' + hex(ch));
-    }
-    function describeExpectation(expectation) {
-      switch (expectation.type) {
-        case 'literal':
-          return '"' + literalEscape(expectation.text) + '"';
-        case 'class':
-          const escapedParts = expectation.parts.map((part) => {
-            return Array.isArray(part) ? classEscape(part[0]) + '-' + classEscape(part[1]) : classEscape(part);
-          });
-          return '[' + (expectation.inverted ? '^' : '') + escapedParts + ']';
-        case 'any':
-          return 'any character';
-        case 'end':
-          return 'end of input';
-        case 'other':
-          return expectation.description;
-      }
-    }
-    function describeExpected(expected1) {
-      const descriptions = expected1.map(describeExpectation);
-      let i;
-      let j;
-      descriptions.sort();
-      if (descriptions.length > 0) {
-        for (i = 1, j = 1; i < descriptions.length; i++) {
-          if (descriptions[i - 1] !== descriptions[i]) {
-            descriptions[j] = descriptions[i];
-            j++;
-          }
-        }
-        descriptions.length = j;
-      }
-      switch (descriptions.length) {
-        case 1:
-          return descriptions[0];
-        case 2:
-          return descriptions[0] + ' or ' + descriptions[1];
-        default:
-          return descriptions.slice(0, -1).join(', ') + ', or ' + descriptions[descriptions.length - 1];
-      }
-    }
-    function describeFound(found1) {
-      return found1 ? '"' + literalEscape(found1) + '"' : 'end of input';
-    }
-    return 'Expected ' + describeExpected(expected) + ' but ' + describeFound(found) + ' found.';
-  }
-  message;
-  expected;
-  found;
-  location;
-  name;
-  constructor(message, expected, found, location) {
-    super();
-    this.message = message;
-    this.expected = expected;
-    this.found = found;
-    this.location = location;
-    this.name = 'SyntaxError';
-    if (typeof Object.setPrototypeOf === 'function') {
-      Object.setPrototypeOf(this, SyntaxError.prototype);
-    } else {
-      this.__proto__ = SyntaxError.prototype;
-    }
-    if (typeof Error.captureStackTrace === 'function') {
-      Error.captureStackTrace(this, SyntaxError);
-    }
-  }
-  format(sources) {
-    let str = 'Error: ' + this.message;
-    if (this.location) {
-      let src = null;
-      let k;
-      for (k = 0; k < sources.length; k++) {
-        if (sources[k].source === this.location.source) {
-          src = sources[k].text.split(/\r\n|\n|\r/g);
-          break;
-        }
-      }
-      let s = this.location.start;
-      let loc = this.location.source + ':' + s.line + ':' + s.column;
-      if (src) {
-        let e = this.location.end;
-        let filler = peg$padEnd('', s.line.toString().length, ' ');
-        let line = src[s.line - 1];
-        let last = s.line === e.line ? e.column : line.length + 1;
-        str +=
-          '\n --> ' +
-          loc +
-          '\n' +
-          filler +
-          ' |\n' +
-          s.line +
-          ' | ' +
-          line +
-          '\n' +
-          filler +
-          ' | ' +
-          peg$padEnd('', s.column - 1, ' ') +
-          peg$padEnd('', last - s.column, '^');
-      } else {
-        str += '\n at ' + loc;
-      }
-    }
-    return str;
-  }
-}
-function peg$parse(input, options) {
-  options = options !== undefined ? options : {};
-  const peg$FAILED = {};
-  const peg$source = options.grammarSource;
-  const peg$startRuleFunctions = {
-    Dot: peg$parseDot,
-    Graph: peg$parseGraph,
-    Subgraph: peg$parseSubgraph,
-    Node: peg$parseNode,
-    Edge: peg$parseEdge,
-    AttributeList: peg$parseAttributeList,
-    Attribute: peg$parseAttribute,
-    ClusterStatements: peg$parseClusterStatements,
-  };
-  let peg$startRuleFunction = peg$parseDot;
-  const peg$c0 = function (v) {
-    return v;
-  };
-  const peg$c1 = function (c1, graph, c2) {
-    return b.createElement('Dot', {}, [...c1, graph, ...c2]);
-  };
-  const peg$c2 = 'strict';
-  const peg$c3 = peg$literalExpectation('strict', true);
-  const peg$c4 = 'graph';
-  const peg$c5 = peg$literalExpectation('graph', true);
-  const peg$c6 = 'digraph';
-  const peg$c7 = peg$literalExpectation('digraph', true);
-  const peg$c8 = '{';
-  const peg$c9 = peg$literalExpectation('{', false);
-  const peg$c10 = '}';
-  const peg$c11 = peg$literalExpectation('}', false);
-  const peg$c12 = function (_strict, _kind, id, children) {
-    const strict = !!_strict;
-    const kind = _kind.toLowerCase();
-    const directed = kind === 'digraph';
-    for (const edgeop of edgeops) {
-      if (directed) {
-        if (edgeop.operator !== '->') {
-          error(`In digraph, it's necessary to describe with "->" operator to create edge.`, edgeop.location);
-        }
-      } else {
-        if (edgeop.operator !== '--') {
-          error(`In graph, it's necessary to describe with "--" operator to create edge.`, edgeop.location);
-        }
-      }
-    }
-    return b.createElement(
-      'Graph',
-      id !== null
-        ? {
-            id,
-            directed,
-            strict,
-          }
-        : {
-            directed,
-            strict,
-          },
-      children,
-    );
-  };
-  const peg$c13 = ';';
-  const peg$c14 = peg$literalExpectation(';', false);
-  const peg$c15 = function (keyValue) {
-    return b.createElement(
-      'Attribute',
-      {
-        ...keyValue,
-      },
-      [],
-    );
-  };
-  const peg$c16 = 'node';
-  const peg$c17 = peg$literalExpectation('node', true);
-  const peg$c18 = 'edge';
-  const peg$c19 = peg$literalExpectation('edge', true);
-  const peg$c20 = function (_kind, children) {
-    return b.createElement(
-      'AttributeList',
-      {
-        kind: _kind.toLowerCase(),
-      },
-      children,
-    );
-  };
-  const peg$c21 = function (id, rhs, _children) {
-    // @ts-ignore
-    return b.createElement(
-      // @ts-ignore
-      'Edge',
-      {
-        targets: [id, ...rhs],
-      },
-      _children ?? [],
-    );
-  };
-  const peg$c22 = function (id, _children) {
-    return b.createElement(
-      'Node',
-      {
-        id,
+  };
+  const peg$c22 = function (id, _children) {
+    return b.createElement(
+      'Node',
+      {
+        id,
       },
       _children ?? [],
     );
@@ -2766,10 +2494,10 @@ function peg$parse(input, options) {
     peg$maxFailExpected.push(expected1);
   }
   function peg$buildSimpleError(message, location1) {
-    return new SyntaxError(message, [], '', location1);
+    return new SyntaxError$1(message, [], '', location1);
   }
   function peg$buildStructuredError(expected1, found, location1) {
-    return new SyntaxError(SyntaxError.buildMessage(expected1, found), expected1, found, location1);
+    return new SyntaxError$1(SyntaxError$1.buildMessage(expected1, found), expected1, found, location1);
   }
   function peg$parseDot() {
     let s0, s1, s2, s3;
@@ -5528,13 +5256,301 @@ const parse$1 = peg$parse;
 function parse(input, options) {
   return parse$1(input, options);
 }
+/**
+ * @group Convert DOT to AST
+ */
+const SyntaxError = SyntaxError$1;
 
+function convertAttribute(key, value) {
+  if (typeof value === 'string') {
+    const trimmed = value.trim();
+    const isHTMLLike = /^<.+>$/ms.test(trimmed);
+    if (isHTMLLike) {
+      return createElement(
+        'Attribute',
+        {
+          key: createElement('Literal', { value: key, quoted: false }, []),
+          value: createElement('Literal', { value: trimmed.slice(1, trimmed.length - 1), quoted: 'html' }, []),
+        },
+        [],
+      );
+    } else {
+      return createElement(
+        'Attribute',
+        {
+          key: createElement('Literal', { value: key, quoted: false }, []),
+          value: createElement('Literal', { value: value, quoted: true }, []),
+        },
+        [],
+      );
+    }
+  }
+  return createElement(
+    'Attribute',
+    {
+      key: createElement('Literal', { value: key, quoted: false }, []),
+      value: createElement('Literal', { value: String(value), quoted: false }, []),
+    },
+    [],
+  );
+}
+
+function convertComment(value, kind) {
+  return createElement(
+    'Comment',
+    {
+      kind: kind,
+      value: value,
+    },
+    [],
+  );
+}
+
+function convertClusterChildren(context, model) {
+  return Array.from(
+    (function* () {
+      for (const [key, value] of model.values) {
+        yield convertAttribute(key, value);
+      }
+      for (const attrs of Object.values(model.attributes)) {
+        if (attrs.size > 0) {
+          if (attrs.comment) {
+            yield convertComment(attrs.comment, context.commentKind);
+          }
+          yield context.convert(attrs);
+        }
+      }
+      for (const node of model.nodes) {
+        if (node.comment) {
+          yield convertComment(node.comment, context.commentKind);
+        }
+        yield context.convert(node);
+      }
+      for (const subgraph of model.subgraphs) {
+        if (subgraph.comment) {
+          yield convertComment(subgraph.comment, context.commentKind);
+        }
+        yield context.convert(subgraph);
+      }
+      for (const edge of model.edges) {
+        if (edge.comment) {
+          yield convertComment(edge.comment, context.commentKind);
+        }
+        yield context.convert(edge);
+      }
+    })(),
+  );
+}
+
+const AttributeListPrintPlugin = {
+  match(model) {
+    return model.$$type === 'AttributeList';
+  },
+  convert(context, model) {
+    return createElement(
+      'AttributeList',
+      {
+        kind: model.$$kind,
+      },
+      model.values.map(([key, value]) => convertAttribute(key, value)),
+    );
+  },
+};
+
+const EdgeConvertPlugin = {
+  match(model) {
+    return model.$$type === 'Edge';
+  },
+  convert(context, model) {
+    return createElement(
+      'Edge',
+      {
+        targets: model.targets.map((target) => {
+          if (common.isNodeModel(target)) {
+            return createElement(
+              'NodeRef',
+              {
+                id: createElement(
+                  'Literal',
+                  {
+                    value: target.id,
+                    quoted: true,
+                  },
+                  [],
+                ),
+              },
+              [],
+            );
+          } else if (common.isForwardRefNode(target)) {
+            return createElement(
+              'NodeRef',
+              {
+                id: createElement(
+                  'Literal',
+                  {
+                    value: target.id,
+                    quoted: true,
+                  },
+                  [],
+                ),
+                port: target.port
+                  ? createElement(
+                      'Literal',
+                      {
+                        value: target.port,
+                        quoted: true,
+                      },
+                      [],
+                    )
+                  : undefined,
+                compass: target.compass
+                  ? createElement(
+                      'Literal',
+                      {
+                        value: target.compass,
+                        quoted: true,
+                      },
+                      [],
+                    )
+                  : undefined,
+              },
+              [],
+            );
+          }
+        }),
+      },
+      [
+        ...(model.attributes.comment ? [convertComment(model.attributes.comment, context.commentKind)] : []),
+        ...model.attributes.values.map(([key, value]) => convertAttribute(key, value)),
+      ],
+    );
+  },
+};
+
+const GraphConvertPlugin = {
+  match(model) {
+    return model.$$type === 'Graph';
+  },
+  convert(context, model) {
+    return createElement('Dot', {}, [
+      ...(model.comment ? [convertComment(model.comment, context.commentKind)] : []),
+      createElement(
+        'Graph',
+        {
+          directed: model.directed,
+          strict: model.strict,
+          id: model.id
+            ? createElement(
+                'Literal',
+                {
+                  value: model.id,
+                  quoted: true,
+                },
+                [],
+              )
+            : undefined,
+        },
+        convertClusterChildren(context, model),
+      ),
+    ]);
+  },
+};
+
+const NodeConvertPlugin = {
+  match(model) {
+    return model.$$type === 'Node';
+  },
+  convert(context, model) {
+    return createElement(
+      'Node',
+      {
+        id: createElement(
+          'Literal',
+          {
+            value: model.id,
+            quoted: true,
+          },
+          [],
+        ),
+      },
+      [
+        ...(model.attributes.comment ? [convertComment(model.attributes.comment, context.commentKind)] : []),
+        ...model.attributes.values.map(([key, value]) => convertAttribute(key, value)),
+      ],
+    );
+  },
+};
+
+const SubgraphConvertPlugin = {
+  match(model) {
+    return model.$$type === 'Subgraph';
+  },
+  convert(context, model) {
+    return createElement(
+      'Subgraph',
+      {
+        id: model.id
+          ? createElement(
+              'Literal',
+              {
+                value: model.id,
+                quoted: true,
+              },
+              [],
+            )
+          : undefined,
+      },
+      convertClusterChildren(context, model),
+    );
+  },
+};
+
+const defaultPlugins = [
+  AttributeListPrintPlugin,
+  EdgeConvertPlugin,
+  NodeConvertPlugin,
+  GraphConvertPlugin,
+  SubgraphConvertPlugin,
+];
+
+/**
+ * @group Convert Model to AST
+ */
+class FromModelConverter {
+  options;
+  /** @hidden */
+  #plugins = [...defaultPlugins];
+  constructor(options = {}) {
+    this.options = options;
+  }
+  convert(model) {
+    const plugins = [...this.#plugins];
+    const { commentKind = 'Slash' } = this.options;
+    const context = {
+      commentKind,
+      convert(m) {
+        for (const plugin of plugins) {
+          /*  */
+          if (plugin.match(m)) {
+            return plugin.convert(context, m);
+          }
+        }
+        throw Error();
+      },
+    };
+    return context.convert(model);
+  }
+}
+
+/**
+ * @group Convert Model to AST
+ */
 function fromModel(model, options) {
-  return new Converter(options).convert(model);
+  return new FromModelConverter(options).convert(model);
 }
 
 exports.Builder = Builder;
-exports.Converter = Converter;
+exports.FromModelConverter = FromModelConverter;
 exports.Printer = Printer;
 exports.SyntaxError = SyntaxError;
 exports.createElement = createElement;