@statelyai/graph 0.3.0 → 0.3.1

package/dist/formats/adjacency-list/index.d.mts

@@ -1,7 +1,41 @@
-import { c as Graph } from "../../types-B6Tpeerk.mjs";
+import { c as Graph } from "../../types-BDXC1O5b.mjs";
 
 //#region src/formats/adjacency-list/index.d.ts
+
+/**
+ * Converts a graph to an adjacency list representation.
+ *
+ * @example
+ * ```ts
+ * import { createGraph, toAdjacencyList } from '@statelyai/graph';
+ *
+ * const graph = createGraph({
+ *   nodes: { a: {}, b: {}, c: {} },
+ *   edges: [{ source: 'a', target: 'b' }, { source: 'a', target: 'c' }],
+ * });
+ *
+ * toAdjacencyList(graph);
+ * // { a: ['b', 'c'], b: [], c: [] }
+ * ```
+ */
 declare function toAdjacencyList(graph: Graph): Record<string, string[]>;
+/**
+ * Parses an adjacency list into a graph.
+ *
+ * @example
+ * ```ts
+ * import { fromAdjacencyList } from '@statelyai/graph';
+ *
+ * const graph = fromAdjacencyList({
+ *   a: ['b', 'c'],
+ *   b: ['c'],
+ *   c: [],
+ * });
+ *
+ * graph.nodes; // [{id: 'a', ...}, {id: 'b', ...}, {id: 'c', ...}]
+ * graph.edges; // [{sourceId: 'a', targetId: 'b', ...}, ...]
+ * ```
+ */
 declare function fromAdjacencyList(adj: Record<string, string[]>, options?: {
   directed?: boolean;
   id?: string;

package/dist/formats/adjacency-list/index.mjs

@@ -1,3 +1,3 @@
-import { n as toAdjacencyList, t as fromAdjacencyList } from "../../adjacency-list-A4_Eiwj3.mjs";
+import { n as toAdjacencyList, t as fromAdjacencyList } from "../../adjacency-list-ITO40kmn.mjs";
 
 export { fromAdjacencyList, toAdjacencyList };

package/dist/formats/converter/index.d.mts

@@ -1,4 +1,4 @@
-import { c as Graph, f as GraphFormatConverter } from "../../types-B6Tpeerk.mjs";
+import { c as Graph, f as GraphFormatConverter } from "../../types-BDXC1O5b.mjs";
 
 //#region src/formats/converter/index.d.ts
 
@@ -19,9 +19,43 @@ import { c as Graph, f as GraphFormatConverter } from "../../types-B6Tpeerk.mjs"
  * ```
  */
 declare function createFormatConverter<TSerial>(to: (graph: Graph) => TSerial, from: (input: TSerial) => Graph): GraphFormatConverter<TSerial>;
-/** Bidirectional converter for adjacency-list format (`Record<string, string[]>`). */
+/**
+ * Bidirectional converter for adjacency-list format (`Record<string, string[]>`).
+ *
+ * @example
+ * ```ts
+ * import { adjacencyListConverter, createGraph } from '@statelyai/graph';
+ *
+ * const graph = createGraph({
+ *   nodes: { a: {}, b: {} },
+ *   edges: [{ source: 'a', target: 'b' }],
+ * });
+ *
+ * const adj = adjacencyListConverter.to(graph);
+ * // { a: ['b'], b: [] }
+ *
+ * const roundTripped = adjacencyListConverter.from(adj);
+ * ```
+ */
 declare const adjacencyListConverter: GraphFormatConverter<Record<string, string[]>>;
-/** Bidirectional converter for edge-list format (`[source, target][]`). */
+/**
+ * Bidirectional converter for edge-list format (`[source, target][]`).
+ *
+ * @example
+ * ```ts
+ * import { edgeListConverter, createGraph } from '@statelyai/graph';
+ *
+ * const graph = createGraph({
+ *   nodes: { a: {}, b: {} },
+ *   edges: [{ source: 'a', target: 'b' }],
+ * });
+ *
+ * const edges = edgeListConverter.to(graph);
+ * // [['a', 'b']]
+ *
+ * const roundTripped = edgeListConverter.from(edges);
+ * ```
+ */
 declare const edgeListConverter: GraphFormatConverter<[string, string][]>;
 //#endregion
 export { adjacencyListConverter, createFormatConverter, edgeListConverter };

package/dist/formats/converter/index.mjs

@@ -1,3 +1,3 @@
-import { n as createFormatConverter, r as edgeListConverter, t as adjacencyListConverter } from "../../converter-DnbeyE_p.mjs";
+import { n as createFormatConverter, r as edgeListConverter, t as adjacencyListConverter } from "../../converter-CchokMDg.mjs";
 
 export { adjacencyListConverter, createFormatConverter, edgeListConverter };

package/dist/formats/cytoscape/index.d.mts

@@ -1,4 +1,4 @@
-import { c as Graph, f as GraphFormatConverter } from "../../types-B6Tpeerk.mjs";
+import { c as Graph, f as GraphFormatConverter } from "../../types-BDXC1O5b.mjs";
 
 //#region src/formats/cytoscape/index.d.ts
 interface CytoscapeNode {
@@ -27,9 +27,57 @@ interface CytoscapeJSON {
     edges: CytoscapeEdge[];
   };
 }
+/**
+ * Converts a graph to Cytoscape.js JSON format.
+ *
+ * @example
+ * ```ts
+ * import { createGraph } from '@statelyai/graph';
+ * import { toCytoscapeJSON } from '@statelyai/graph/formats/cytoscape';
+ *
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }],
+ *   edges: [{ id: 'e0', sourceId: 'a', targetId: 'b' }],
+ * });
+ *
+ * const cyto = toCytoscapeJSON(graph);
+ * // { elements: { nodes: [...], edges: [...] } }
+ * ```
+ */
 declare function toCytoscapeJSON(graph: Graph): CytoscapeJSON;
+/**
+ * Parses a Cytoscape.js JSON object into a graph.
+ *
+ * @example
+ * ```ts
+ * import { fromCytoscapeJSON } from '@statelyai/graph/formats/cytoscape';
+ *
+ * const graph = fromCytoscapeJSON({
+ *   elements: {
+ *     nodes: [{ data: { id: 'a' } }, { data: { id: 'b' } }],
+ *     edges: [{ data: { id: 'e0', source: 'a', target: 'b' } }],
+ *   },
+ * });
+ * ```
+ */
 declare function fromCytoscapeJSON(cyto: CytoscapeJSON): Graph;
-/** Bidirectional converter for Cytoscape.js JSON format. */
+/**
+ * Bidirectional converter for Cytoscape.js JSON format.
+ *
+ * @example
+ * ```ts
+ * import { createGraph } from '@statelyai/graph';
+ * import { cytoscapeConverter } from '@statelyai/graph/formats/cytoscape';
+ *
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }],
+ *   edges: [{ id: 'e0', sourceId: 'a', targetId: 'b' }],
+ * });
+ *
+ * const cyto = cytoscapeConverter.to(graph);
+ * const roundTripped = cytoscapeConverter.from(cyto);
+ * ```
+ */
 declare const cytoscapeConverter: GraphFormatConverter<CytoscapeJSON>;
 //#endregion
 export { CytoscapeEdge, CytoscapeJSON, CytoscapeNode, cytoscapeConverter, fromCytoscapeJSON, toCytoscapeJSON };

package/dist/formats/cytoscape/index.mjs

@@ -1,6 +1,23 @@
-import { n as createFormatConverter } from "../../converter-DnbeyE_p.mjs";
+import { n as createFormatConverter } from "../../converter-CchokMDg.mjs";
 
 //#region src/formats/cytoscape/index.ts
+/**
+* Converts a graph to Cytoscape.js JSON format.
+*
+* @example
+* ```ts
+* import { createGraph } from '@statelyai/graph';
+* import { toCytoscapeJSON } from '@statelyai/graph/formats/cytoscape';
+*
+* const graph = createGraph({
+*   nodes: [{ id: 'a' }, { id: 'b' }],
+*   edges: [{ id: 'e0', sourceId: 'a', targetId: 'b' }],
+* });
+*
+* const cyto = toCytoscapeJSON(graph);
+* // { elements: { nodes: [...], edges: [...] } }
+* ```
+*/
 function toCytoscapeJSON(graph) {
 	const graphData = {};
 	if (graph.id) graphData.id = graph.id;
@@ -42,6 +59,21 @@ function toCytoscapeJSON(graph) {
 		}
 	};
 }
+/**
+* Parses a Cytoscape.js JSON object into a graph.
+*
+* @example
+* ```ts
+* import { fromCytoscapeJSON } from '@statelyai/graph/formats/cytoscape';
+*
+* const graph = fromCytoscapeJSON({
+*   elements: {
+*     nodes: [{ data: { id: 'a' } }, { data: { id: 'b' } }],
+*     edges: [{ data: { id: 'e0', source: 'a', target: 'b' } }],
+*   },
+* });
+* ```
+*/
 function fromCytoscapeJSON(cyto) {
 	if (!cyto || typeof cyto !== "object") throw new Error("Cytoscape: expected an object");
 	if (!cyto.elements || typeof cyto.elements !== "object") throw new Error("Cytoscape: missing \"elements\" property");
@@ -80,7 +112,23 @@ function fromCytoscapeJSON(cyto) {
 		}))
 	};
 }
-/** Bidirectional converter for Cytoscape.js JSON format. */
+/**
+* Bidirectional converter for Cytoscape.js JSON format.
+*
+* @example
+* ```ts
+* import { createGraph } from '@statelyai/graph';
+* import { cytoscapeConverter } from '@statelyai/graph/formats/cytoscape';
+*
+* const graph = createGraph({
+*   nodes: [{ id: 'a' }, { id: 'b' }],
+*   edges: [{ id: 'e0', sourceId: 'a', targetId: 'b' }],
+* });
+*
+* const cyto = cytoscapeConverter.to(graph);
+* const roundTripped = cytoscapeConverter.from(cyto);
+* ```
+*/
 const cytoscapeConverter = createFormatConverter(toCytoscapeJSON, fromCytoscapeJSON);
 
 //#endregion

package/dist/formats/d3/index.d.mts

@@ -1,4 +1,4 @@
-import { c as Graph, f as GraphFormatConverter } from "../../types-B6Tpeerk.mjs";
+import { c as Graph, f as GraphFormatConverter } from "../../types-BDXC1O5b.mjs";
 
 //#region src/formats/d3/index.d.ts
 interface D3Node {
@@ -14,9 +14,55 @@ interface D3Graph {
   nodes: D3Node[];
   links: D3Link[];
 }
+/**
+ * Converts a graph to D3.js force-directed format.
+ *
+ * @example
+ * ```ts
+ * import { createGraph } from '@statelyai/graph';
+ * import { toD3Graph } from '@statelyai/graph/formats/d3';
+ *
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }],
+ *   edges: [{ id: 'e0', sourceId: 'a', targetId: 'b' }],
+ * });
+ *
+ * const d3 = toD3Graph(graph);
+ * // { nodes: [{ id: 'a' }, { id: 'b' }], links: [{ source: 'a', target: 'b' }] }
+ * ```
+ */
 declare function toD3Graph(graph: Graph): D3Graph;
+/**
+ * Parses a D3.js force-directed JSON object into a graph.
+ *
+ * @example
+ * ```ts
+ * import { fromD3Graph } from '@statelyai/graph/formats/d3';
+ *
+ * const graph = fromD3Graph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }],
+ *   links: [{ source: 'a', target: 'b' }],
+ * });
+ * ```
+ */
 declare function fromD3Graph(d3: D3Graph): Graph;
-/** Bidirectional converter for D3.js force-directed JSON format. */
+/**
+ * Bidirectional converter for D3.js force-directed JSON format.
+ *
+ * @example
+ * ```ts
+ * import { createGraph } from '@statelyai/graph';
+ * import { d3Converter } from '@statelyai/graph/formats/d3';
+ *
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }],
+ *   edges: [{ id: 'e0', sourceId: 'a', targetId: 'b' }],
+ * });
+ *
+ * const d3 = d3Converter.to(graph);
+ * const roundTripped = d3Converter.from(d3);
+ * ```
+ */
 declare const d3Converter: GraphFormatConverter<D3Graph>;
 //#endregion
 export { D3Graph, D3Link, D3Node, d3Converter, fromD3Graph, toD3Graph };

package/dist/formats/d3/index.mjs

@@ -1,6 +1,23 @@
-import { n as createFormatConverter } from "../../converter-DnbeyE_p.mjs";
+import { n as createFormatConverter } from "../../converter-CchokMDg.mjs";
 
 //#region src/formats/d3/index.ts
+/**
+* Converts a graph to D3.js force-directed format.
+*
+* @example
+* ```ts
+* import { createGraph } from '@statelyai/graph';
+* import { toD3Graph } from '@statelyai/graph/formats/d3';
+*
+* const graph = createGraph({
+*   nodes: [{ id: 'a' }, { id: 'b' }],
+*   edges: [{ id: 'e0', sourceId: 'a', targetId: 'b' }],
+* });
+*
+* const d3 = toD3Graph(graph);
+* // { nodes: [{ id: 'a' }, { id: 'b' }], links: [{ source: 'a', target: 'b' }] }
+* ```
+*/
 function toD3Graph(graph) {
 	return {
 		nodes: graph.nodes.map((n) => {
@@ -26,6 +43,19 @@ function toD3Graph(graph) {
 		})
 	};
 }
+/**
+* Parses a D3.js force-directed JSON object into a graph.
+*
+* @example
+* ```ts
+* import { fromD3Graph } from '@statelyai/graph/formats/d3';
+*
+* const graph = fromD3Graph({
+*   nodes: [{ id: 'a' }, { id: 'b' }],
+*   links: [{ source: 'a', target: 'b' }],
+* });
+* ```
+*/
 function fromD3Graph(d3) {
 	if (!d3 || typeof d3 !== "object") throw new Error("D3: expected an object");
 	if (!Array.isArray(d3.nodes)) throw new Error("D3: \"nodes\" must be an array");
@@ -58,7 +88,23 @@ function fromD3Graph(d3) {
 		}))
 	};
 }
-/** Bidirectional converter for D3.js force-directed JSON format. */
+/**
+* Bidirectional converter for D3.js force-directed JSON format.
+*
+* @example
+* ```ts
+* import { createGraph } from '@statelyai/graph';
+* import { d3Converter } from '@statelyai/graph/formats/d3';
+*
+* const graph = createGraph({
+*   nodes: [{ id: 'a' }, { id: 'b' }],
+*   edges: [{ id: 'e0', sourceId: 'a', targetId: 'b' }],
+* });
+*
+* const d3 = d3Converter.to(graph);
+* const roundTripped = d3Converter.from(d3);
+* ```
+*/
 const d3Converter = createFormatConverter(toD3Graph, fromD3Graph);
 
 //#endregion

package/dist/formats/dot/index.d.mts

@@ -1,9 +1,63 @@
-import { c as Graph, f as GraphFormatConverter } from "../../types-B6Tpeerk.mjs";
+import { c as Graph, f as GraphFormatConverter } from "../../types-BDXC1O5b.mjs";
 
 //#region src/formats/dot/index.d.ts
+
+/**
+ * Converts a graph to a DOT (Graphviz) format string.
+ *
+ * @example
+ * ```ts
+ * import { createGraph, toDOT } from '@statelyai/graph';
+ *
+ * const graph = createGraph({
+ *   nodes: { a: {}, b: {} },
+ *   edges: [{ source: 'a', target: 'b' }],
+ * });
+ *
+ * const dot = toDOT(graph);
+ * // digraph "" {
+ * //   a;
+ * //   b;
+ * //   a -> b;
+ * // }
+ * ```
+ */
 declare function toDOT(graph: Graph): string;
+/**
+ * Parses a DOT (Graphviz) format string into a graph.
+ *
+ * @example
+ * ```ts
+ * import { fromDOT } from '@statelyai/graph';
+ *
+ * const graph = fromDOT(`
+ *   digraph {
+ *     a -> b;
+ *     b -> c;
+ *   }
+ * `);
+ *
+ * graph.nodes; // [{id: 'a', ...}, {id: 'b', ...}, {id: 'c', ...}]
+ * graph.edges; // [{sourceId: 'a', targetId: 'b', ...}, ...]
+ * ```
+ */
 declare function fromDOT(dot: string): Graph;
-/** Bidirectional converter for DOT (Graphviz) format. */
+/**
+ * Bidirectional converter for DOT (Graphviz) format.
+ *
+ * @example
+ * ```ts
+ * import { dotConverter, createGraph } from '@statelyai/graph';
+ *
+ * const graph = createGraph({
+ *   nodes: { a: {}, b: {} },
+ *   edges: [{ source: 'a', target: 'b' }],
+ * });
+ *
+ * const dot = dotConverter.to(graph);
+ * const roundTripped = dotConverter.from(dot);
+ * ```
+ */
 declare const dotConverter: GraphFormatConverter<string>;
 //#endregion
 export { dotConverter, fromDOT, toDOT };

package/dist/formats/dot/index.mjs

@@ -1,4 +1,4 @@
-import { n as createFormatConverter } from "../../converter-DnbeyE_p.mjs";
+import { n as createFormatConverter } from "../../converter-CchokMDg.mjs";
 import parse from "dotparser";
 
 //#region src/formats/dot/index.ts
@@ -26,6 +26,26 @@ const SHAPE_TO_DOT = {
 	cylinder: "cylinder",
 	parallelogram: "parallelogram"
 };
+/**
+* Converts a graph to a DOT (Graphviz) format string.
+*
+* @example
+* ```ts
+* import { createGraph, toDOT } from '@statelyai/graph';
+*
+* const graph = createGraph({
+*   nodes: { a: {}, b: {} },
+*   edges: [{ source: 'a', target: 'b' }],
+* });
+*
+* const dot = toDOT(graph);
+* // digraph "" {
+* //   a;
+* //   b;
+* //   a -> b;
+* // }
+* ```
+*/
 function toDOT(graph) {
 	const isDirected = graph.type === "directed";
 	const keyword = isDirected ? "digraph" : "graph";
@@ -100,6 +120,24 @@ function nodeFromAttrs(id, attrs, defaults, parentId) {
 		...color && { color }
 	};
 }
+/**
+* Parses a DOT (Graphviz) format string into a graph.
+*
+* @example
+* ```ts
+* import { fromDOT } from '@statelyai/graph';
+*
+* const graph = fromDOT(`
+*   digraph {
+*     a -> b;
+*     b -> c;
+*   }
+* `);
+*
+* graph.nodes; // [{id: 'a', ...}, {id: 'b', ...}, {id: 'c', ...}]
+* graph.edges; // [{sourceId: 'a', targetId: 'b', ...}, ...]
+* ```
+*/
 function fromDOT(dot) {
 	if (typeof dot !== "string") throw new Error("DOT: expected a string");
 	if (!dot.trim()) throw new Error("DOT: input is empty");
@@ -228,7 +266,22 @@ function fromDOT(dot) {
 		...direction && { direction }
 	};
 }
-/** Bidirectional converter for DOT (Graphviz) format. */
+/**
+* Bidirectional converter for DOT (Graphviz) format.
+*
+* @example
+* ```ts
+* import { dotConverter, createGraph } from '@statelyai/graph';
+*
+* const graph = createGraph({
+*   nodes: { a: {}, b: {} },
+*   edges: [{ source: 'a', target: 'b' }],
+* });
+*
+* const dot = dotConverter.to(graph);
+* const roundTripped = dotConverter.from(dot);
+* ```
+*/
 const dotConverter = createFormatConverter(toDOT, fromDOT);
 
 //#endregion

package/dist/formats/edge-list/index.d.mts

@@ -1,7 +1,40 @@
-import { c as Graph } from "../../types-B6Tpeerk.mjs";
+import { c as Graph } from "../../types-BDXC1O5b.mjs";
 
 //#region src/formats/edge-list/index.d.ts
+
+/**
+ * Converts a graph to an edge list of `[source, target]` tuples.
+ *
+ * @example
+ * ```ts
+ * import { createGraph, toEdgeList } from '@statelyai/graph';
+ *
+ * const graph = createGraph({
+ *   nodes: { a: {}, b: {}, c: {} },
+ *   edges: [{ source: 'a', target: 'b' }, { source: 'b', target: 'c' }],
+ * });
+ *
+ * toEdgeList(graph);
+ * // [['a', 'b'], ['b', 'c']]
+ * ```
+ */
 declare function toEdgeList(graph: Graph): [string, string][];
+/**
+ * Parses an edge list of `[source, target]` tuples into a graph.
+ *
+ * @example
+ * ```ts
+ * import { fromEdgeList } from '@statelyai/graph';
+ *
+ * const graph = fromEdgeList([
+ *   ['a', 'b'],
+ *   ['b', 'c'],
+ * ]);
+ *
+ * graph.nodes; // [{id: 'a', ...}, {id: 'b', ...}, {id: 'c', ...}]
+ * graph.edges; // [{sourceId: 'a', targetId: 'b', ...}, ...]
+ * ```
+ */
 declare function fromEdgeList(edges: [string, string][], options?: {
   directed?: boolean;
   id?: string;

package/dist/formats/edge-list/index.mjs

@@ -1,3 +1,3 @@
-import { n as toEdgeList, t as fromEdgeList } from "../../edge-list-DuHMz8hf.mjs";
+import { n as toEdgeList, t as fromEdgeList } from "../../edge-list-CgX6bBIF.mjs";
 
 export { fromEdgeList, toEdgeList };

package/dist/formats/gexf/index.d.mts

@@ -1,4 +1,4 @@
-import { c as Graph, f as GraphFormatConverter } from "../../types-B6Tpeerk.mjs";
+import { c as Graph, f as GraphFormatConverter } from "../../types-BDXC1O5b.mjs";
 
 //#region src/formats/gexf/index.d.ts
 declare function toGEXF(graph: Graph): string;

package/dist/formats/gexf/index.mjs

@@ -1,4 +1,4 @@
-import { n as createFormatConverter } from "../../converter-DnbeyE_p.mjs";
+import { n as createFormatConverter } from "../../converter-CchokMDg.mjs";
 import { XMLBuilder, XMLParser } from "fast-xml-parser";
 
 //#region src/formats/gexf/index.ts

package/dist/formats/gml/index.d.mts

@@ -1,9 +1,65 @@
-import { c as Graph, f as GraphFormatConverter } from "../../types-B6Tpeerk.mjs";
+import { c as Graph, f as GraphFormatConverter } from "../../types-BDXC1O5b.mjs";
 
 //#region src/formats/gml/index.d.ts
+
+/**
+ * Converts a graph to GML (Graph Modelling Language) string.
+ *
+ * @example
+ * ```ts
+ * import { createGraph } from '@statelyai/graph';
+ * import { toGML } from '@statelyai/graph/formats/gml';
+ *
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }],
+ *   edges: [{ id: 'e0', sourceId: 'a', targetId: 'b' }],
+ * });
+ *
+ * const gml = toGML(graph);
+ * // graph [
+ * //   directed 1
+ * //   node [ id "a" ]
+ * //   node [ id "b" ]
+ * //   edge [ id "e0" source "a" target "b" ]
+ * // ]
+ * ```
+ */
 declare function toGML(graph: Graph): string;
+/**
+ * Parses a GML (Graph Modelling Language) string into a graph.
+ *
+ * @example
+ * ```ts
+ * import { fromGML } from '@statelyai/graph/formats/gml';
+ *
+ * const graph = fromGML(`
+ *   graph [
+ *     directed 1
+ *     node [ id "a" ]
+ *     node [ id "b" ]
+ *     edge [ source "a" target "b" ]
+ *   ]
+ * `);
+ * ```
+ */
 declare function fromGML(gml: string): Graph;
-/** Bidirectional converter for GML (Graph Modelling Language) format. */
+/**
+ * Bidirectional converter for GML (Graph Modelling Language) format.
+ *
+ * @example
+ * ```ts
+ * import { createGraph } from '@statelyai/graph';
+ * import { gmlConverter } from '@statelyai/graph/formats/gml';
+ *
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }],
+ *   edges: [{ id: 'e0', sourceId: 'a', targetId: 'b' }],
+ * });
+ *
+ * const gml = gmlConverter.to(graph);
+ * const roundTripped = gmlConverter.from(gml);
+ * ```
+ */
 declare const gmlConverter: GraphFormatConverter<string>;
 //#endregion
 export { fromGML, gmlConverter, toGML };