cariboujs 2.0.4 → 2.0.6

package/wkt/wktParser.js

@@ -4,109 +4,129 @@ import antlr4 from 'antlr4';
 import wktListener from './wktListener.js';
 import wktVisitor from './wktVisitor.js';
 
-const serializedATN = [4,1,24,316,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,
+const serializedATN = [4,1,31,375,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,
 4,2,5,7,5,2,6,7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,
 2,13,7,13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,
-20,7,20,1,0,5,0,44,8,0,10,0,12,0,47,9,0,1,0,1,0,1,1,1,1,1,1,1,1,1,1,5,1,
-56,8,1,10,1,12,1,59,9,1,1,1,1,1,1,1,3,1,64,8,1,1,2,1,2,1,2,1,2,1,2,1,2,1,
-2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,3,2,80,8,2,1,3,1,3,3,3,84,8,3,1,3,1,3,1,3,
-1,3,1,3,3,3,91,8,3,1,4,1,4,1,4,1,5,1,5,1,5,1,6,1,6,1,6,1,6,1,6,3,6,104,8,
-6,1,6,1,6,1,6,1,6,3,6,110,8,6,5,6,112,8,6,10,6,12,6,115,9,6,1,6,1,6,1,6,
-3,6,120,8,6,1,7,1,7,1,7,1,7,3,7,126,8,7,1,7,1,7,1,7,3,7,131,8,7,5,7,133,
-8,7,10,7,12,7,136,9,7,1,7,1,7,1,7,3,7,141,8,7,1,8,1,8,1,8,1,8,1,8,3,8,148,
-8,8,1,8,1,8,1,8,1,8,3,8,154,8,8,5,8,156,8,8,10,8,12,8,159,9,8,1,8,1,8,1,
-8,3,8,164,8,8,1,9,1,9,1,9,1,9,3,9,170,8,9,1,9,1,9,1,9,3,9,175,8,9,5,9,177,
-8,9,10,9,12,9,180,9,9,1,9,1,9,1,9,3,9,185,8,9,1,10,1,10,1,10,1,10,1,10,5,
-10,192,8,10,10,10,12,10,195,9,10,1,10,1,10,1,10,3,10,200,8,10,1,11,1,11,
-1,11,1,11,1,11,5,11,207,8,11,10,11,12,11,210,9,11,1,11,1,11,1,11,3,11,215,
-8,11,1,12,1,12,1,12,1,12,1,12,5,12,222,8,12,10,12,12,12,225,9,12,1,12,1,
-12,1,12,3,12,230,8,12,1,13,1,13,1,13,1,13,1,13,5,13,237,8,13,10,13,12,13,
-240,9,13,1,13,1,13,1,13,3,13,245,8,13,1,14,1,14,1,14,1,14,1,14,5,14,252,
-8,14,10,14,12,14,255,9,14,1,14,1,14,1,14,3,14,260,8,14,1,15,1,15,1,15,1,
-15,1,15,5,15,267,8,15,10,15,12,15,270,9,15,1,15,1,15,1,16,1,16,1,16,1,16,
-1,16,3,16,279,8,16,1,17,1,17,1,17,1,17,5,17,285,8,17,10,17,12,17,288,9,17,
-1,17,1,17,1,17,3,17,293,8,17,1,18,1,18,1,18,1,18,5,18,299,8,18,10,18,12,
-18,302,9,18,1,18,1,18,1,18,3,18,307,8,18,1,19,4,19,310,8,19,11,19,12,19,
-311,1,20,1,20,1,20,0,0,21,0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,
-34,36,38,40,0,0,349,0,45,1,0,0,0,2,50,1,0,0,0,4,79,1,0,0,0,6,81,1,0,0,0,
-8,92,1,0,0,0,10,95,1,0,0,0,12,98,1,0,0,0,14,121,1,0,0,0,16,142,1,0,0,0,18,
-165,1,0,0,0,20,186,1,0,0,0,22,201,1,0,0,0,24,216,1,0,0,0,26,231,1,0,0,0,
-28,246,1,0,0,0,30,261,1,0,0,0,32,278,1,0,0,0,34,292,1,0,0,0,36,306,1,0,0,
-0,38,309,1,0,0,0,40,313,1,0,0,0,42,44,3,4,2,0,43,42,1,0,0,0,44,47,1,0,0,
-0,45,43,1,0,0,0,45,46,1,0,0,0,46,48,1,0,0,0,47,45,1,0,0,0,48,49,5,0,0,1,
-49,1,1,0,0,0,50,63,5,13,0,0,51,52,5,5,0,0,52,57,3,4,2,0,53,54,5,4,0,0,54,
-56,3,4,2,0,55,53,1,0,0,0,56,59,1,0,0,0,57,55,1,0,0,0,57,58,1,0,0,0,58,60,
-1,0,0,0,59,57,1,0,0,0,60,61,5,6,0,0,61,64,1,0,0,0,62,64,5,14,0,0,63,51,1,
-0,0,0,63,62,1,0,0,0,64,3,1,0,0,0,65,80,3,10,5,0,66,80,3,8,4,0,67,80,3,6,
-3,0,68,80,3,18,9,0,69,80,3,16,8,0,70,80,3,14,7,0,71,80,3,12,6,0,72,80,3,
-20,10,0,73,80,3,22,11,0,74,80,3,24,12,0,75,80,3,30,15,0,76,80,3,26,13,0,
-77,80,3,28,14,0,78,80,3,2,1,0,79,65,1,0,0,0,79,66,1,0,0,0,79,67,1,0,0,0,
-79,68,1,0,0,0,79,69,1,0,0,0,79,70,1,0,0,0,79,71,1,0,0,0,79,72,1,0,0,0,79,
-73,1,0,0,0,79,74,1,0,0,0,79,75,1,0,0,0,79,76,1,0,0,0,79,77,1,0,0,0,79,78,
-1,0,0,0,80,5,1,0,0,0,81,90,5,7,0,0,82,84,3,40,20,0,83,82,1,0,0,0,83,84,1,
-0,0,0,84,85,1,0,0,0,85,86,5,5,0,0,86,87,3,38,19,0,87,88,5,6,0,0,88,91,1,
-0,0,0,89,91,5,14,0,0,90,83,1,0,0,0,90,89,1,0,0,0,91,7,1,0,0,0,92,93,5,8,
-0,0,93,94,3,36,18,0,94,9,1,0,0,0,95,96,5,9,0,0,96,97,3,34,17,0,97,11,1,0,
-0,0,98,119,5,19,0,0,99,103,5,5,0,0,100,104,3,36,18,0,101,104,3,30,15,0,102,
-104,3,18,9,0,103,100,1,0,0,0,103,101,1,0,0,0,103,102,1,0,0,0,104,113,1,0,
-0,0,105,109,5,4,0,0,106,110,3,30,15,0,107,110,3,36,18,0,108,110,3,18,9,0,
-109,106,1,0,0,0,109,107,1,0,0,0,109,108,1,0,0,0,110,112,1,0,0,0,111,105,
-1,0,0,0,112,115,1,0,0,0,113,111,1,0,0,0,113,114,1,0,0,0,114,116,1,0,0,0,
-115,113,1,0,0,0,116,117,5,6,0,0,117,120,1,0,0,0,118,120,5,14,0,0,119,99,
-1,0,0,0,119,118,1,0,0,0,120,13,1,0,0,0,121,140,5,17,0,0,122,125,5,5,0,0,
-123,126,3,34,17,0,124,126,3,16,8,0,125,123,1,0,0,0,125,124,1,0,0,0,126,134,
-1,0,0,0,127,130,5,4,0,0,128,131,3,34,17,0,129,131,3,16,8,0,130,128,1,0,0,
-0,130,129,1,0,0,0,131,133,1,0,0,0,132,127,1,0,0,0,133,136,1,0,0,0,134,132,
-1,0,0,0,134,135,1,0,0,0,135,137,1,0,0,0,136,134,1,0,0,0,137,138,5,6,0,0,
-138,141,1,0,0,0,139,141,5,14,0,0,140,122,1,0,0,0,140,139,1,0,0,0,141,15,
-1,0,0,0,142,163,5,18,0,0,143,147,5,5,0,0,144,148,3,36,18,0,145,148,3,30,
-15,0,146,148,3,18,9,0,147,144,1,0,0,0,147,145,1,0,0,0,147,146,1,0,0,0,148,
-157,1,0,0,0,149,153,5,4,0,0,150,154,3,30,15,0,151,154,3,36,18,0,152,154,
-3,18,9,0,153,150,1,0,0,0,153,151,1,0,0,0,153,152,1,0,0,0,154,156,1,0,0,0,
-155,149,1,0,0,0,156,159,1,0,0,0,157,155,1,0,0,0,157,158,1,0,0,0,158,160,
-1,0,0,0,159,157,1,0,0,0,160,161,5,6,0,0,161,164,1,0,0,0,162,164,5,14,0,0,
-163,143,1,0,0,0,163,162,1,0,0,0,164,17,1,0,0,0,165,184,5,16,0,0,166,169,
-5,5,0,0,167,170,3,36,18,0,168,170,3,30,15,0,169,167,1,0,0,0,169,168,1,0,
-0,0,170,178,1,0,0,0,171,174,5,4,0,0,172,175,3,30,15,0,173,175,3,36,18,0,
-174,172,1,0,0,0,174,173,1,0,0,0,175,177,1,0,0,0,176,171,1,0,0,0,177,180,
-1,0,0,0,178,176,1,0,0,0,178,179,1,0,0,0,179,181,1,0,0,0,180,178,1,0,0,0,
-181,182,5,6,0,0,182,185,1,0,0,0,183,185,5,14,0,0,184,166,1,0,0,0,184,183,
-1,0,0,0,185,19,1,0,0,0,186,199,5,10,0,0,187,188,5,5,0,0,188,193,3,32,16,
-0,189,190,5,4,0,0,190,192,3,32,16,0,191,189,1,0,0,0,192,195,1,0,0,0,193,
-191,1,0,0,0,193,194,1,0,0,0,194,196,1,0,0,0,195,193,1,0,0,0,196,197,5,6,
-0,0,197,200,1,0,0,0,198,200,5,14,0,0,199,187,1,0,0,0,199,198,1,0,0,0,200,
-21,1,0,0,0,201,214,5,11,0,0,202,203,5,5,0,0,203,208,3,36,18,0,204,205,5,
-4,0,0,205,207,3,36,18,0,206,204,1,0,0,0,207,210,1,0,0,0,208,206,1,0,0,0,
-208,209,1,0,0,0,209,211,1,0,0,0,210,208,1,0,0,0,211,212,5,6,0,0,212,215,
-1,0,0,0,213,215,5,14,0,0,214,202,1,0,0,0,214,213,1,0,0,0,215,23,1,0,0,0,
-216,229,5,12,0,0,217,218,5,5,0,0,218,223,3,34,17,0,219,220,5,4,0,0,220,222,
-3,34,17,0,221,219,1,0,0,0,222,225,1,0,0,0,223,221,1,0,0,0,223,224,1,0,0,
-0,224,226,1,0,0,0,225,223,1,0,0,0,226,227,5,6,0,0,227,230,1,0,0,0,228,230,
-5,14,0,0,229,217,1,0,0,0,229,228,1,0,0,0,230,25,1,0,0,0,231,244,5,22,0,0,
-232,233,5,5,0,0,233,238,3,34,17,0,234,235,5,4,0,0,235,237,3,34,17,0,236,
-234,1,0,0,0,237,240,1,0,0,0,238,236,1,0,0,0,238,239,1,0,0,0,239,241,1,0,
-0,0,240,238,1,0,0,0,241,242,5,6,0,0,242,245,1,0,0,0,243,245,5,14,0,0,244,
-232,1,0,0,0,244,243,1,0,0,0,245,27,1,0,0,0,246,259,5,21,0,0,247,248,5,5,
-0,0,248,253,3,34,17,0,249,250,5,4,0,0,250,252,3,34,17,0,251,249,1,0,0,0,
-252,255,1,0,0,0,253,251,1,0,0,0,253,254,1,0,0,0,254,256,1,0,0,0,255,253,
-1,0,0,0,256,257,5,6,0,0,257,260,1,0,0,0,258,260,5,14,0,0,259,247,1,0,0,0,
-259,258,1,0,0,0,260,29,1,0,0,0,261,262,5,15,0,0,262,263,5,5,0,0,263,268,
-3,38,19,0,264,265,5,4,0,0,265,267,3,38,19,0,266,264,1,0,0,0,267,270,1,0,
-0,0,268,266,1,0,0,0,268,269,1,0,0,0,269,271,1,0,0,0,270,268,1,0,0,0,271,
-272,5,6,0,0,272,31,1,0,0,0,273,279,3,38,19,0,274,275,5,5,0,0,275,276,3,38,
-19,0,276,277,5,6,0,0,277,279,1,0,0,0,278,273,1,0,0,0,278,274,1,0,0,0,279,
-33,1,0,0,0,280,281,5,5,0,0,281,286,3,36,18,0,282,283,5,4,0,0,283,285,3,36,
-18,0,284,282,1,0,0,0,285,288,1,0,0,0,286,284,1,0,0,0,286,287,1,0,0,0,287,
-289,1,0,0,0,288,286,1,0,0,0,289,290,5,6,0,0,290,293,1,0,0,0,291,293,5,14,
-0,0,292,280,1,0,0,0,292,291,1,0,0,0,293,35,1,0,0,0,294,295,5,5,0,0,295,300,
-3,38,19,0,296,297,5,4,0,0,297,299,3,38,19,0,298,296,1,0,0,0,299,302,1,0,
-0,0,300,298,1,0,0,0,300,301,1,0,0,0,301,303,1,0,0,0,302,300,1,0,0,0,303,
-304,5,6,0,0,304,307,1,0,0,0,305,307,5,14,0,0,306,294,1,0,0,0,306,305,1,0,
-0,0,307,37,1,0,0,0,308,310,5,1,0,0,309,308,1,0,0,0,310,311,1,0,0,0,311,309,
-1,0,0,0,311,312,1,0,0,0,312,39,1,0,0,0,313,314,5,23,0,0,314,41,1,0,0,0,39,
-45,57,63,79,83,90,103,109,113,119,125,130,134,140,147,153,157,163,169,174,
-178,184,193,199,208,214,223,229,238,244,253,259,268,278,286,292,300,306,
-311];
+20,7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7,26,2,27,
+7,27,1,0,5,0,58,8,0,10,0,12,0,61,9,0,1,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,81,8,1,1,2,1,2,1,3,1,3,3,3,87,8,
+3,1,3,1,3,1,3,1,3,1,3,3,3,94,8,3,1,4,1,4,3,4,98,8,4,1,4,1,4,1,5,1,5,3,5,
+104,8,5,1,5,1,5,1,6,1,6,3,6,110,8,6,1,6,1,6,1,7,1,7,3,7,116,8,7,1,7,1,7,
+1,8,1,8,3,8,122,8,8,1,8,1,8,1,8,1,8,5,8,128,8,8,10,8,12,8,131,9,8,1,8,1,
+8,1,8,3,8,136,8,8,1,9,1,9,3,9,140,8,9,1,9,1,9,1,9,1,9,5,9,146,8,9,10,9,12,
+9,149,9,9,1,9,1,9,1,9,3,9,154,8,9,1,10,1,10,3,10,158,8,10,1,10,1,10,1,10,
+1,10,5,10,164,8,10,10,10,12,10,167,9,10,1,10,1,10,1,10,3,10,172,8,10,1,11,
+1,11,3,11,176,8,11,1,11,1,11,1,11,1,11,5,11,182,8,11,10,11,12,11,185,9,11,
+1,11,1,11,1,11,3,11,190,8,11,1,12,1,12,3,12,194,8,12,1,12,1,12,1,13,1,13,
+3,13,200,8,13,1,13,1,13,1,13,1,13,5,13,206,8,13,10,13,12,13,209,9,13,1,13,
+1,13,1,13,3,13,214,8,13,1,14,1,14,1,14,3,14,219,8,14,1,15,1,15,1,15,1,15,
+1,15,1,15,1,15,1,15,1,15,1,16,1,16,3,16,232,8,16,1,16,1,16,1,16,1,16,5,16,
+238,8,16,10,16,12,16,241,9,16,1,16,1,16,1,16,3,16,246,8,16,1,17,1,17,3,17,
+250,8,17,1,17,1,17,1,17,1,17,5,17,256,8,17,10,17,12,17,259,9,17,1,17,1,17,
+1,17,3,17,264,8,17,1,18,1,18,1,18,3,18,269,8,18,1,19,1,19,3,19,273,8,19,
+1,19,1,19,1,19,1,19,5,19,279,8,19,10,19,12,19,282,9,19,1,19,1,19,1,19,3,
+19,287,8,19,1,20,1,20,3,20,291,8,20,1,21,1,21,3,21,295,8,21,1,21,1,21,1,
+21,1,21,5,21,301,8,21,10,21,12,21,304,9,21,1,21,1,21,1,21,3,21,309,8,21,
+1,22,1,22,3,22,313,8,22,1,22,1,22,1,22,1,22,5,22,319,8,22,10,22,12,22,322,
+9,22,1,22,1,22,1,22,3,22,327,8,22,1,23,1,23,1,23,1,23,5,23,333,8,23,10,23,
+12,23,336,9,23,1,23,1,23,1,23,3,23,341,8,23,1,24,1,24,1,24,1,24,5,24,347,
+8,24,10,24,12,24,350,9,24,1,24,1,24,1,24,3,24,355,8,24,1,25,1,25,1,25,1,
+25,1,25,1,25,3,25,363,8,25,1,26,1,26,1,26,3,26,368,8,26,1,26,3,26,371,8,
+26,1,27,1,27,1,27,0,0,28,0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,
+36,38,40,42,44,46,48,50,52,54,0,2,1,0,25,27,2,0,1,1,28,30,412,0,59,1,0,0,
+0,2,80,1,0,0,0,4,82,1,0,0,0,6,84,1,0,0,0,8,95,1,0,0,0,10,101,1,0,0,0,12,
+107,1,0,0,0,14,113,1,0,0,0,16,119,1,0,0,0,18,137,1,0,0,0,20,155,1,0,0,0,
+22,173,1,0,0,0,24,191,1,0,0,0,26,197,1,0,0,0,28,218,1,0,0,0,30,220,1,0,0,
+0,32,229,1,0,0,0,34,247,1,0,0,0,36,268,1,0,0,0,38,270,1,0,0,0,40,290,1,0,
+0,0,42,292,1,0,0,0,44,310,1,0,0,0,46,340,1,0,0,0,48,354,1,0,0,0,50,362,1,
+0,0,0,52,364,1,0,0,0,54,372,1,0,0,0,56,58,3,2,1,0,57,56,1,0,0,0,58,61,1,
+0,0,0,59,57,1,0,0,0,59,60,1,0,0,0,60,62,1,0,0,0,61,59,1,0,0,0,62,63,5,0,
+0,1,63,1,1,0,0,0,64,81,3,6,3,0,65,81,3,8,4,0,66,81,3,10,5,0,67,81,3,12,6,
+0,68,81,3,14,7,0,69,81,3,16,8,0,70,81,3,18,9,0,71,81,3,20,10,0,72,81,3,22,
+11,0,73,81,3,24,12,0,74,81,3,26,13,0,75,81,3,32,16,0,76,81,3,34,17,0,77,
+81,3,38,19,0,78,81,3,42,21,0,79,81,3,44,22,0,80,64,1,0,0,0,80,65,1,0,0,0,
+80,66,1,0,0,0,80,67,1,0,0,0,80,68,1,0,0,0,80,69,1,0,0,0,80,70,1,0,0,0,80,
+71,1,0,0,0,80,72,1,0,0,0,80,73,1,0,0,0,80,74,1,0,0,0,80,75,1,0,0,0,80,76,
+1,0,0,0,80,77,1,0,0,0,80,78,1,0,0,0,80,79,1,0,0,0,81,3,1,0,0,0,82,83,7,0,
+0,0,83,5,1,0,0,0,84,86,5,7,0,0,85,87,3,4,2,0,86,85,1,0,0,0,86,87,1,0,0,0,
+87,93,1,0,0,0,88,89,5,5,0,0,89,90,3,52,26,0,90,91,5,6,0,0,91,94,1,0,0,0,
+92,94,5,24,0,0,93,88,1,0,0,0,93,92,1,0,0,0,94,7,1,0,0,0,95,97,5,8,0,0,96,
+98,3,4,2,0,97,96,1,0,0,0,97,98,1,0,0,0,98,99,1,0,0,0,99,100,3,48,24,0,100,
+9,1,0,0,0,101,103,5,9,0,0,102,104,3,4,2,0,103,102,1,0,0,0,103,104,1,0,0,
+0,104,105,1,0,0,0,105,106,3,48,24,0,106,11,1,0,0,0,107,109,5,10,0,0,108,
+110,3,4,2,0,109,108,1,0,0,0,109,110,1,0,0,0,110,111,1,0,0,0,111,112,3,46,
+23,0,112,13,1,0,0,0,113,115,5,11,0,0,114,116,3,4,2,0,115,114,1,0,0,0,115,
+116,1,0,0,0,116,117,1,0,0,0,117,118,3,46,23,0,118,15,1,0,0,0,119,121,5,12,
+0,0,120,122,3,4,2,0,121,120,1,0,0,0,121,122,1,0,0,0,122,135,1,0,0,0,123,
+124,5,5,0,0,124,129,3,50,25,0,125,126,5,4,0,0,126,128,3,50,25,0,127,125,
+1,0,0,0,128,131,1,0,0,0,129,127,1,0,0,0,129,130,1,0,0,0,130,132,1,0,0,0,
+131,129,1,0,0,0,132,133,5,6,0,0,133,136,1,0,0,0,134,136,5,24,0,0,135,123,
+1,0,0,0,135,134,1,0,0,0,136,17,1,0,0,0,137,139,5,13,0,0,138,140,3,4,2,0,
+139,138,1,0,0,0,139,140,1,0,0,0,140,153,1,0,0,0,141,142,5,5,0,0,142,147,
+3,48,24,0,143,144,5,4,0,0,144,146,3,48,24,0,145,143,1,0,0,0,146,149,1,0,
+0,0,147,145,1,0,0,0,147,148,1,0,0,0,148,150,1,0,0,0,149,147,1,0,0,0,150,
+151,5,6,0,0,151,154,1,0,0,0,152,154,5,24,0,0,153,141,1,0,0,0,153,152,1,0,
+0,0,154,19,1,0,0,0,155,157,5,14,0,0,156,158,3,4,2,0,157,156,1,0,0,0,157,
+158,1,0,0,0,158,171,1,0,0,0,159,160,5,5,0,0,160,165,3,46,23,0,161,162,5,
+4,0,0,162,164,3,46,23,0,163,161,1,0,0,0,164,167,1,0,0,0,165,163,1,0,0,0,
+165,166,1,0,0,0,166,168,1,0,0,0,167,165,1,0,0,0,168,169,5,6,0,0,169,172,
+1,0,0,0,170,172,5,24,0,0,171,159,1,0,0,0,171,170,1,0,0,0,172,21,1,0,0,0,
+173,175,5,15,0,0,174,176,3,4,2,0,175,174,1,0,0,0,175,176,1,0,0,0,176,189,
+1,0,0,0,177,178,5,5,0,0,178,183,3,2,1,0,179,180,5,4,0,0,180,182,3,2,1,0,
+181,179,1,0,0,0,182,185,1,0,0,0,183,181,1,0,0,0,183,184,1,0,0,0,184,186,
+1,0,0,0,185,183,1,0,0,0,186,187,5,6,0,0,187,190,1,0,0,0,188,190,5,24,0,0,
+189,177,1,0,0,0,189,188,1,0,0,0,190,23,1,0,0,0,191,193,5,16,0,0,192,194,
+3,4,2,0,193,192,1,0,0,0,193,194,1,0,0,0,194,195,1,0,0,0,195,196,3,48,24,
+0,196,25,1,0,0,0,197,199,5,17,0,0,198,200,3,4,2,0,199,198,1,0,0,0,199,200,
+1,0,0,0,200,213,1,0,0,0,201,202,5,5,0,0,202,207,3,28,14,0,203,204,5,4,0,
+0,204,206,3,28,14,0,205,203,1,0,0,0,206,209,1,0,0,0,207,205,1,0,0,0,207,
+208,1,0,0,0,208,210,1,0,0,0,209,207,1,0,0,0,210,211,5,6,0,0,211,214,1,0,
+0,0,212,214,5,24,0,0,213,201,1,0,0,0,213,212,1,0,0,0,214,27,1,0,0,0,215,
+219,3,48,24,0,216,219,3,24,12,0,217,219,3,30,15,0,218,215,1,0,0,0,218,216,
+1,0,0,0,218,217,1,0,0,0,219,29,1,0,0,0,220,221,5,18,0,0,221,222,5,5,0,0,
+222,223,3,54,27,0,223,224,5,4,0,0,224,225,3,54,27,0,225,226,5,4,0,0,226,
+227,3,54,27,0,227,228,5,6,0,0,228,31,1,0,0,0,229,231,5,19,0,0,230,232,3,
+4,2,0,231,230,1,0,0,0,231,232,1,0,0,0,232,245,1,0,0,0,233,234,5,5,0,0,234,
+239,3,36,18,0,235,236,5,4,0,0,236,238,3,36,18,0,237,235,1,0,0,0,238,241,
+1,0,0,0,239,237,1,0,0,0,239,240,1,0,0,0,240,242,1,0,0,0,241,239,1,0,0,0,
+242,243,5,6,0,0,243,246,1,0,0,0,244,246,5,24,0,0,245,233,1,0,0,0,245,244,
+1,0,0,0,246,33,1,0,0,0,247,249,5,20,0,0,248,250,3,4,2,0,249,248,1,0,0,0,
+249,250,1,0,0,0,250,263,1,0,0,0,251,252,5,5,0,0,252,257,3,36,18,0,253,254,
+5,4,0,0,254,256,3,36,18,0,255,253,1,0,0,0,256,259,1,0,0,0,257,255,1,0,0,
+0,257,258,1,0,0,0,258,260,1,0,0,0,259,257,1,0,0,0,260,261,5,6,0,0,261,264,
+1,0,0,0,262,264,5,24,0,0,263,251,1,0,0,0,263,262,1,0,0,0,264,35,1,0,0,0,
+265,269,3,48,24,0,266,269,3,24,12,0,267,269,3,26,13,0,268,265,1,0,0,0,268,
+266,1,0,0,0,268,267,1,0,0,0,269,37,1,0,0,0,270,272,5,21,0,0,271,273,3,4,
+2,0,272,271,1,0,0,0,272,273,1,0,0,0,273,286,1,0,0,0,274,275,5,5,0,0,275,
+280,3,40,20,0,276,277,5,4,0,0,277,279,3,40,20,0,278,276,1,0,0,0,279,282,
+1,0,0,0,280,278,1,0,0,0,280,281,1,0,0,0,281,283,1,0,0,0,282,280,1,0,0,0,
+283,284,5,6,0,0,284,287,1,0,0,0,285,287,5,24,0,0,286,274,1,0,0,0,286,285,
+1,0,0,0,287,39,1,0,0,0,288,291,3,46,23,0,289,291,3,32,16,0,290,288,1,0,0,
+0,290,289,1,0,0,0,291,41,1,0,0,0,292,294,5,22,0,0,293,295,3,4,2,0,294,293,
+1,0,0,0,294,295,1,0,0,0,295,308,1,0,0,0,296,297,5,5,0,0,297,302,3,46,23,
+0,298,299,5,4,0,0,299,301,3,46,23,0,300,298,1,0,0,0,301,304,1,0,0,0,302,
+300,1,0,0,0,302,303,1,0,0,0,303,305,1,0,0,0,304,302,1,0,0,0,305,306,5,6,
+0,0,306,309,1,0,0,0,307,309,5,24,0,0,308,296,1,0,0,0,308,307,1,0,0,0,309,
+43,1,0,0,0,310,312,5,23,0,0,311,313,3,4,2,0,312,311,1,0,0,0,312,313,1,0,
+0,0,313,326,1,0,0,0,314,315,5,5,0,0,315,320,3,46,23,0,316,317,5,4,0,0,317,
+319,3,46,23,0,318,316,1,0,0,0,319,322,1,0,0,0,320,318,1,0,0,0,320,321,1,
+0,0,0,321,323,1,0,0,0,322,320,1,0,0,0,323,324,5,6,0,0,324,327,1,0,0,0,325,
+327,5,24,0,0,326,314,1,0,0,0,326,325,1,0,0,0,327,45,1,0,0,0,328,329,5,5,
+0,0,329,334,3,48,24,0,330,331,5,4,0,0,331,333,3,48,24,0,332,330,1,0,0,0,
+333,336,1,0,0,0,334,332,1,0,0,0,334,335,1,0,0,0,335,337,1,0,0,0,336,334,
+1,0,0,0,337,338,5,6,0,0,338,341,1,0,0,0,339,341,5,24,0,0,340,328,1,0,0,0,
+340,339,1,0,0,0,341,47,1,0,0,0,342,343,5,5,0,0,343,348,3,52,26,0,344,345,
+5,4,0,0,345,347,3,52,26,0,346,344,1,0,0,0,347,350,1,0,0,0,348,346,1,0,0,
+0,348,349,1,0,0,0,349,351,1,0,0,0,350,348,1,0,0,0,351,352,5,6,0,0,352,355,
+1,0,0,0,353,355,5,24,0,0,354,342,1,0,0,0,354,353,1,0,0,0,355,49,1,0,0,0,
+356,363,3,52,26,0,357,358,5,5,0,0,358,359,3,52,26,0,359,360,5,6,0,0,360,
+363,1,0,0,0,361,363,5,24,0,0,362,356,1,0,0,0,362,357,1,0,0,0,362,361,1,0,
+0,0,363,51,1,0,0,0,364,365,3,54,27,0,365,367,3,54,27,0,366,368,3,54,27,0,
+367,366,1,0,0,0,367,368,1,0,0,0,368,370,1,0,0,0,369,371,3,54,27,0,370,369,
+1,0,0,0,370,371,1,0,0,0,371,53,1,0,0,0,372,373,7,1,0,0,373,55,1,0,0,0,49,
+59,80,86,93,97,103,109,115,121,129,135,139,147,153,157,165,171,175,183,189,
+193,199,207,213,218,231,239,245,249,257,263,268,272,280,286,290,294,302,
+308,312,320,326,334,340,348,354,362,367,370];
 
 
 const atn = new antlr4.atn.ATNDeserializer().deserialize(serializedATN);
@@ -121,19 +141,22 @@ export default class wktParser extends antlr4.Parser {
     static literalNames = [ null, null, null, null, "','", "'('", "')'" ];
     static symbolicNames = [ null, "DECIMAL", "INTEGERPART", "DECIMALPART", 
                              "COMMA", "LPAR", "RPAR", "POINT", "LINESTRING", 
-                             "POLYGON", "MULTIPOINT", "MULTILINESTRING", 
-                             "MULTIPOLYGON", "GEOMETRYCOLLECTION", "EMPTY_", 
-                             "CIRCULARSTRING", "COMPOUNDCURVE", "MULTISURFACE", 
-                             "CURVEPOLYGON", "MULTICURVE", "TRIANGLE", "TIN", 
-                             "POLYHEDRALSURFACE", "STRING", "WS" ];
-    static ruleNames = [ "file_", "geometryCollection", "geometry", "pointGeometry", 
-                         "lineStringGeometry", "polygonGeometry", "multiCurveGeometry", 
-                         "multiSurfaceGeometry", "curvePolygonGeometry", 
-                         "compoundCurveGeometry", "multiPointGeometry", 
-                         "multiLineStringGeometry", "multiPolygonGeometry", 
-                         "multiPolyhedralSurfaceGeometry", "multiTinGeometry", 
-                         "circularStringGeometry", "pointOrClosedPoint", 
-                         "polygon", "lineString", "point", "name" ];
+                             "LINEARRING", "POLYGON", "TRIANGLE", "MULTIPOINT", 
+                             "MULTILINESTRING", "MULTIPOLYGON", "GEOMETRYCOLLECTION", 
+                             "CIRCULARSTRING", "COMPOUNDCURVE", "CLOTHOID", 
+                             "CURVEPOLYGON", "MULTICURVE", "MULTISURFACE", 
+                             "POLYHEDRALSURFACE", "TIN", "EMPTY_", "ZM_", 
+                             "Z_", "M_", "NAN_", "NEG_INF_", "INF_", "WS" ];
+    static ruleNames = [ "file_", "geometry", "dim", "pointGeometry", "lineStringGeometry", 
+                         "linearRingGeometry", "polygonGeometry", "triangleGeometry", 
+                         "multiPointGeometry", "multiLineStringGeometry", 
+                         "multiPolygonGeometry", "geometryCollection", "circularStringGeometry", 
+                         "compoundCurveGeometry", "compoundCurveMember", 
+                         "clothoidGeometry", "curvePolygonGeometry", "multiCurveGeometry", 
+                         "curveMember", "multiSurfaceGeometry", "surfaceMember", 
+                         "polyhedralSurfaceGeometry", "tinGeometry", "polygonText", 
+                         "lineStringText", "pointOrClosedPoint", "point", 
+                         "ordinate" ];
 
     constructor(input) {
         super(input);
@@ -151,17 +174,17 @@ export default class wktParser extends antlr4.Parser {
 	    var _la = 0;
 	    try {
 	        this.enterOuterAlt(localctx, 1);
-	        this.state = 45;
+	        this.state = 59;
 	        this._errHandler.sync(this);
 	        _la = this._input.LA(1);
-	        while((((_la) & ~0x1f) === 0 && ((1 << _la) & 7323520) !== 0)) {
-	            this.state = 42;
+	        while((((_la) & ~0x1f) === 0 && ((1 << _la) & 16514944) !== 0)) {
+	            this.state = 56;
 	            this.geometry();
-	            this.state = 47;
+	            this.state = 61;
 	            this._errHandler.sync(this);
 	            _la = this._input.LA(1);
 	        }
-	        this.state = 48;
+	        this.state = 62;
 	        this.match(wktParser.EOF);
 	    } catch (re) {
 	    	if(re instanceof antlr4.error.RecognitionException) {
@@ -179,123 +202,92 @@ export default class wktParser extends antlr4.Parser {
 
 
 
-	geometryCollection() {
-	    let localctx = new GeometryCollectionContext(this, this._ctx, this.state);
-	    this.enterRule(localctx, 2, wktParser.RULE_geometryCollection);
-	    var _la = 0;
-	    try {
-	        this.enterOuterAlt(localctx, 1);
-	        this.state = 50;
-	        this.match(wktParser.GEOMETRYCOLLECTION);
-	        this.state = 63;
-	        this._errHandler.sync(this);
-	        switch(this._input.LA(1)) {
-	        case 5:
-	            this.state = 51;
-	            this.match(wktParser.LPAR);
-	            this.state = 52;
-	            this.geometry();
-	            this.state = 57;
-	            this._errHandler.sync(this);
-	            _la = this._input.LA(1);
-	            while(_la===4) {
-	                this.state = 53;
-	                this.match(wktParser.COMMA);
-	                this.state = 54;
-	                this.geometry();
-	                this.state = 59;
-	                this._errHandler.sync(this);
-	                _la = this._input.LA(1);
-	            }
-	            this.state = 60;
-	            this.match(wktParser.RPAR);
-	            break;
-	        case 14:
-	            this.state = 62;
-	            this.match(wktParser.EMPTY_);
-	            break;
-	        default:
-	            throw new antlr4.error.NoViableAltException(this);
-	        }
-	    } catch (re) {
-	    	if(re instanceof antlr4.error.RecognitionException) {
-		        localctx.exception = re;
-		        this._errHandler.reportError(this, re);
-		        this._errHandler.recover(this, re);
-		    } else {
-		    	throw re;
-		    }
-	    } finally {
-	        this.exitRule();
-	    }
-	    return localctx;
-	}
-
-
-
 	geometry() {
 	    let localctx = new GeometryContext(this, this._ctx, this.state);
-	    this.enterRule(localctx, 4, wktParser.RULE_geometry);
+	    this.enterRule(localctx, 2, wktParser.RULE_geometry);
 	    try {
-	        this.enterOuterAlt(localctx, 1);
-	        this.state = 79;
+	        this.state = 80;
 	        this._errHandler.sync(this);
 	        switch(this._input.LA(1)) {
-	        case 9:
-	            this.state = 65;
-	            this.polygonGeometry();
+	        case 7:
+	            this.enterOuterAlt(localctx, 1);
+	            this.state = 64;
+	            this.pointGeometry();
 	            break;
 	        case 8:
-	            this.state = 66;
+	            this.enterOuterAlt(localctx, 2);
+	            this.state = 65;
 	            this.lineStringGeometry();
 	            break;
-	        case 7:
+	        case 9:
+	            this.enterOuterAlt(localctx, 3);
+	            this.state = 66;
+	            this.linearRingGeometry();
+	            break;
+	        case 10:
+	            this.enterOuterAlt(localctx, 4);
 	            this.state = 67;
-	            this.pointGeometry();
+	            this.polygonGeometry();
 	            break;
-	        case 16:
+	        case 11:
+	            this.enterOuterAlt(localctx, 5);
 	            this.state = 68;
-	            this.compoundCurveGeometry();
+	            this.triangleGeometry();
 	            break;
-	        case 18:
+	        case 12:
+	            this.enterOuterAlt(localctx, 6);
 	            this.state = 69;
-	            this.curvePolygonGeometry();
+	            this.multiPointGeometry();
 	            break;
-	        case 17:
+	        case 13:
+	            this.enterOuterAlt(localctx, 7);
 	            this.state = 70;
-	            this.multiSurfaceGeometry();
+	            this.multiLineStringGeometry();
 	            break;
-	        case 19:
+	        case 14:
+	            this.enterOuterAlt(localctx, 8);
 	            this.state = 71;
-	            this.multiCurveGeometry();
+	            this.multiPolygonGeometry();
 	            break;
-	        case 10:
+	        case 15:
+	            this.enterOuterAlt(localctx, 9);
 	            this.state = 72;
-	            this.multiPointGeometry();
+	            this.geometryCollection();
 	            break;
-	        case 11:
+	        case 16:
+	            this.enterOuterAlt(localctx, 10);
 	            this.state = 73;
-	            this.multiLineStringGeometry();
+	            this.circularStringGeometry();
 	            break;
-	        case 12:
+	        case 17:
+	            this.enterOuterAlt(localctx, 11);
 	            this.state = 74;
-	            this.multiPolygonGeometry();
+	            this.compoundCurveGeometry();
 	            break;
-	        case 15:
+	        case 19:
+	            this.enterOuterAlt(localctx, 12);
 	            this.state = 75;
-	            this.circularStringGeometry();
+	            this.curvePolygonGeometry();
 	            break;
-	        case 22:
+	        case 20:
+	            this.enterOuterAlt(localctx, 13);
 	            this.state = 76;
-	            this.multiPolyhedralSurfaceGeometry();
+	            this.multiCurveGeometry();
 	            break;
 	        case 21:
+	            this.enterOuterAlt(localctx, 14);
 	            this.state = 77;
-	            this.multiTinGeometry();
+	            this.multiSurfaceGeometry();
 	            break;
-	        case 13:
+	        case 22:
+	            this.enterOuterAlt(localctx, 15);
 	            this.state = 78;
-	            this.geometryCollection();
+	            this.polyhedralSurfaceGeometry();
+	            break;
+	        case 23:
+	            this.enterOuterAlt(localctx, 16);
+	            this.state = 79;
+	            this.tinGeometry();
 	            break;
 	        default:
 	            throw new antlr4.error.NoViableAltException(this);
@@ -316,36 +308,66 @@ export default class wktParser extends antlr4.Parser {
 
 
 
+	dim() {
+	    let localctx = new DimContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 4, wktParser.RULE_dim);
+	    var _la = 0;
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 82;
+	        _la = this._input.LA(1);
+	        if(!((((_la) & ~0x1f) === 0 && ((1 << _la) & 234881024) !== 0))) {
+	        this._errHandler.recoverInline(this);
+	        }
+	        else {
+	        	this._errHandler.reportMatch(this);
+	            this.consume();
+	        }
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
 	pointGeometry() {
 	    let localctx = new PointGeometryContext(this, this._ctx, this.state);
 	    this.enterRule(localctx, 6, wktParser.RULE_pointGeometry);
 	    var _la = 0;
 	    try {
 	        this.enterOuterAlt(localctx, 1);
-	        this.state = 81;
+	        this.state = 84;
 	        this.match(wktParser.POINT);
-	        this.state = 90;
+	        this.state = 86;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        if((((_la) & ~0x1f) === 0 && ((1 << _la) & 234881024) !== 0)) {
+	            this.state = 85;
+	            this.dim();
+	        }
+
+	        this.state = 93;
 	        this._errHandler.sync(this);
 	        switch(this._input.LA(1)) {
 	        case 5:
-	        case 23:
-	            this.state = 83;
-	            this._errHandler.sync(this);
-	            _la = this._input.LA(1);
-	            if(_la===23) {
-	                this.state = 82;
-	                this.name();
-	            }
-
-	            this.state = 85;
+	            this.state = 88;
 	            this.match(wktParser.LPAR);
-	            this.state = 86;
+	            this.state = 89;
 	            this.point();
-	            this.state = 87;
+	            this.state = 90;
 	            this.match(wktParser.RPAR);
 	            break;
-	        case 14:
-	            this.state = 89;
+	        case 24:
+	            this.state = 92;
 	            this.match(wktParser.EMPTY_);
 	            break;
 	        default:
@@ -370,12 +392,55 @@ export default class wktParser extends antlr4.Parser {
 	lineStringGeometry() {
 	    let localctx = new LineStringGeometryContext(this, this._ctx, this.state);
 	    this.enterRule(localctx, 8, wktParser.RULE_lineStringGeometry);
+	    var _la = 0;
 	    try {
 	        this.enterOuterAlt(localctx, 1);
-	        this.state = 92;
+	        this.state = 95;
 	        this.match(wktParser.LINESTRING);
-	        this.state = 93;
-	        this.lineString();
+	        this.state = 97;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        if((((_la) & ~0x1f) === 0 && ((1 << _la) & 234881024) !== 0)) {
+	            this.state = 96;
+	            this.dim();
+	        }
+
+	        this.state = 99;
+	        this.lineStringText();
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	linearRingGeometry() {
+	    let localctx = new LinearRingGeometryContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 10, wktParser.RULE_linearRingGeometry);
+	    var _la = 0;
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 101;
+	        this.match(wktParser.LINEARRING);
+	        this.state = 103;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        if((((_la) & ~0x1f) === 0 && ((1 << _la) & 234881024) !== 0)) {
+	            this.state = 102;
+	            this.dim();
+	        }
+
+	        this.state = 105;
+	        this.lineStringText();
 	    } catch (re) {
 	    	if(re instanceof antlr4.error.RecognitionException) {
 		        localctx.exception = re;
@@ -394,13 +459,22 @@ export default class wktParser extends antlr4.Parser {
 
 	polygonGeometry() {
 	    let localctx = new PolygonGeometryContext(this, this._ctx, this.state);
-	    this.enterRule(localctx, 10, wktParser.RULE_polygonGeometry);
+	    this.enterRule(localctx, 12, wktParser.RULE_polygonGeometry);
+	    var _la = 0;
 	    try {
 	        this.enterOuterAlt(localctx, 1);
-	        this.state = 95;
+	        this.state = 107;
 	        this.match(wktParser.POLYGON);
-	        this.state = 96;
-	        this.polygon();
+	        this.state = 109;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        if((((_la) & ~0x1f) === 0 && ((1 << _la) & 234881024) !== 0)) {
+	            this.state = 108;
+	            this.dim();
+	        }
+
+	        this.state = 111;
+	        this.polygonText();
 	    } catch (re) {
 	    	if(re instanceof antlr4.error.RecognitionException) {
 		        localctx.exception = re;
@@ -417,78 +491,24 @@ export default class wktParser extends antlr4.Parser {
 
 
 
-	multiCurveGeometry() {
-	    let localctx = new MultiCurveGeometryContext(this, this._ctx, this.state);
-	    this.enterRule(localctx, 12, wktParser.RULE_multiCurveGeometry);
+	triangleGeometry() {
+	    let localctx = new TriangleGeometryContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 14, wktParser.RULE_triangleGeometry);
 	    var _la = 0;
 	    try {
 	        this.enterOuterAlt(localctx, 1);
-	        this.state = 98;
-	        this.match(wktParser.MULTICURVE);
-	        this.state = 119;
+	        this.state = 113;
+	        this.match(wktParser.TRIANGLE);
+	        this.state = 115;
 	        this._errHandler.sync(this);
-	        switch(this._input.LA(1)) {
-	        case 5:
-	            this.state = 99;
-	            this.match(wktParser.LPAR);
-	            this.state = 103;
-	            this._errHandler.sync(this);
-	            switch(this._input.LA(1)) {
-	            case 5:
-	            case 14:
-	                this.state = 100;
-	                this.lineString();
-	                break;
-	            case 15:
-	                this.state = 101;
-	                this.circularStringGeometry();
-	                break;
-	            case 16:
-	                this.state = 102;
-	                this.compoundCurveGeometry();
-	                break;
-	            default:
-	                throw new antlr4.error.NoViableAltException(this);
-	            }
-	            this.state = 113;
-	            this._errHandler.sync(this);
-	            _la = this._input.LA(1);
-	            while(_la===4) {
-	                this.state = 105;
-	                this.match(wktParser.COMMA);
-	                this.state = 109;
-	                this._errHandler.sync(this);
-	                switch(this._input.LA(1)) {
-	                case 15:
-	                    this.state = 106;
-	                    this.circularStringGeometry();
-	                    break;
-	                case 5:
-	                case 14:
-	                    this.state = 107;
-	                    this.lineString();
-	                    break;
-	                case 16:
-	                    this.state = 108;
-	                    this.compoundCurveGeometry();
-	                    break;
-	                default:
-	                    throw new antlr4.error.NoViableAltException(this);
-	                }
-	                this.state = 115;
-	                this._errHandler.sync(this);
-	                _la = this._input.LA(1);
-	            }
-	            this.state = 116;
-	            this.match(wktParser.RPAR);
-	            break;
-	        case 14:
-	            this.state = 118;
-	            this.match(wktParser.EMPTY_);
-	            break;
-	        default:
-	            throw new antlr4.error.NoViableAltException(this);
+	        _la = this._input.LA(1);
+	        if((((_la) & ~0x1f) === 0 && ((1 << _la) & 234881024) !== 0)) {
+	            this.state = 114;
+	            this.dim();
 	        }
+
+	        this.state = 117;
+	        this.polygonText();
 	    } catch (re) {
 	    	if(re instanceof antlr4.error.RecognitionException) {
 		        localctx.exception = re;
@@ -505,65 +525,47 @@ export default class wktParser extends antlr4.Parser {
 
 
 
-	multiSurfaceGeometry() {
-	    let localctx = new MultiSurfaceGeometryContext(this, this._ctx, this.state);
-	    this.enterRule(localctx, 14, wktParser.RULE_multiSurfaceGeometry);
+	multiPointGeometry() {
+	    let localctx = new MultiPointGeometryContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 16, wktParser.RULE_multiPointGeometry);
 	    var _la = 0;
 	    try {
 	        this.enterOuterAlt(localctx, 1);
+	        this.state = 119;
+	        this.match(wktParser.MULTIPOINT);
 	        this.state = 121;
-	        this.match(wktParser.MULTISURFACE);
-	        this.state = 140;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        if((((_la) & ~0x1f) === 0 && ((1 << _la) & 234881024) !== 0)) {
+	            this.state = 120;
+	            this.dim();
+	        }
+
+	        this.state = 135;
 	        this._errHandler.sync(this);
 	        switch(this._input.LA(1)) {
 	        case 5:
-	            this.state = 122;
+	            this.state = 123;
 	            this.match(wktParser.LPAR);
-	            this.state = 125;
-	            this._errHandler.sync(this);
-	            switch(this._input.LA(1)) {
-	            case 5:
-	            case 14:
-	                this.state = 123;
-	                this.polygon();
-	                break;
-	            case 18:
-	                this.state = 124;
-	                this.curvePolygonGeometry();
-	                break;
-	            default:
-	                throw new antlr4.error.NoViableAltException(this);
-	            }
-	            this.state = 134;
+	            this.state = 124;
+	            this.pointOrClosedPoint();
+	            this.state = 129;
 	            this._errHandler.sync(this);
 	            _la = this._input.LA(1);
 	            while(_la===4) {
-	                this.state = 127;
+	                this.state = 125;
 	                this.match(wktParser.COMMA);
-	                this.state = 130;
-	                this._errHandler.sync(this);
-	                switch(this._input.LA(1)) {
-	                case 5:
-	                case 14:
-	                    this.state = 128;
-	                    this.polygon();
-	                    break;
-	                case 18:
-	                    this.state = 129;
-	                    this.curvePolygonGeometry();
-	                    break;
-	                default:
-	                    throw new antlr4.error.NoViableAltException(this);
-	                }
-	                this.state = 136;
+	                this.state = 126;
+	                this.pointOrClosedPoint();
+	                this.state = 131;
 	                this._errHandler.sync(this);
 	                _la = this._input.LA(1);
 	            }
-	            this.state = 137;
+	            this.state = 132;
 	            this.match(wktParser.RPAR);
 	            break;
-	        case 14:
-	            this.state = 139;
+	        case 24:
+	            this.state = 134;
 	            this.match(wktParser.EMPTY_);
 	            break;
 	        default:
@@ -585,73 +587,47 @@ export default class wktParser extends antlr4.Parser {
 
 
 
-	curvePolygonGeometry() {
-	    let localctx = new CurvePolygonGeometryContext(this, this._ctx, this.state);
-	    this.enterRule(localctx, 16, wktParser.RULE_curvePolygonGeometry);
+	multiLineStringGeometry() {
+	    let localctx = new MultiLineStringGeometryContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 18, wktParser.RULE_multiLineStringGeometry);
 	    var _la = 0;
 	    try {
 	        this.enterOuterAlt(localctx, 1);
-	        this.state = 142;
-	        this.match(wktParser.CURVEPOLYGON);
-	        this.state = 163;
+	        this.state = 137;
+	        this.match(wktParser.MULTILINESTRING);
+	        this.state = 139;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        if((((_la) & ~0x1f) === 0 && ((1 << _la) & 234881024) !== 0)) {
+	            this.state = 138;
+	            this.dim();
+	        }
+
+	        this.state = 153;
 	        this._errHandler.sync(this);
 	        switch(this._input.LA(1)) {
 	        case 5:
-	            this.state = 143;
+	            this.state = 141;
 	            this.match(wktParser.LPAR);
+	            this.state = 142;
+	            this.lineStringText();
 	            this.state = 147;
 	            this._errHandler.sync(this);
-	            switch(this._input.LA(1)) {
-	            case 5:
-	            case 14:
-	                this.state = 144;
-	                this.lineString();
-	                break;
-	            case 15:
-	                this.state = 145;
-	                this.circularStringGeometry();
-	                break;
-	            case 16:
-	                this.state = 146;
-	                this.compoundCurveGeometry();
-	                break;
-	            default:
-	                throw new antlr4.error.NoViableAltException(this);
-	            }
-	            this.state = 157;
-	            this._errHandler.sync(this);
 	            _la = this._input.LA(1);
 	            while(_la===4) {
-	                this.state = 149;
+	                this.state = 143;
 	                this.match(wktParser.COMMA);
-	                this.state = 153;
-	                this._errHandler.sync(this);
-	                switch(this._input.LA(1)) {
-	                case 15:
-	                    this.state = 150;
-	                    this.circularStringGeometry();
-	                    break;
-	                case 5:
-	                case 14:
-	                    this.state = 151;
-	                    this.lineString();
-	                    break;
-	                case 16:
-	                    this.state = 152;
-	                    this.compoundCurveGeometry();
-	                    break;
-	                default:
-	                    throw new antlr4.error.NoViableAltException(this);
-	                }
-	                this.state = 159;
+	                this.state = 144;
+	                this.lineStringText();
+	                this.state = 149;
 	                this._errHandler.sync(this);
 	                _la = this._input.LA(1);
 	            }
-	            this.state = 160;
+	            this.state = 150;
 	            this.match(wktParser.RPAR);
 	            break;
-	        case 14:
-	            this.state = 162;
+	        case 24:
+	            this.state = 152;
 	            this.match(wktParser.EMPTY_);
 	            break;
 	        default:
@@ -673,65 +649,47 @@ export default class wktParser extends antlr4.Parser {
 
 
 
-	compoundCurveGeometry() {
-	    let localctx = new CompoundCurveGeometryContext(this, this._ctx, this.state);
-	    this.enterRule(localctx, 18, wktParser.RULE_compoundCurveGeometry);
+	multiPolygonGeometry() {
+	    let localctx = new MultiPolygonGeometryContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 20, wktParser.RULE_multiPolygonGeometry);
 	    var _la = 0;
 	    try {
 	        this.enterOuterAlt(localctx, 1);
-	        this.state = 165;
-	        this.match(wktParser.COMPOUNDCURVE);
-	        this.state = 184;
+	        this.state = 155;
+	        this.match(wktParser.MULTIPOLYGON);
+	        this.state = 157;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        if((((_la) & ~0x1f) === 0 && ((1 << _la) & 234881024) !== 0)) {
+	            this.state = 156;
+	            this.dim();
+	        }
+
+	        this.state = 171;
 	        this._errHandler.sync(this);
 	        switch(this._input.LA(1)) {
 	        case 5:
-	            this.state = 166;
+	            this.state = 159;
 	            this.match(wktParser.LPAR);
-	            this.state = 169;
-	            this._errHandler.sync(this);
-	            switch(this._input.LA(1)) {
-	            case 5:
-	            case 14:
-	                this.state = 167;
-	                this.lineString();
-	                break;
-	            case 15:
-	                this.state = 168;
-	                this.circularStringGeometry();
-	                break;
-	            default:
-	                throw new antlr4.error.NoViableAltException(this);
-	            }
-	            this.state = 178;
+	            this.state = 160;
+	            this.polygonText();
+	            this.state = 165;
 	            this._errHandler.sync(this);
 	            _la = this._input.LA(1);
 	            while(_la===4) {
-	                this.state = 171;
+	                this.state = 161;
 	                this.match(wktParser.COMMA);
-	                this.state = 174;
-	                this._errHandler.sync(this);
-	                switch(this._input.LA(1)) {
-	                case 15:
-	                    this.state = 172;
-	                    this.circularStringGeometry();
-	                    break;
-	                case 5:
-	                case 14:
-	                    this.state = 173;
-	                    this.lineString();
-	                    break;
-	                default:
-	                    throw new antlr4.error.NoViableAltException(this);
-	                }
-	                this.state = 180;
+	                this.state = 162;
+	                this.polygonText();
+	                this.state = 167;
 	                this._errHandler.sync(this);
 	                _la = this._input.LA(1);
 	            }
-	            this.state = 181;
+	            this.state = 168;
 	            this.match(wktParser.RPAR);
 	            break;
-	        case 14:
-	            this.state = 183;
+	        case 24:
+	            this.state = 170;
 	            this.match(wktParser.EMPTY_);
 	            break;
 	        default:
@@ -753,39 +711,47 @@ export default class wktParser extends antlr4.Parser {
 
 
 
-	multiPointGeometry() {
-	    let localctx = new MultiPointGeometryContext(this, this._ctx, this.state);
-	    this.enterRule(localctx, 20, wktParser.RULE_multiPointGeometry);
+	geometryCollection() {
+	    let localctx = new GeometryCollectionContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 22, wktParser.RULE_geometryCollection);
 	    var _la = 0;
 	    try {
 	        this.enterOuterAlt(localctx, 1);
-	        this.state = 186;
-	        this.match(wktParser.MULTIPOINT);
-	        this.state = 199;
+	        this.state = 173;
+	        this.match(wktParser.GEOMETRYCOLLECTION);
+	        this.state = 175;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        if((((_la) & ~0x1f) === 0 && ((1 << _la) & 234881024) !== 0)) {
+	            this.state = 174;
+	            this.dim();
+	        }
+
+	        this.state = 189;
 	        this._errHandler.sync(this);
 	        switch(this._input.LA(1)) {
 	        case 5:
-	            this.state = 187;
+	            this.state = 177;
 	            this.match(wktParser.LPAR);
-	            this.state = 188;
-	            this.pointOrClosedPoint();
-	            this.state = 193;
+	            this.state = 178;
+	            this.geometry();
+	            this.state = 183;
 	            this._errHandler.sync(this);
 	            _la = this._input.LA(1);
 	            while(_la===4) {
-	                this.state = 189;
+	                this.state = 179;
 	                this.match(wktParser.COMMA);
-	                this.state = 190;
-	                this.pointOrClosedPoint();
-	                this.state = 195;
+	                this.state = 180;
+	                this.geometry();
+	                this.state = 185;
 	                this._errHandler.sync(this);
 	                _la = this._input.LA(1);
 	            }
-	            this.state = 196;
+	            this.state = 186;
 	            this.match(wktParser.RPAR);
 	            break;
-	        case 14:
-	            this.state = 198;
+	        case 24:
+	            this.state = 188;
 	            this.match(wktParser.EMPTY_);
 	            break;
 	        default:
@@ -807,39 +773,81 @@ export default class wktParser extends antlr4.Parser {
 
 
 
-	multiLineStringGeometry() {
-	    let localctx = new MultiLineStringGeometryContext(this, this._ctx, this.state);
-	    this.enterRule(localctx, 22, wktParser.RULE_multiLineStringGeometry);
+	circularStringGeometry() {
+	    let localctx = new CircularStringGeometryContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 24, wktParser.RULE_circularStringGeometry);
 	    var _la = 0;
 	    try {
 	        this.enterOuterAlt(localctx, 1);
-	        this.state = 201;
-	        this.match(wktParser.MULTILINESTRING);
-	        this.state = 214;
+	        this.state = 191;
+	        this.match(wktParser.CIRCULARSTRING);
+	        this.state = 193;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        if((((_la) & ~0x1f) === 0 && ((1 << _la) & 234881024) !== 0)) {
+	            this.state = 192;
+	            this.dim();
+	        }
+
+	        this.state = 195;
+	        this.lineStringText();
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	compoundCurveGeometry() {
+	    let localctx = new CompoundCurveGeometryContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 26, wktParser.RULE_compoundCurveGeometry);
+	    var _la = 0;
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 197;
+	        this.match(wktParser.COMPOUNDCURVE);
+	        this.state = 199;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        if((((_la) & ~0x1f) === 0 && ((1 << _la) & 234881024) !== 0)) {
+	            this.state = 198;
+	            this.dim();
+	        }
+
+	        this.state = 213;
 	        this._errHandler.sync(this);
 	        switch(this._input.LA(1)) {
 	        case 5:
-	            this.state = 202;
+	            this.state = 201;
 	            this.match(wktParser.LPAR);
-	            this.state = 203;
-	            this.lineString();
-	            this.state = 208;
+	            this.state = 202;
+	            this.compoundCurveMember();
+	            this.state = 207;
 	            this._errHandler.sync(this);
 	            _la = this._input.LA(1);
 	            while(_la===4) {
-	                this.state = 204;
+	                this.state = 203;
 	                this.match(wktParser.COMMA);
-	                this.state = 205;
-	                this.lineString();
-	                this.state = 210;
+	                this.state = 204;
+	                this.compoundCurveMember();
+	                this.state = 209;
 	                this._errHandler.sync(this);
 	                _la = this._input.LA(1);
 	            }
-	            this.state = 211;
+	            this.state = 210;
 	            this.match(wktParser.RPAR);
 	            break;
-	        case 14:
-	            this.state = 213;
+	        case 24:
+	            this.state = 212;
 	            this.match(wktParser.EMPTY_);
 	            break;
 	        default:
@@ -861,40 +869,28 @@ export default class wktParser extends antlr4.Parser {
 
 
 
-	multiPolygonGeometry() {
-	    let localctx = new MultiPolygonGeometryContext(this, this._ctx, this.state);
-	    this.enterRule(localctx, 24, wktParser.RULE_multiPolygonGeometry);
-	    var _la = 0;
+	compoundCurveMember() {
+	    let localctx = new CompoundCurveMemberContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 28, wktParser.RULE_compoundCurveMember);
 	    try {
-	        this.enterOuterAlt(localctx, 1);
-	        this.state = 216;
-	        this.match(wktParser.MULTIPOLYGON);
-	        this.state = 229;
+	        this.state = 218;
 	        this._errHandler.sync(this);
 	        switch(this._input.LA(1)) {
 	        case 5:
-	            this.state = 217;
-	            this.match(wktParser.LPAR);
-	            this.state = 218;
-	            this.polygon();
-	            this.state = 223;
-	            this._errHandler.sync(this);
-	            _la = this._input.LA(1);
-	            while(_la===4) {
-	                this.state = 219;
-	                this.match(wktParser.COMMA);
-	                this.state = 220;
-	                this.polygon();
-	                this.state = 225;
-	                this._errHandler.sync(this);
-	                _la = this._input.LA(1);
-	            }
-	            this.state = 226;
-	            this.match(wktParser.RPAR);
+	        case 24:
+	            this.enterOuterAlt(localctx, 1);
+	            this.state = 215;
+	            this.lineStringText();
 	            break;
-	        case 14:
-	            this.state = 228;
-	            this.match(wktParser.EMPTY_);
+	        case 16:
+	            this.enterOuterAlt(localctx, 2);
+	            this.state = 216;
+	            this.circularStringGeometry();
+	            break;
+	        case 18:
+	            this.enterOuterAlt(localctx, 3);
+	            this.state = 217;
+	            this.clothoidGeometry();
 	            break;
 	        default:
 	            throw new antlr4.error.NoViableAltException(this);
@@ -915,39 +911,84 @@ export default class wktParser extends antlr4.Parser {
 
 
 
-	multiPolyhedralSurfaceGeometry() {
-	    let localctx = new MultiPolyhedralSurfaceGeometryContext(this, this._ctx, this.state);
-	    this.enterRule(localctx, 26, wktParser.RULE_multiPolyhedralSurfaceGeometry);
+	clothoidGeometry() {
+	    let localctx = new ClothoidGeometryContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 30, wktParser.RULE_clothoidGeometry);
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 220;
+	        this.match(wktParser.CLOTHOID);
+	        this.state = 221;
+	        this.match(wktParser.LPAR);
+	        this.state = 222;
+	        this.ordinate();
+	        this.state = 223;
+	        this.match(wktParser.COMMA);
+	        this.state = 224;
+	        this.ordinate();
+	        this.state = 225;
+	        this.match(wktParser.COMMA);
+	        this.state = 226;
+	        this.ordinate();
+	        this.state = 227;
+	        this.match(wktParser.RPAR);
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	curvePolygonGeometry() {
+	    let localctx = new CurvePolygonGeometryContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 32, wktParser.RULE_curvePolygonGeometry);
 	    var _la = 0;
 	    try {
 	        this.enterOuterAlt(localctx, 1);
+	        this.state = 229;
+	        this.match(wktParser.CURVEPOLYGON);
 	        this.state = 231;
-	        this.match(wktParser.POLYHEDRALSURFACE);
-	        this.state = 244;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        if((((_la) & ~0x1f) === 0 && ((1 << _la) & 234881024) !== 0)) {
+	            this.state = 230;
+	            this.dim();
+	        }
+
+	        this.state = 245;
 	        this._errHandler.sync(this);
 	        switch(this._input.LA(1)) {
 	        case 5:
-	            this.state = 232;
-	            this.match(wktParser.LPAR);
 	            this.state = 233;
-	            this.polygon();
-	            this.state = 238;
+	            this.match(wktParser.LPAR);
+	            this.state = 234;
+	            this.curveMember();
+	            this.state = 239;
 	            this._errHandler.sync(this);
 	            _la = this._input.LA(1);
 	            while(_la===4) {
-	                this.state = 234;
-	                this.match(wktParser.COMMA);
 	                this.state = 235;
-	                this.polygon();
-	                this.state = 240;
+	                this.match(wktParser.COMMA);
+	                this.state = 236;
+	                this.curveMember();
+	                this.state = 241;
 	                this._errHandler.sync(this);
 	                _la = this._input.LA(1);
 	            }
-	            this.state = 241;
+	            this.state = 242;
 	            this.match(wktParser.RPAR);
 	            break;
-	        case 14:
-	            this.state = 243;
+	        case 24:
+	            this.state = 244;
 	            this.match(wktParser.EMPTY_);
 	            break;
 	        default:
@@ -969,39 +1010,47 @@ export default class wktParser extends antlr4.Parser {
 
 
 
-	multiTinGeometry() {
-	    let localctx = new MultiTinGeometryContext(this, this._ctx, this.state);
-	    this.enterRule(localctx, 28, wktParser.RULE_multiTinGeometry);
+	multiCurveGeometry() {
+	    let localctx = new MultiCurveGeometryContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 34, wktParser.RULE_multiCurveGeometry);
 	    var _la = 0;
 	    try {
 	        this.enterOuterAlt(localctx, 1);
-	        this.state = 246;
-	        this.match(wktParser.TIN);
-	        this.state = 259;
+	        this.state = 247;
+	        this.match(wktParser.MULTICURVE);
+	        this.state = 249;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        if((((_la) & ~0x1f) === 0 && ((1 << _la) & 234881024) !== 0)) {
+	            this.state = 248;
+	            this.dim();
+	        }
+
+	        this.state = 263;
 	        this._errHandler.sync(this);
 	        switch(this._input.LA(1)) {
 	        case 5:
-	            this.state = 247;
+	            this.state = 251;
 	            this.match(wktParser.LPAR);
-	            this.state = 248;
-	            this.polygon();
-	            this.state = 253;
+	            this.state = 252;
+	            this.curveMember();
+	            this.state = 257;
 	            this._errHandler.sync(this);
 	            _la = this._input.LA(1);
 	            while(_la===4) {
-	                this.state = 249;
+	                this.state = 253;
 	                this.match(wktParser.COMMA);
-	                this.state = 250;
-	                this.polygon();
-	                this.state = 255;
+	                this.state = 254;
+	                this.curveMember();
+	                this.state = 259;
 	                this._errHandler.sync(this);
 	                _la = this._input.LA(1);
 	            }
-	            this.state = 256;
+	            this.state = 260;
 	            this.match(wktParser.RPAR);
 	            break;
-	        case 14:
-	            this.state = 258;
+	        case 24:
+	            this.state = 262;
 	            this.match(wktParser.EMPTY_);
 	            break;
 	        default:
@@ -1023,32 +1072,32 @@ export default class wktParser extends antlr4.Parser {
 
 
 
-	circularStringGeometry() {
-	    let localctx = new CircularStringGeometryContext(this, this._ctx, this.state);
-	    this.enterRule(localctx, 30, wktParser.RULE_circularStringGeometry);
-	    var _la = 0;
+	curveMember() {
+	    let localctx = new CurveMemberContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 36, wktParser.RULE_curveMember);
 	    try {
-	        this.enterOuterAlt(localctx, 1);
-	        this.state = 261;
-	        this.match(wktParser.CIRCULARSTRING);
-	        this.state = 262;
-	        this.match(wktParser.LPAR);
-	        this.state = 263;
-	        this.point();
 	        this.state = 268;
 	        this._errHandler.sync(this);
-	        _la = this._input.LA(1);
-	        while(_la===4) {
-	            this.state = 264;
-	            this.match(wktParser.COMMA);
+	        switch(this._input.LA(1)) {
+	        case 5:
+	        case 24:
+	            this.enterOuterAlt(localctx, 1);
 	            this.state = 265;
-	            this.point();
-	            this.state = 270;
-	            this._errHandler.sync(this);
-	            _la = this._input.LA(1);
+	            this.lineStringText();
+	            break;
+	        case 16:
+	            this.enterOuterAlt(localctx, 2);
+	            this.state = 266;
+	            this.circularStringGeometry();
+	            break;
+	        case 17:
+	            this.enterOuterAlt(localctx, 3);
+	            this.state = 267;
+	            this.compoundCurveGeometry();
+	            break;
+	        default:
+	            throw new antlr4.error.NoViableAltException(this);
 	        }
-	        this.state = 271;
-	        this.match(wktParser.RPAR);
 	    } catch (re) {
 	    	if(re instanceof antlr4.error.RecognitionException) {
 		        localctx.exception = re;
@@ -1065,27 +1114,49 @@ export default class wktParser extends antlr4.Parser {
 
 
 
-	pointOrClosedPoint() {
-	    let localctx = new PointOrClosedPointContext(this, this._ctx, this.state);
-	    this.enterRule(localctx, 32, wktParser.RULE_pointOrClosedPoint);
+	multiSurfaceGeometry() {
+	    let localctx = new MultiSurfaceGeometryContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 38, wktParser.RULE_multiSurfaceGeometry);
+	    var _la = 0;
 	    try {
-	        this.state = 278;
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 270;
+	        this.match(wktParser.MULTISURFACE);
+	        this.state = 272;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        if((((_la) & ~0x1f) === 0 && ((1 << _la) & 234881024) !== 0)) {
+	            this.state = 271;
+	            this.dim();
+	        }
+
+	        this.state = 286;
 	        this._errHandler.sync(this);
 	        switch(this._input.LA(1)) {
-	        case 1:
-	            this.enterOuterAlt(localctx, 1);
-	            this.state = 273;
-	            this.point();
-	            break;
 	        case 5:
-	            this.enterOuterAlt(localctx, 2);
 	            this.state = 274;
 	            this.match(wktParser.LPAR);
 	            this.state = 275;
-	            this.point();
-	            this.state = 276;
+	            this.surfaceMember();
+	            this.state = 280;
+	            this._errHandler.sync(this);
+	            _la = this._input.LA(1);
+	            while(_la===4) {
+	                this.state = 276;
+	                this.match(wktParser.COMMA);
+	                this.state = 277;
+	                this.surfaceMember();
+	                this.state = 282;
+	                this._errHandler.sync(this);
+	                _la = this._input.LA(1);
+	            }
+	            this.state = 283;
 	            this.match(wktParser.RPAR);
 	            break;
+	        case 24:
+	            this.state = 285;
+	            this.match(wktParser.EMPTY_);
+	            break;
 	        default:
 	            throw new antlr4.error.NoViableAltException(this);
 	        }
@@ -1105,39 +1176,23 @@ export default class wktParser extends antlr4.Parser {
 
 
 
-	polygon() {
-	    let localctx = new PolygonContext(this, this._ctx, this.state);
-	    this.enterRule(localctx, 34, wktParser.RULE_polygon);
-	    var _la = 0;
+	surfaceMember() {
+	    let localctx = new SurfaceMemberContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 40, wktParser.RULE_surfaceMember);
 	    try {
-	        this.state = 292;
+	        this.state = 290;
 	        this._errHandler.sync(this);
 	        switch(this._input.LA(1)) {
 	        case 5:
+	        case 24:
 	            this.enterOuterAlt(localctx, 1);
-	            this.state = 280;
-	            this.match(wktParser.LPAR);
-	            this.state = 281;
-	            this.lineString();
-	            this.state = 286;
-	            this._errHandler.sync(this);
-	            _la = this._input.LA(1);
-	            while(_la===4) {
-	                this.state = 282;
-	                this.match(wktParser.COMMA);
-	                this.state = 283;
-	                this.lineString();
-	                this.state = 288;
-	                this._errHandler.sync(this);
-	                _la = this._input.LA(1);
-	            }
-	            this.state = 289;
-	            this.match(wktParser.RPAR);
+	            this.state = 288;
+	            this.polygonText();
 	            break;
-	        case 14:
+	        case 19:
 	            this.enterOuterAlt(localctx, 2);
-	            this.state = 291;
-	            this.match(wktParser.EMPTY_);
+	            this.state = 289;
+	            this.curvePolygonGeometry();
 	            break;
 	        default:
 	            throw new antlr4.error.NoViableAltException(this);
@@ -1158,38 +1213,47 @@ export default class wktParser extends antlr4.Parser {
 
 
 
-	lineString() {
-	    let localctx = new LineStringContext(this, this._ctx, this.state);
-	    this.enterRule(localctx, 36, wktParser.RULE_lineString);
+	polyhedralSurfaceGeometry() {
+	    let localctx = new PolyhedralSurfaceGeometryContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 42, wktParser.RULE_polyhedralSurfaceGeometry);
 	    var _la = 0;
 	    try {
-	        this.state = 306;
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 292;
+	        this.match(wktParser.POLYHEDRALSURFACE);
+	        this.state = 294;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        if((((_la) & ~0x1f) === 0 && ((1 << _la) & 234881024) !== 0)) {
+	            this.state = 293;
+	            this.dim();
+	        }
+
+	        this.state = 308;
 	        this._errHandler.sync(this);
 	        switch(this._input.LA(1)) {
 	        case 5:
-	            this.enterOuterAlt(localctx, 1);
-	            this.state = 294;
+	            this.state = 296;
 	            this.match(wktParser.LPAR);
-	            this.state = 295;
-	            this.point();
-	            this.state = 300;
+	            this.state = 297;
+	            this.polygonText();
+	            this.state = 302;
 	            this._errHandler.sync(this);
 	            _la = this._input.LA(1);
 	            while(_la===4) {
-	                this.state = 296;
+	                this.state = 298;
 	                this.match(wktParser.COMMA);
-	                this.state = 297;
-	                this.point();
-	                this.state = 302;
+	                this.state = 299;
+	                this.polygonText();
+	                this.state = 304;
 	                this._errHandler.sync(this);
 	                _la = this._input.LA(1);
 	            }
-	            this.state = 303;
+	            this.state = 305;
 	            this.match(wktParser.RPAR);
 	            break;
-	        case 14:
-	            this.enterOuterAlt(localctx, 2);
-	            this.state = 305;
+	        case 24:
+	            this.state = 307;
 	            this.match(wktParser.EMPTY_);
 	            break;
 	        default:
@@ -1211,22 +1275,52 @@ export default class wktParser extends antlr4.Parser {
 
 
 
-	point() {
-	    let localctx = new PointContext(this, this._ctx, this.state);
-	    this.enterRule(localctx, 38, wktParser.RULE_point);
+	tinGeometry() {
+	    let localctx = new TinGeometryContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 44, wktParser.RULE_tinGeometry);
 	    var _la = 0;
 	    try {
 	        this.enterOuterAlt(localctx, 1);
-	        this.state = 309; 
+	        this.state = 310;
+	        this.match(wktParser.TIN);
+	        this.state = 312;
 	        this._errHandler.sync(this);
 	        _la = this._input.LA(1);
-	        do {
-	            this.state = 308;
-	            this.match(wktParser.DECIMAL);
-	            this.state = 311; 
+	        if((((_la) & ~0x1f) === 0 && ((1 << _la) & 234881024) !== 0)) {
+	            this.state = 311;
+	            this.dim();
+	        }
+
+	        this.state = 326;
+	        this._errHandler.sync(this);
+	        switch(this._input.LA(1)) {
+	        case 5:
+	            this.state = 314;
+	            this.match(wktParser.LPAR);
+	            this.state = 315;
+	            this.polygonText();
+	            this.state = 320;
 	            this._errHandler.sync(this);
 	            _la = this._input.LA(1);
-	        } while(_la===1);
+	            while(_la===4) {
+	                this.state = 316;
+	                this.match(wktParser.COMMA);
+	                this.state = 317;
+	                this.polygonText();
+	                this.state = 322;
+	                this._errHandler.sync(this);
+	                _la = this._input.LA(1);
+	            }
+	            this.state = 323;
+	            this.match(wktParser.RPAR);
+	            break;
+	        case 24:
+	            this.state = 325;
+	            this.match(wktParser.EMPTY_);
+	            break;
+	        default:
+	            throw new antlr4.error.NoViableAltException(this);
+	        }
 	    } catch (re) {
 	    	if(re instanceof antlr4.error.RecognitionException) {
 		        localctx.exception = re;
@@ -1243,79 +1337,568 @@ export default class wktParser extends antlr4.Parser {
 
 
 
-	name() {
-	    let localctx = new NameContext(this, this._ctx, this.state);
-	    this.enterRule(localctx, 40, wktParser.RULE_name);
+	polygonText() {
+	    let localctx = new PolygonTextContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 46, wktParser.RULE_polygonText);
+	    var _la = 0;
 	    try {
-	        this.enterOuterAlt(localctx, 1);
-	        this.state = 313;
-	        this.match(wktParser.STRING);
-	    } catch (re) {
-	    	if(re instanceof antlr4.error.RecognitionException) {
-		        localctx.exception = re;
-		        this._errHandler.reportError(this, re);
-		        this._errHandler.recover(this, re);
-		    } else {
-		    	throw re;
-		    }
-	    } finally {
-	        this.exitRule();
-	    }
+	        this.state = 340;
+	        this._errHandler.sync(this);
+	        switch(this._input.LA(1)) {
+	        case 5:
+	            this.enterOuterAlt(localctx, 1);
+	            this.state = 328;
+	            this.match(wktParser.LPAR);
+	            this.state = 329;
+	            this.lineStringText();
+	            this.state = 334;
+	            this._errHandler.sync(this);
+	            _la = this._input.LA(1);
+	            while(_la===4) {
+	                this.state = 330;
+	                this.match(wktParser.COMMA);
+	                this.state = 331;
+	                this.lineStringText();
+	                this.state = 336;
+	                this._errHandler.sync(this);
+	                _la = this._input.LA(1);
+	            }
+	            this.state = 337;
+	            this.match(wktParser.RPAR);
+	            break;
+	        case 24:
+	            this.enterOuterAlt(localctx, 2);
+	            this.state = 339;
+	            this.match(wktParser.EMPTY_);
+	            break;
+	        default:
+	            throw new antlr4.error.NoViableAltException(this);
+	        }
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	lineStringText() {
+	    let localctx = new LineStringTextContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 48, wktParser.RULE_lineStringText);
+	    var _la = 0;
+	    try {
+	        this.state = 354;
+	        this._errHandler.sync(this);
+	        switch(this._input.LA(1)) {
+	        case 5:
+	            this.enterOuterAlt(localctx, 1);
+	            this.state = 342;
+	            this.match(wktParser.LPAR);
+	            this.state = 343;
+	            this.point();
+	            this.state = 348;
+	            this._errHandler.sync(this);
+	            _la = this._input.LA(1);
+	            while(_la===4) {
+	                this.state = 344;
+	                this.match(wktParser.COMMA);
+	                this.state = 345;
+	                this.point();
+	                this.state = 350;
+	                this._errHandler.sync(this);
+	                _la = this._input.LA(1);
+	            }
+	            this.state = 351;
+	            this.match(wktParser.RPAR);
+	            break;
+	        case 24:
+	            this.enterOuterAlt(localctx, 2);
+	            this.state = 353;
+	            this.match(wktParser.EMPTY_);
+	            break;
+	        default:
+	            throw new antlr4.error.NoViableAltException(this);
+	        }
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
 	    return localctx;
 	}
 
 
+
+	pointOrClosedPoint() {
+	    let localctx = new PointOrClosedPointContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 50, wktParser.RULE_pointOrClosedPoint);
+	    try {
+	        this.state = 362;
+	        this._errHandler.sync(this);
+	        switch(this._input.LA(1)) {
+	        case 1:
+	        case 28:
+	        case 29:
+	        case 30:
+	            this.enterOuterAlt(localctx, 1);
+	            this.state = 356;
+	            this.point();
+	            break;
+	        case 5:
+	            this.enterOuterAlt(localctx, 2);
+	            this.state = 357;
+	            this.match(wktParser.LPAR);
+	            this.state = 358;
+	            this.point();
+	            this.state = 359;
+	            this.match(wktParser.RPAR);
+	            break;
+	        case 24:
+	            this.enterOuterAlt(localctx, 3);
+	            this.state = 361;
+	            this.match(wktParser.EMPTY_);
+	            break;
+	        default:
+	            throw new antlr4.error.NoViableAltException(this);
+	        }
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	point() {
+	    let localctx = new PointContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 52, wktParser.RULE_point);
+	    var _la = 0;
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 364;
+	        this.ordinate();
+	        this.state = 365;
+	        this.ordinate();
+	        this.state = 367;
+	        this._errHandler.sync(this);
+	        var la_ = this._interp.adaptivePredict(this._input,47,this._ctx);
+	        if(la_===1) {
+	            this.state = 366;
+	            this.ordinate();
+
+	        }
+	        this.state = 370;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        if((((_la) & ~0x1f) === 0 && ((1 << _la) & 1879048194) !== 0)) {
+	            this.state = 369;
+	            this.ordinate();
+	        }
+
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	ordinate() {
+	    let localctx = new OrdinateContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 54, wktParser.RULE_ordinate);
+	    var _la = 0;
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 372;
+	        _la = this._input.LA(1);
+	        if(!((((_la) & ~0x1f) === 0 && ((1 << _la) & 1879048194) !== 0))) {
+	        this._errHandler.recoverInline(this);
+	        }
+	        else {
+	        	this._errHandler.reportMatch(this);
+	            this.consume();
+	        }
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+}
+
+wktParser.EOF = antlr4.Token.EOF;
+wktParser.DECIMAL = 1;
+wktParser.INTEGERPART = 2;
+wktParser.DECIMALPART = 3;
+wktParser.COMMA = 4;
+wktParser.LPAR = 5;
+wktParser.RPAR = 6;
+wktParser.POINT = 7;
+wktParser.LINESTRING = 8;
+wktParser.LINEARRING = 9;
+wktParser.POLYGON = 10;
+wktParser.TRIANGLE = 11;
+wktParser.MULTIPOINT = 12;
+wktParser.MULTILINESTRING = 13;
+wktParser.MULTIPOLYGON = 14;
+wktParser.GEOMETRYCOLLECTION = 15;
+wktParser.CIRCULARSTRING = 16;
+wktParser.COMPOUNDCURVE = 17;
+wktParser.CLOTHOID = 18;
+wktParser.CURVEPOLYGON = 19;
+wktParser.MULTICURVE = 20;
+wktParser.MULTISURFACE = 21;
+wktParser.POLYHEDRALSURFACE = 22;
+wktParser.TIN = 23;
+wktParser.EMPTY_ = 24;
+wktParser.ZM_ = 25;
+wktParser.Z_ = 26;
+wktParser.M_ = 27;
+wktParser.NAN_ = 28;
+wktParser.NEG_INF_ = 29;
+wktParser.INF_ = 30;
+wktParser.WS = 31;
+
+wktParser.RULE_file_ = 0;
+wktParser.RULE_geometry = 1;
+wktParser.RULE_dim = 2;
+wktParser.RULE_pointGeometry = 3;
+wktParser.RULE_lineStringGeometry = 4;
+wktParser.RULE_linearRingGeometry = 5;
+wktParser.RULE_polygonGeometry = 6;
+wktParser.RULE_triangleGeometry = 7;
+wktParser.RULE_multiPointGeometry = 8;
+wktParser.RULE_multiLineStringGeometry = 9;
+wktParser.RULE_multiPolygonGeometry = 10;
+wktParser.RULE_geometryCollection = 11;
+wktParser.RULE_circularStringGeometry = 12;
+wktParser.RULE_compoundCurveGeometry = 13;
+wktParser.RULE_compoundCurveMember = 14;
+wktParser.RULE_clothoidGeometry = 15;
+wktParser.RULE_curvePolygonGeometry = 16;
+wktParser.RULE_multiCurveGeometry = 17;
+wktParser.RULE_curveMember = 18;
+wktParser.RULE_multiSurfaceGeometry = 19;
+wktParser.RULE_surfaceMember = 20;
+wktParser.RULE_polyhedralSurfaceGeometry = 21;
+wktParser.RULE_tinGeometry = 22;
+wktParser.RULE_polygonText = 23;
+wktParser.RULE_lineStringText = 24;
+wktParser.RULE_pointOrClosedPoint = 25;
+wktParser.RULE_point = 26;
+wktParser.RULE_ordinate = 27;
+
+class File_Context extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = wktParser.RULE_file_;
+    }
+
+	EOF() {
+	    return this.getToken(wktParser.EOF, 0);
+	};
+
+	geometry = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(GeometryContext);
+	    } else {
+	        return this.getTypedRuleContext(GeometryContext,i);
+	    }
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof wktListener ) {
+	        listener.enterFile_(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof wktListener ) {
+	        listener.exitFile_(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof wktVisitor ) {
+	        return visitor.visitFile_(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class GeometryContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = wktParser.RULE_geometry;
+    }
+
+	pointGeometry() {
+	    return this.getTypedRuleContext(PointGeometryContext,0);
+	};
+
+	lineStringGeometry() {
+	    return this.getTypedRuleContext(LineStringGeometryContext,0);
+	};
+
+	linearRingGeometry() {
+	    return this.getTypedRuleContext(LinearRingGeometryContext,0);
+	};
+
+	polygonGeometry() {
+	    return this.getTypedRuleContext(PolygonGeometryContext,0);
+	};
+
+	triangleGeometry() {
+	    return this.getTypedRuleContext(TriangleGeometryContext,0);
+	};
+
+	multiPointGeometry() {
+	    return this.getTypedRuleContext(MultiPointGeometryContext,0);
+	};
+
+	multiLineStringGeometry() {
+	    return this.getTypedRuleContext(MultiLineStringGeometryContext,0);
+	};
+
+	multiPolygonGeometry() {
+	    return this.getTypedRuleContext(MultiPolygonGeometryContext,0);
+	};
+
+	geometryCollection() {
+	    return this.getTypedRuleContext(GeometryCollectionContext,0);
+	};
+
+	circularStringGeometry() {
+	    return this.getTypedRuleContext(CircularStringGeometryContext,0);
+	};
+
+	compoundCurveGeometry() {
+	    return this.getTypedRuleContext(CompoundCurveGeometryContext,0);
+	};
+
+	curvePolygonGeometry() {
+	    return this.getTypedRuleContext(CurvePolygonGeometryContext,0);
+	};
+
+	multiCurveGeometry() {
+	    return this.getTypedRuleContext(MultiCurveGeometryContext,0);
+	};
+
+	multiSurfaceGeometry() {
+	    return this.getTypedRuleContext(MultiSurfaceGeometryContext,0);
+	};
+
+	polyhedralSurfaceGeometry() {
+	    return this.getTypedRuleContext(PolyhedralSurfaceGeometryContext,0);
+	};
+
+	tinGeometry() {
+	    return this.getTypedRuleContext(TinGeometryContext,0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof wktListener ) {
+	        listener.enterGeometry(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof wktListener ) {
+	        listener.exitGeometry(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof wktVisitor ) {
+	        return visitor.visitGeometry(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class DimContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = wktParser.RULE_dim;
+    }
+
+	Z_() {
+	    return this.getToken(wktParser.Z_, 0);
+	};
+
+	M_() {
+	    return this.getToken(wktParser.M_, 0);
+	};
+
+	ZM_() {
+	    return this.getToken(wktParser.ZM_, 0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof wktListener ) {
+	        listener.enterDim(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof wktListener ) {
+	        listener.exitDim(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof wktVisitor ) {
+	        return visitor.visitDim(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class PointGeometryContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = wktParser.RULE_pointGeometry;
+    }
+
+	POINT() {
+	    return this.getToken(wktParser.POINT, 0);
+	};
+
+	LPAR() {
+	    return this.getToken(wktParser.LPAR, 0);
+	};
+
+	point() {
+	    return this.getTypedRuleContext(PointContext,0);
+	};
+
+	RPAR() {
+	    return this.getToken(wktParser.RPAR, 0);
+	};
+
+	EMPTY_() {
+	    return this.getToken(wktParser.EMPTY_, 0);
+	};
+
+	dim() {
+	    return this.getTypedRuleContext(DimContext,0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof wktListener ) {
+	        listener.enterPointGeometry(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof wktListener ) {
+	        listener.exitPointGeometry(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof wktVisitor ) {
+	        return visitor.visitPointGeometry(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
 }
 
-wktParser.EOF = antlr4.Token.EOF;
-wktParser.DECIMAL = 1;
-wktParser.INTEGERPART = 2;
-wktParser.DECIMALPART = 3;
-wktParser.COMMA = 4;
-wktParser.LPAR = 5;
-wktParser.RPAR = 6;
-wktParser.POINT = 7;
-wktParser.LINESTRING = 8;
-wktParser.POLYGON = 9;
-wktParser.MULTIPOINT = 10;
-wktParser.MULTILINESTRING = 11;
-wktParser.MULTIPOLYGON = 12;
-wktParser.GEOMETRYCOLLECTION = 13;
-wktParser.EMPTY_ = 14;
-wktParser.CIRCULARSTRING = 15;
-wktParser.COMPOUNDCURVE = 16;
-wktParser.MULTISURFACE = 17;
-wktParser.CURVEPOLYGON = 18;
-wktParser.MULTICURVE = 19;
-wktParser.TRIANGLE = 20;
-wktParser.TIN = 21;
-wktParser.POLYHEDRALSURFACE = 22;
-wktParser.STRING = 23;
-wktParser.WS = 24;
 
-wktParser.RULE_file_ = 0;
-wktParser.RULE_geometryCollection = 1;
-wktParser.RULE_geometry = 2;
-wktParser.RULE_pointGeometry = 3;
-wktParser.RULE_lineStringGeometry = 4;
-wktParser.RULE_polygonGeometry = 5;
-wktParser.RULE_multiCurveGeometry = 6;
-wktParser.RULE_multiSurfaceGeometry = 7;
-wktParser.RULE_curvePolygonGeometry = 8;
-wktParser.RULE_compoundCurveGeometry = 9;
-wktParser.RULE_multiPointGeometry = 10;
-wktParser.RULE_multiLineStringGeometry = 11;
-wktParser.RULE_multiPolygonGeometry = 12;
-wktParser.RULE_multiPolyhedralSurfaceGeometry = 13;
-wktParser.RULE_multiTinGeometry = 14;
-wktParser.RULE_circularStringGeometry = 15;
-wktParser.RULE_pointOrClosedPoint = 16;
-wktParser.RULE_polygon = 17;
-wktParser.RULE_lineString = 18;
-wktParser.RULE_point = 19;
-wktParser.RULE_name = 20;
 
-class File_Context extends antlr4.ParserRuleContext {
+class LineStringGeometryContext extends antlr4.ParserRuleContext {
 
     constructor(parser, parent, invokingState) {
         if(parent===undefined) {
@@ -1326,39 +1909,138 @@ class File_Context extends antlr4.ParserRuleContext {
         }
         super(parent, invokingState);
         this.parser = parser;
-        this.ruleIndex = wktParser.RULE_file_;
+        this.ruleIndex = wktParser.RULE_lineStringGeometry;
     }
 
-	EOF() {
-	    return this.getToken(wktParser.EOF, 0);
+	LINESTRING() {
+	    return this.getToken(wktParser.LINESTRING, 0);
 	};
 
-	geometry = function(i) {
-	    if(i===undefined) {
-	        i = null;
+	lineStringText() {
+	    return this.getTypedRuleContext(LineStringTextContext,0);
+	};
+
+	dim() {
+	    return this.getTypedRuleContext(DimContext,0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof wktListener ) {
+	        listener.enterLineStringGeometry(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof wktListener ) {
+	        listener.exitLineStringGeometry(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof wktVisitor ) {
+	        return visitor.visitLineStringGeometry(this);
+	    } else {
+	        return visitor.visitChildren(this);
 	    }
-	    if(i===null) {
-	        return this.getTypedRuleContexts(GeometryContext);
+	}
+
+
+}
+
+
+
+class LinearRingGeometryContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = wktParser.RULE_linearRingGeometry;
+    }
+
+	LINEARRING() {
+	    return this.getToken(wktParser.LINEARRING, 0);
+	};
+
+	lineStringText() {
+	    return this.getTypedRuleContext(LineStringTextContext,0);
+	};
+
+	dim() {
+	    return this.getTypedRuleContext(DimContext,0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof wktListener ) {
+	        listener.enterLinearRingGeometry(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof wktListener ) {
+	        listener.exitLinearRingGeometry(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof wktVisitor ) {
+	        return visitor.visitLinearRingGeometry(this);
 	    } else {
-	        return this.getTypedRuleContext(GeometryContext,i);
+	        return visitor.visitChildren(this);
 	    }
+	}
+
+
+}
+
+
+
+class PolygonGeometryContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = wktParser.RULE_polygonGeometry;
+    }
+
+	POLYGON() {
+	    return this.getToken(wktParser.POLYGON, 0);
+	};
+
+	polygonText() {
+	    return this.getTypedRuleContext(PolygonTextContext,0);
+	};
+
+	dim() {
+	    return this.getTypedRuleContext(DimContext,0);
 	};
 
 	enterRule(listener) {
 	    if(listener instanceof wktListener ) {
-	        listener.enterFile_(this);
+	        listener.enterPolygonGeometry(this);
 		}
 	}
 
 	exitRule(listener) {
 	    if(listener instanceof wktListener ) {
-	        listener.exitFile_(this);
+	        listener.exitPolygonGeometry(this);
 		}
 	}
 
 	accept(visitor) {
 	    if ( visitor instanceof wktVisitor ) {
-	        return visitor.visitFile_(this);
+	        return visitor.visitPolygonGeometry(this);
 	    } else {
 	        return visitor.visitChildren(this);
 	    }
@@ -1369,7 +2051,7 @@ class File_Context extends antlr4.ParserRuleContext {
 
 
 
-class GeometryCollectionContext extends antlr4.ParserRuleContext {
+class TriangleGeometryContext extends antlr4.ParserRuleContext {
 
     constructor(parser, parent, invokingState) {
         if(parent===undefined) {
@@ -1380,25 +2062,76 @@ class GeometryCollectionContext extends antlr4.ParserRuleContext {
         }
         super(parent, invokingState);
         this.parser = parser;
-        this.ruleIndex = wktParser.RULE_geometryCollection;
+        this.ruleIndex = wktParser.RULE_triangleGeometry;
     }
 
-	GEOMETRYCOLLECTION() {
-	    return this.getToken(wktParser.GEOMETRYCOLLECTION, 0);
+	TRIANGLE() {
+	    return this.getToken(wktParser.TRIANGLE, 0);
+	};
+
+	polygonText() {
+	    return this.getTypedRuleContext(PolygonTextContext,0);
+	};
+
+	dim() {
+	    return this.getTypedRuleContext(DimContext,0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof wktListener ) {
+	        listener.enterTriangleGeometry(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof wktListener ) {
+	        listener.exitTriangleGeometry(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof wktVisitor ) {
+	        return visitor.visitTriangleGeometry(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class MultiPointGeometryContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = wktParser.RULE_multiPointGeometry;
+    }
+
+	MULTIPOINT() {
+	    return this.getToken(wktParser.MULTIPOINT, 0);
 	};
 
 	LPAR() {
 	    return this.getToken(wktParser.LPAR, 0);
 	};
 
-	geometry = function(i) {
+	pointOrClosedPoint = function(i) {
 	    if(i===undefined) {
 	        i = null;
 	    }
 	    if(i===null) {
-	        return this.getTypedRuleContexts(GeometryContext);
+	        return this.getTypedRuleContexts(PointOrClosedPointContext);
 	    } else {
-	        return this.getTypedRuleContext(GeometryContext,i);
+	        return this.getTypedRuleContext(PointOrClosedPointContext,i);
 	    }
 	};
 
@@ -1410,6 +2143,10 @@ class GeometryCollectionContext extends antlr4.ParserRuleContext {
 	    return this.getToken(wktParser.EMPTY_, 0);
 	};
 
+	dim() {
+	    return this.getTypedRuleContext(DimContext,0);
+	};
+
 	COMMA = function(i) {
 		if(i===undefined) {
 			i = null;
@@ -1424,19 +2161,19 @@ class GeometryCollectionContext extends antlr4.ParserRuleContext {
 
 	enterRule(listener) {
 	    if(listener instanceof wktListener ) {
-	        listener.enterGeometryCollection(this);
+	        listener.enterMultiPointGeometry(this);
 		}
 	}
 
 	exitRule(listener) {
 	    if(listener instanceof wktListener ) {
-	        listener.exitGeometryCollection(this);
+	        listener.exitMultiPointGeometry(this);
 		}
 	}
 
 	accept(visitor) {
 	    if ( visitor instanceof wktVisitor ) {
-	        return visitor.visitGeometryCollection(this);
+	        return visitor.visitMultiPointGeometry(this);
 	    } else {
 	        return visitor.visitChildren(this);
 	    }
@@ -1447,7 +2184,7 @@ class GeometryCollectionContext extends antlr4.ParserRuleContext {
 
 
 
-class GeometryContext extends antlr4.ParserRuleContext {
+class MultiLineStringGeometryContext extends antlr4.ParserRuleContext {
 
     constructor(parser, parent, invokingState) {
         if(parent===undefined) {
@@ -1458,80 +2195,67 @@ class GeometryContext extends antlr4.ParserRuleContext {
         }
         super(parent, invokingState);
         this.parser = parser;
-        this.ruleIndex = wktParser.RULE_geometry;
+        this.ruleIndex = wktParser.RULE_multiLineStringGeometry;
     }
 
-	polygonGeometry() {
-	    return this.getTypedRuleContext(PolygonGeometryContext,0);
-	};
-
-	lineStringGeometry() {
-	    return this.getTypedRuleContext(LineStringGeometryContext,0);
-	};
-
-	pointGeometry() {
-	    return this.getTypedRuleContext(PointGeometryContext,0);
-	};
-
-	compoundCurveGeometry() {
-	    return this.getTypedRuleContext(CompoundCurveGeometryContext,0);
-	};
-
-	curvePolygonGeometry() {
-	    return this.getTypedRuleContext(CurvePolygonGeometryContext,0);
-	};
-
-	multiSurfaceGeometry() {
-	    return this.getTypedRuleContext(MultiSurfaceGeometryContext,0);
-	};
-
-	multiCurveGeometry() {
-	    return this.getTypedRuleContext(MultiCurveGeometryContext,0);
+	MULTILINESTRING() {
+	    return this.getToken(wktParser.MULTILINESTRING, 0);
 	};
 
-	multiPointGeometry() {
-	    return this.getTypedRuleContext(MultiPointGeometryContext,0);
+	LPAR() {
+	    return this.getToken(wktParser.LPAR, 0);
 	};
 
-	multiLineStringGeometry() {
-	    return this.getTypedRuleContext(MultiLineStringGeometryContext,0);
+	lineStringText = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(LineStringTextContext);
+	    } else {
+	        return this.getTypedRuleContext(LineStringTextContext,i);
+	    }
 	};
 
-	multiPolygonGeometry() {
-	    return this.getTypedRuleContext(MultiPolygonGeometryContext,0);
+	RPAR() {
+	    return this.getToken(wktParser.RPAR, 0);
 	};
 
-	circularStringGeometry() {
-	    return this.getTypedRuleContext(CircularStringGeometryContext,0);
+	EMPTY_() {
+	    return this.getToken(wktParser.EMPTY_, 0);
 	};
 
-	multiPolyhedralSurfaceGeometry() {
-	    return this.getTypedRuleContext(MultiPolyhedralSurfaceGeometryContext,0);
+	dim() {
+	    return this.getTypedRuleContext(DimContext,0);
 	};
 
-	multiTinGeometry() {
-	    return this.getTypedRuleContext(MultiTinGeometryContext,0);
+	COMMA = function(i) {
+		if(i===undefined) {
+			i = null;
+		}
+	    if(i===null) {
+	        return this.getTokens(wktParser.COMMA);
+	    } else {
+	        return this.getToken(wktParser.COMMA, i);
+	    }
 	};
 
-	geometryCollection() {
-	    return this.getTypedRuleContext(GeometryCollectionContext,0);
-	};
 
 	enterRule(listener) {
 	    if(listener instanceof wktListener ) {
-	        listener.enterGeometry(this);
+	        listener.enterMultiLineStringGeometry(this);
 		}
 	}
 
 	exitRule(listener) {
 	    if(listener instanceof wktListener ) {
-	        listener.exitGeometry(this);
+	        listener.exitMultiLineStringGeometry(this);
 		}
 	}
 
 	accept(visitor) {
 	    if ( visitor instanceof wktVisitor ) {
-	        return visitor.visitGeometry(this);
+	        return visitor.visitMultiLineStringGeometry(this);
 	    } else {
 	        return visitor.visitChildren(this);
 	    }
@@ -1542,7 +2266,7 @@ class GeometryContext extends antlr4.ParserRuleContext {
 
 
 
-class PointGeometryContext extends antlr4.ParserRuleContext {
+class MultiPolygonGeometryContext extends antlr4.ParserRuleContext {
 
     constructor(parser, parent, invokingState) {
         if(parent===undefined) {
@@ -1553,48 +2277,67 @@ class PointGeometryContext extends antlr4.ParserRuleContext {
         }
         super(parent, invokingState);
         this.parser = parser;
-        this.ruleIndex = wktParser.RULE_pointGeometry;
+        this.ruleIndex = wktParser.RULE_multiPolygonGeometry;
     }
 
-	POINT() {
-	    return this.getToken(wktParser.POINT, 0);
-	};
-
-	EMPTY_() {
-	    return this.getToken(wktParser.EMPTY_, 0);
+	MULTIPOLYGON() {
+	    return this.getToken(wktParser.MULTIPOLYGON, 0);
 	};
 
 	LPAR() {
 	    return this.getToken(wktParser.LPAR, 0);
 	};
 
-	point() {
-	    return this.getTypedRuleContext(PointContext,0);
+	polygonText = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(PolygonTextContext);
+	    } else {
+	        return this.getTypedRuleContext(PolygonTextContext,i);
+	    }
 	};
 
 	RPAR() {
 	    return this.getToken(wktParser.RPAR, 0);
 	};
 
-	name() {
-	    return this.getTypedRuleContext(NameContext,0);
+	EMPTY_() {
+	    return this.getToken(wktParser.EMPTY_, 0);
+	};
+
+	dim() {
+	    return this.getTypedRuleContext(DimContext,0);
+	};
+
+	COMMA = function(i) {
+		if(i===undefined) {
+			i = null;
+		}
+	    if(i===null) {
+	        return this.getTokens(wktParser.COMMA);
+	    } else {
+	        return this.getToken(wktParser.COMMA, i);
+	    }
 	};
 
+
 	enterRule(listener) {
 	    if(listener instanceof wktListener ) {
-	        listener.enterPointGeometry(this);
+	        listener.enterMultiPolygonGeometry(this);
 		}
 	}
 
 	exitRule(listener) {
 	    if(listener instanceof wktListener ) {
-	        listener.exitPointGeometry(this);
+	        listener.exitMultiPolygonGeometry(this);
 		}
 	}
 
 	accept(visitor) {
 	    if ( visitor instanceof wktVisitor ) {
-	        return visitor.visitPointGeometry(this);
+	        return visitor.visitMultiPolygonGeometry(this);
 	    } else {
 	        return visitor.visitChildren(this);
 	    }
@@ -1605,7 +2348,7 @@ class PointGeometryContext extends antlr4.ParserRuleContext {
 
 
 
-class LineStringGeometryContext extends antlr4.ParserRuleContext {
+class GeometryCollectionContext extends antlr4.ParserRuleContext {
 
     constructor(parser, parent, invokingState) {
         if(parent===undefined) {
@@ -1616,32 +2359,67 @@ class LineStringGeometryContext extends antlr4.ParserRuleContext {
         }
         super(parent, invokingState);
         this.parser = parser;
-        this.ruleIndex = wktParser.RULE_lineStringGeometry;
+        this.ruleIndex = wktParser.RULE_geometryCollection;
     }
 
-	LINESTRING() {
-	    return this.getToken(wktParser.LINESTRING, 0);
+	GEOMETRYCOLLECTION() {
+	    return this.getToken(wktParser.GEOMETRYCOLLECTION, 0);
+	};
+
+	LPAR() {
+	    return this.getToken(wktParser.LPAR, 0);
+	};
+
+	geometry = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(GeometryContext);
+	    } else {
+	        return this.getTypedRuleContext(GeometryContext,i);
+	    }
+	};
+
+	RPAR() {
+	    return this.getToken(wktParser.RPAR, 0);
+	};
+
+	EMPTY_() {
+	    return this.getToken(wktParser.EMPTY_, 0);
+	};
+
+	dim() {
+	    return this.getTypedRuleContext(DimContext,0);
 	};
 
-	lineString() {
-	    return this.getTypedRuleContext(LineStringContext,0);
+	COMMA = function(i) {
+		if(i===undefined) {
+			i = null;
+		}
+	    if(i===null) {
+	        return this.getTokens(wktParser.COMMA);
+	    } else {
+	        return this.getToken(wktParser.COMMA, i);
+	    }
 	};
 
+
 	enterRule(listener) {
 	    if(listener instanceof wktListener ) {
-	        listener.enterLineStringGeometry(this);
+	        listener.enterGeometryCollection(this);
 		}
 	}
 
 	exitRule(listener) {
 	    if(listener instanceof wktListener ) {
-	        listener.exitLineStringGeometry(this);
+	        listener.exitGeometryCollection(this);
 		}
 	}
 
 	accept(visitor) {
 	    if ( visitor instanceof wktVisitor ) {
-	        return visitor.visitLineStringGeometry(this);
+	        return visitor.visitGeometryCollection(this);
 	    } else {
 	        return visitor.visitChildren(this);
 	    }
@@ -1652,7 +2430,7 @@ class LineStringGeometryContext extends antlr4.ParserRuleContext {
 
 
 
-class PolygonGeometryContext extends antlr4.ParserRuleContext {
+class CircularStringGeometryContext extends antlr4.ParserRuleContext {
 
     constructor(parser, parent, invokingState) {
         if(parent===undefined) {
@@ -1663,32 +2441,36 @@ class PolygonGeometryContext extends antlr4.ParserRuleContext {
         }
         super(parent, invokingState);
         this.parser = parser;
-        this.ruleIndex = wktParser.RULE_polygonGeometry;
+        this.ruleIndex = wktParser.RULE_circularStringGeometry;
     }
 
-	POLYGON() {
-	    return this.getToken(wktParser.POLYGON, 0);
+	CIRCULARSTRING() {
+	    return this.getToken(wktParser.CIRCULARSTRING, 0);
+	};
+
+	lineStringText() {
+	    return this.getTypedRuleContext(LineStringTextContext,0);
 	};
 
-	polygon() {
-	    return this.getTypedRuleContext(PolygonContext,0);
+	dim() {
+	    return this.getTypedRuleContext(DimContext,0);
 	};
 
 	enterRule(listener) {
 	    if(listener instanceof wktListener ) {
-	        listener.enterPolygonGeometry(this);
+	        listener.enterCircularStringGeometry(this);
 		}
 	}
 
 	exitRule(listener) {
 	    if(listener instanceof wktListener ) {
-	        listener.exitPolygonGeometry(this);
+	        listener.exitCircularStringGeometry(this);
 		}
 	}
 
 	accept(visitor) {
 	    if ( visitor instanceof wktVisitor ) {
-	        return visitor.visitPolygonGeometry(this);
+	        return visitor.visitCircularStringGeometry(this);
 	    } else {
 	        return visitor.visitChildren(this);
 	    }
@@ -1699,7 +2481,7 @@ class PolygonGeometryContext extends antlr4.ParserRuleContext {
 
 
 
-class MultiCurveGeometryContext extends antlr4.ParserRuleContext {
+class CompoundCurveGeometryContext extends antlr4.ParserRuleContext {
 
     constructor(parser, parent, invokingState) {
         if(parent===undefined) {
@@ -1710,56 +2492,38 @@ class MultiCurveGeometryContext extends antlr4.ParserRuleContext {
         }
         super(parent, invokingState);
         this.parser = parser;
-        this.ruleIndex = wktParser.RULE_multiCurveGeometry;
+        this.ruleIndex = wktParser.RULE_compoundCurveGeometry;
     }
 
-	MULTICURVE() {
-	    return this.getToken(wktParser.MULTICURVE, 0);
-	};
-
-	EMPTY_() {
-	    return this.getToken(wktParser.EMPTY_, 0);
+	COMPOUNDCURVE() {
+	    return this.getToken(wktParser.COMPOUNDCURVE, 0);
 	};
 
 	LPAR() {
 	    return this.getToken(wktParser.LPAR, 0);
 	};
 
-	RPAR() {
-	    return this.getToken(wktParser.RPAR, 0);
-	};
-
-	lineString = function(i) {
+	compoundCurveMember = function(i) {
 	    if(i===undefined) {
 	        i = null;
 	    }
 	    if(i===null) {
-	        return this.getTypedRuleContexts(LineStringContext);
+	        return this.getTypedRuleContexts(CompoundCurveMemberContext);
 	    } else {
-	        return this.getTypedRuleContext(LineStringContext,i);
+	        return this.getTypedRuleContext(CompoundCurveMemberContext,i);
 	    }
 	};
 
-	circularStringGeometry = function(i) {
-	    if(i===undefined) {
-	        i = null;
-	    }
-	    if(i===null) {
-	        return this.getTypedRuleContexts(CircularStringGeometryContext);
-	    } else {
-	        return this.getTypedRuleContext(CircularStringGeometryContext,i);
-	    }
+	RPAR() {
+	    return this.getToken(wktParser.RPAR, 0);
 	};
 
-	compoundCurveGeometry = function(i) {
-	    if(i===undefined) {
-	        i = null;
-	    }
-	    if(i===null) {
-	        return this.getTypedRuleContexts(CompoundCurveGeometryContext);
-	    } else {
-	        return this.getTypedRuleContext(CompoundCurveGeometryContext,i);
-	    }
+	EMPTY_() {
+	    return this.getToken(wktParser.EMPTY_, 0);
+	};
+
+	dim() {
+	    return this.getTypedRuleContext(DimContext,0);
 	};
 
 	COMMA = function(i) {
@@ -1776,19 +2540,19 @@ class MultiCurveGeometryContext extends antlr4.ParserRuleContext {
 
 	enterRule(listener) {
 	    if(listener instanceof wktListener ) {
-	        listener.enterMultiCurveGeometry(this);
+	        listener.enterCompoundCurveGeometry(this);
 		}
 	}
 
 	exitRule(listener) {
 	    if(listener instanceof wktListener ) {
-	        listener.exitMultiCurveGeometry(this);
+	        listener.exitCompoundCurveGeometry(this);
 		}
 	}
 
 	accept(visitor) {
 	    if ( visitor instanceof wktVisitor ) {
-	        return visitor.visitMultiCurveGeometry(this);
+	        return visitor.visitCompoundCurveGeometry(this);
 	    } else {
 	        return visitor.visitChildren(this);
 	    }
@@ -1799,7 +2563,7 @@ class MultiCurveGeometryContext extends antlr4.ParserRuleContext {
 
 
 
-class MultiSurfaceGeometryContext extends antlr4.ParserRuleContext {
+class CompoundCurveMemberContext extends antlr4.ParserRuleContext {
 
     constructor(parser, parent, invokingState) {
         if(parent===undefined) {
@@ -1810,74 +2574,36 @@ class MultiSurfaceGeometryContext extends antlr4.ParserRuleContext {
         }
         super(parent, invokingState);
         this.parser = parser;
-        this.ruleIndex = wktParser.RULE_multiSurfaceGeometry;
+        this.ruleIndex = wktParser.RULE_compoundCurveMember;
     }
 
-	MULTISURFACE() {
-	    return this.getToken(wktParser.MULTISURFACE, 0);
-	};
-
-	EMPTY_() {
-	    return this.getToken(wktParser.EMPTY_, 0);
-	};
-
-	LPAR() {
-	    return this.getToken(wktParser.LPAR, 0);
-	};
-
-	RPAR() {
-	    return this.getToken(wktParser.RPAR, 0);
-	};
-
-	polygon = function(i) {
-	    if(i===undefined) {
-	        i = null;
-	    }
-	    if(i===null) {
-	        return this.getTypedRuleContexts(PolygonContext);
-	    } else {
-	        return this.getTypedRuleContext(PolygonContext,i);
-	    }
+	lineStringText() {
+	    return this.getTypedRuleContext(LineStringTextContext,0);
 	};
 
-	curvePolygonGeometry = function(i) {
-	    if(i===undefined) {
-	        i = null;
-	    }
-	    if(i===null) {
-	        return this.getTypedRuleContexts(CurvePolygonGeometryContext);
-	    } else {
-	        return this.getTypedRuleContext(CurvePolygonGeometryContext,i);
-	    }
+	circularStringGeometry() {
+	    return this.getTypedRuleContext(CircularStringGeometryContext,0);
 	};
 
-	COMMA = function(i) {
-		if(i===undefined) {
-			i = null;
-		}
-	    if(i===null) {
-	        return this.getTokens(wktParser.COMMA);
-	    } else {
-	        return this.getToken(wktParser.COMMA, i);
-	    }
+	clothoidGeometry() {
+	    return this.getTypedRuleContext(ClothoidGeometryContext,0);
 	};
 
-
 	enterRule(listener) {
 	    if(listener instanceof wktListener ) {
-	        listener.enterMultiSurfaceGeometry(this);
+	        listener.enterCompoundCurveMember(this);
 		}
 	}
 
 	exitRule(listener) {
 	    if(listener instanceof wktListener ) {
-	        listener.exitMultiSurfaceGeometry(this);
+	        listener.exitCompoundCurveMember(this);
 		}
 	}
 
 	accept(visitor) {
 	    if ( visitor instanceof wktVisitor ) {
-	        return visitor.visitMultiSurfaceGeometry(this);
+	        return visitor.visitCompoundCurveMember(this);
 	    } else {
 	        return visitor.visitChildren(this);
 	    }
@@ -1888,7 +2614,7 @@ class MultiSurfaceGeometryContext extends antlr4.ParserRuleContext {
 
 
 
-class CurvePolygonGeometryContext extends antlr4.ParserRuleContext {
+class ClothoidGeometryContext extends antlr4.ParserRuleContext {
 
     constructor(parser, parent, invokingState) {
         if(parent===undefined) {
@@ -1899,55 +2625,25 @@ class CurvePolygonGeometryContext extends antlr4.ParserRuleContext {
         }
         super(parent, invokingState);
         this.parser = parser;
-        this.ruleIndex = wktParser.RULE_curvePolygonGeometry;
+        this.ruleIndex = wktParser.RULE_clothoidGeometry;
     }
 
-	CURVEPOLYGON() {
-	    return this.getToken(wktParser.CURVEPOLYGON, 0);
-	};
-
-	EMPTY_() {
-	    return this.getToken(wktParser.EMPTY_, 0);
+	CLOTHOID() {
+	    return this.getToken(wktParser.CLOTHOID, 0);
 	};
 
 	LPAR() {
 	    return this.getToken(wktParser.LPAR, 0);
 	};
 
-	RPAR() {
-	    return this.getToken(wktParser.RPAR, 0);
-	};
-
-	lineString = function(i) {
-	    if(i===undefined) {
-	        i = null;
-	    }
-	    if(i===null) {
-	        return this.getTypedRuleContexts(LineStringContext);
-	    } else {
-	        return this.getTypedRuleContext(LineStringContext,i);
-	    }
-	};
-
-	circularStringGeometry = function(i) {
-	    if(i===undefined) {
-	        i = null;
-	    }
-	    if(i===null) {
-	        return this.getTypedRuleContexts(CircularStringGeometryContext);
-	    } else {
-	        return this.getTypedRuleContext(CircularStringGeometryContext,i);
-	    }
-	};
-
-	compoundCurveGeometry = function(i) {
+	ordinate = function(i) {
 	    if(i===undefined) {
 	        i = null;
 	    }
 	    if(i===null) {
-	        return this.getTypedRuleContexts(CompoundCurveGeometryContext);
+	        return this.getTypedRuleContexts(OrdinateContext);
 	    } else {
-	        return this.getTypedRuleContext(CompoundCurveGeometryContext,i);
+	        return this.getTypedRuleContext(OrdinateContext,i);
 	    }
 	};
 
@@ -1963,21 +2659,25 @@ class CurvePolygonGeometryContext extends antlr4.ParserRuleContext {
 	};
 
 
+	RPAR() {
+	    return this.getToken(wktParser.RPAR, 0);
+	};
+
 	enterRule(listener) {
 	    if(listener instanceof wktListener ) {
-	        listener.enterCurvePolygonGeometry(this);
+	        listener.enterClothoidGeometry(this);
 		}
 	}
 
 	exitRule(listener) {
 	    if(listener instanceof wktListener ) {
-	        listener.exitCurvePolygonGeometry(this);
+	        listener.exitClothoidGeometry(this);
 		}
 	}
 
 	accept(visitor) {
 	    if ( visitor instanceof wktVisitor ) {
-	        return visitor.visitCurvePolygonGeometry(this);
+	        return visitor.visitClothoidGeometry(this);
 	    } else {
 	        return visitor.visitChildren(this);
 	    }
@@ -1988,7 +2688,7 @@ class CurvePolygonGeometryContext extends antlr4.ParserRuleContext {
 
 
 
-class CompoundCurveGeometryContext extends antlr4.ParserRuleContext {
+class CurvePolygonGeometryContext extends antlr4.ParserRuleContext {
 
     constructor(parser, parent, invokingState) {
         if(parent===undefined) {
@@ -1999,45 +2699,38 @@ class CompoundCurveGeometryContext extends antlr4.ParserRuleContext {
         }
         super(parent, invokingState);
         this.parser = parser;
-        this.ruleIndex = wktParser.RULE_compoundCurveGeometry;
+        this.ruleIndex = wktParser.RULE_curvePolygonGeometry;
     }
 
-	COMPOUNDCURVE() {
-	    return this.getToken(wktParser.COMPOUNDCURVE, 0);
-	};
-
-	EMPTY_() {
-	    return this.getToken(wktParser.EMPTY_, 0);
+	CURVEPOLYGON() {
+	    return this.getToken(wktParser.CURVEPOLYGON, 0);
 	};
 
 	LPAR() {
 	    return this.getToken(wktParser.LPAR, 0);
 	};
 
-	RPAR() {
-	    return this.getToken(wktParser.RPAR, 0);
-	};
-
-	lineString = function(i) {
+	curveMember = function(i) {
 	    if(i===undefined) {
 	        i = null;
 	    }
 	    if(i===null) {
-	        return this.getTypedRuleContexts(LineStringContext);
+	        return this.getTypedRuleContexts(CurveMemberContext);
 	    } else {
-	        return this.getTypedRuleContext(LineStringContext,i);
+	        return this.getTypedRuleContext(CurveMemberContext,i);
 	    }
 	};
 
-	circularStringGeometry = function(i) {
-	    if(i===undefined) {
-	        i = null;
-	    }
-	    if(i===null) {
-	        return this.getTypedRuleContexts(CircularStringGeometryContext);
-	    } else {
-	        return this.getTypedRuleContext(CircularStringGeometryContext,i);
-	    }
+	RPAR() {
+	    return this.getToken(wktParser.RPAR, 0);
+	};
+
+	EMPTY_() {
+	    return this.getToken(wktParser.EMPTY_, 0);
+	};
+
+	dim() {
+	    return this.getTypedRuleContext(DimContext,0);
 	};
 
 	COMMA = function(i) {
@@ -2054,19 +2747,19 @@ class CompoundCurveGeometryContext extends antlr4.ParserRuleContext {
 
 	enterRule(listener) {
 	    if(listener instanceof wktListener ) {
-	        listener.enterCompoundCurveGeometry(this);
+	        listener.enterCurvePolygonGeometry(this);
 		}
 	}
 
 	exitRule(listener) {
 	    if(listener instanceof wktListener ) {
-	        listener.exitCompoundCurveGeometry(this);
+	        listener.exitCurvePolygonGeometry(this);
 		}
 	}
 
 	accept(visitor) {
 	    if ( visitor instanceof wktVisitor ) {
-	        return visitor.visitCompoundCurveGeometry(this);
+	        return visitor.visitCurvePolygonGeometry(this);
 	    } else {
 	        return visitor.visitChildren(this);
 	    }
@@ -2077,7 +2770,7 @@ class CompoundCurveGeometryContext extends antlr4.ParserRuleContext {
 
 
 
-class MultiPointGeometryContext extends antlr4.ParserRuleContext {
+class MultiCurveGeometryContext extends antlr4.ParserRuleContext {
 
     constructor(parser, parent, invokingState) {
         if(parent===undefined) {
@@ -2088,29 +2781,25 @@ class MultiPointGeometryContext extends antlr4.ParserRuleContext {
         }
         super(parent, invokingState);
         this.parser = parser;
-        this.ruleIndex = wktParser.RULE_multiPointGeometry;
+        this.ruleIndex = wktParser.RULE_multiCurveGeometry;
     }
 
-	MULTIPOINT() {
-	    return this.getToken(wktParser.MULTIPOINT, 0);
-	};
-
-	EMPTY_() {
-	    return this.getToken(wktParser.EMPTY_, 0);
+	MULTICURVE() {
+	    return this.getToken(wktParser.MULTICURVE, 0);
 	};
 
 	LPAR() {
 	    return this.getToken(wktParser.LPAR, 0);
 	};
 
-	pointOrClosedPoint = function(i) {
+	curveMember = function(i) {
 	    if(i===undefined) {
 	        i = null;
 	    }
 	    if(i===null) {
-	        return this.getTypedRuleContexts(PointOrClosedPointContext);
+	        return this.getTypedRuleContexts(CurveMemberContext);
 	    } else {
-	        return this.getTypedRuleContext(PointOrClosedPointContext,i);
+	        return this.getTypedRuleContext(CurveMemberContext,i);
 	    }
 	};
 
@@ -2118,6 +2807,14 @@ class MultiPointGeometryContext extends antlr4.ParserRuleContext {
 	    return this.getToken(wktParser.RPAR, 0);
 	};
 
+	EMPTY_() {
+	    return this.getToken(wktParser.EMPTY_, 0);
+	};
+
+	dim() {
+	    return this.getTypedRuleContext(DimContext,0);
+	};
+
 	COMMA = function(i) {
 		if(i===undefined) {
 			i = null;
@@ -2132,19 +2829,19 @@ class MultiPointGeometryContext extends antlr4.ParserRuleContext {
 
 	enterRule(listener) {
 	    if(listener instanceof wktListener ) {
-	        listener.enterMultiPointGeometry(this);
+	        listener.enterMultiCurveGeometry(this);
 		}
 	}
 
 	exitRule(listener) {
 	    if(listener instanceof wktListener ) {
-	        listener.exitMultiPointGeometry(this);
+	        listener.exitMultiCurveGeometry(this);
 		}
 	}
 
 	accept(visitor) {
 	    if ( visitor instanceof wktVisitor ) {
-	        return visitor.visitMultiPointGeometry(this);
+	        return visitor.visitMultiCurveGeometry(this);
 	    } else {
 	        return visitor.visitChildren(this);
 	    }
@@ -2155,7 +2852,7 @@ class MultiPointGeometryContext extends antlr4.ParserRuleContext {
 
 
 
-class MultiLineStringGeometryContext extends antlr4.ParserRuleContext {
+class CurveMemberContext extends antlr4.ParserRuleContext {
 
     constructor(parser, parent, invokingState) {
         if(parent===undefined) {
@@ -2166,63 +2863,36 @@ class MultiLineStringGeometryContext extends antlr4.ParserRuleContext {
         }
         super(parent, invokingState);
         this.parser = parser;
-        this.ruleIndex = wktParser.RULE_multiLineStringGeometry;
+        this.ruleIndex = wktParser.RULE_curveMember;
     }
 
-	MULTILINESTRING() {
-	    return this.getToken(wktParser.MULTILINESTRING, 0);
-	};
-
-	EMPTY_() {
-	    return this.getToken(wktParser.EMPTY_, 0);
-	};
-
-	LPAR() {
-	    return this.getToken(wktParser.LPAR, 0);
-	};
-
-	lineString = function(i) {
-	    if(i===undefined) {
-	        i = null;
-	    }
-	    if(i===null) {
-	        return this.getTypedRuleContexts(LineStringContext);
-	    } else {
-	        return this.getTypedRuleContext(LineStringContext,i);
-	    }
+	lineStringText() {
+	    return this.getTypedRuleContext(LineStringTextContext,0);
 	};
 
-	RPAR() {
-	    return this.getToken(wktParser.RPAR, 0);
+	circularStringGeometry() {
+	    return this.getTypedRuleContext(CircularStringGeometryContext,0);
 	};
 
-	COMMA = function(i) {
-		if(i===undefined) {
-			i = null;
-		}
-	    if(i===null) {
-	        return this.getTokens(wktParser.COMMA);
-	    } else {
-	        return this.getToken(wktParser.COMMA, i);
-	    }
+	compoundCurveGeometry() {
+	    return this.getTypedRuleContext(CompoundCurveGeometryContext,0);
 	};
 
-
 	enterRule(listener) {
 	    if(listener instanceof wktListener ) {
-	        listener.enterMultiLineStringGeometry(this);
+	        listener.enterCurveMember(this);
 		}
 	}
 
 	exitRule(listener) {
 	    if(listener instanceof wktListener ) {
-	        listener.exitMultiLineStringGeometry(this);
+	        listener.exitCurveMember(this);
 		}
 	}
 
 	accept(visitor) {
 	    if ( visitor instanceof wktVisitor ) {
-	        return visitor.visitMultiLineStringGeometry(this);
+	        return visitor.visitCurveMember(this);
 	    } else {
 	        return visitor.visitChildren(this);
 	    }
@@ -2233,7 +2903,7 @@ class MultiLineStringGeometryContext extends antlr4.ParserRuleContext {
 
 
 
-class MultiPolygonGeometryContext extends antlr4.ParserRuleContext {
+class MultiSurfaceGeometryContext extends antlr4.ParserRuleContext {
 
     constructor(parser, parent, invokingState) {
         if(parent===undefined) {
@@ -2244,29 +2914,25 @@ class MultiPolygonGeometryContext extends antlr4.ParserRuleContext {
         }
         super(parent, invokingState);
         this.parser = parser;
-        this.ruleIndex = wktParser.RULE_multiPolygonGeometry;
+        this.ruleIndex = wktParser.RULE_multiSurfaceGeometry;
     }
 
-	MULTIPOLYGON() {
-	    return this.getToken(wktParser.MULTIPOLYGON, 0);
-	};
-
-	EMPTY_() {
-	    return this.getToken(wktParser.EMPTY_, 0);
+	MULTISURFACE() {
+	    return this.getToken(wktParser.MULTISURFACE, 0);
 	};
 
 	LPAR() {
 	    return this.getToken(wktParser.LPAR, 0);
 	};
 
-	polygon = function(i) {
+	surfaceMember = function(i) {
 	    if(i===undefined) {
 	        i = null;
 	    }
 	    if(i===null) {
-	        return this.getTypedRuleContexts(PolygonContext);
+	        return this.getTypedRuleContexts(SurfaceMemberContext);
 	    } else {
-	        return this.getTypedRuleContext(PolygonContext,i);
+	        return this.getTypedRuleContext(SurfaceMemberContext,i);
 	    }
 	};
 
@@ -2274,6 +2940,14 @@ class MultiPolygonGeometryContext extends antlr4.ParserRuleContext {
 	    return this.getToken(wktParser.RPAR, 0);
 	};
 
+	EMPTY_() {
+	    return this.getToken(wktParser.EMPTY_, 0);
+	};
+
+	dim() {
+	    return this.getTypedRuleContext(DimContext,0);
+	};
+
 	COMMA = function(i) {
 		if(i===undefined) {
 			i = null;
@@ -2288,19 +2962,19 @@ class MultiPolygonGeometryContext extends antlr4.ParserRuleContext {
 
 	enterRule(listener) {
 	    if(listener instanceof wktListener ) {
-	        listener.enterMultiPolygonGeometry(this);
+	        listener.enterMultiSurfaceGeometry(this);
 		}
 	}
 
 	exitRule(listener) {
 	    if(listener instanceof wktListener ) {
-	        listener.exitMultiPolygonGeometry(this);
+	        listener.exitMultiSurfaceGeometry(this);
 		}
 	}
 
 	accept(visitor) {
 	    if ( visitor instanceof wktVisitor ) {
-	        return visitor.visitMultiPolygonGeometry(this);
+	        return visitor.visitMultiSurfaceGeometry(this);
 	    } else {
 	        return visitor.visitChildren(this);
 	    }
@@ -2311,7 +2985,7 @@ class MultiPolygonGeometryContext extends antlr4.ParserRuleContext {
 
 
 
-class MultiPolyhedralSurfaceGeometryContext extends antlr4.ParserRuleContext {
+class SurfaceMemberContext extends antlr4.ParserRuleContext {
 
     constructor(parser, parent, invokingState) {
         if(parent===undefined) {
@@ -2322,63 +2996,32 @@ class MultiPolyhedralSurfaceGeometryContext extends antlr4.ParserRuleContext {
         }
         super(parent, invokingState);
         this.parser = parser;
-        this.ruleIndex = wktParser.RULE_multiPolyhedralSurfaceGeometry;
+        this.ruleIndex = wktParser.RULE_surfaceMember;
     }
 
-	POLYHEDRALSURFACE() {
-	    return this.getToken(wktParser.POLYHEDRALSURFACE, 0);
-	};
-
-	EMPTY_() {
-	    return this.getToken(wktParser.EMPTY_, 0);
-	};
-
-	LPAR() {
-	    return this.getToken(wktParser.LPAR, 0);
-	};
-
-	polygon = function(i) {
-	    if(i===undefined) {
-	        i = null;
-	    }
-	    if(i===null) {
-	        return this.getTypedRuleContexts(PolygonContext);
-	    } else {
-	        return this.getTypedRuleContext(PolygonContext,i);
-	    }
-	};
-
-	RPAR() {
-	    return this.getToken(wktParser.RPAR, 0);
+	polygonText() {
+	    return this.getTypedRuleContext(PolygonTextContext,0);
 	};
 
-	COMMA = function(i) {
-		if(i===undefined) {
-			i = null;
-		}
-	    if(i===null) {
-	        return this.getTokens(wktParser.COMMA);
-	    } else {
-	        return this.getToken(wktParser.COMMA, i);
-	    }
+	curvePolygonGeometry() {
+	    return this.getTypedRuleContext(CurvePolygonGeometryContext,0);
 	};
 
-
 	enterRule(listener) {
 	    if(listener instanceof wktListener ) {
-	        listener.enterMultiPolyhedralSurfaceGeometry(this);
+	        listener.enterSurfaceMember(this);
 		}
 	}
 
 	exitRule(listener) {
 	    if(listener instanceof wktListener ) {
-	        listener.exitMultiPolyhedralSurfaceGeometry(this);
+	        listener.exitSurfaceMember(this);
 		}
 	}
 
 	accept(visitor) {
 	    if ( visitor instanceof wktVisitor ) {
-	        return visitor.visitMultiPolyhedralSurfaceGeometry(this);
+	        return visitor.visitSurfaceMember(this);
 	    } else {
 	        return visitor.visitChildren(this);
 	    }
@@ -2389,7 +3032,7 @@ class MultiPolyhedralSurfaceGeometryContext extends antlr4.ParserRuleContext {
 
 
 
-class MultiTinGeometryContext extends antlr4.ParserRuleContext {
+class PolyhedralSurfaceGeometryContext extends antlr4.ParserRuleContext {
 
     constructor(parser, parent, invokingState) {
         if(parent===undefined) {
@@ -2400,29 +3043,25 @@ class MultiTinGeometryContext extends antlr4.ParserRuleContext {
         }
         super(parent, invokingState);
         this.parser = parser;
-        this.ruleIndex = wktParser.RULE_multiTinGeometry;
+        this.ruleIndex = wktParser.RULE_polyhedralSurfaceGeometry;
     }
 
-	TIN() {
-	    return this.getToken(wktParser.TIN, 0);
-	};
-
-	EMPTY_() {
-	    return this.getToken(wktParser.EMPTY_, 0);
+	POLYHEDRALSURFACE() {
+	    return this.getToken(wktParser.POLYHEDRALSURFACE, 0);
 	};
 
 	LPAR() {
 	    return this.getToken(wktParser.LPAR, 0);
 	};
 
-	polygon = function(i) {
+	polygonText = function(i) {
 	    if(i===undefined) {
 	        i = null;
 	    }
 	    if(i===null) {
-	        return this.getTypedRuleContexts(PolygonContext);
+	        return this.getTypedRuleContexts(PolygonTextContext);
 	    } else {
-	        return this.getTypedRuleContext(PolygonContext,i);
+	        return this.getTypedRuleContext(PolygonTextContext,i);
 	    }
 	};
 
@@ -2430,6 +3069,14 @@ class MultiTinGeometryContext extends antlr4.ParserRuleContext {
 	    return this.getToken(wktParser.RPAR, 0);
 	};
 
+	EMPTY_() {
+	    return this.getToken(wktParser.EMPTY_, 0);
+	};
+
+	dim() {
+	    return this.getTypedRuleContext(DimContext,0);
+	};
+
 	COMMA = function(i) {
 		if(i===undefined) {
 			i = null;
@@ -2444,19 +3091,19 @@ class MultiTinGeometryContext extends antlr4.ParserRuleContext {
 
 	enterRule(listener) {
 	    if(listener instanceof wktListener ) {
-	        listener.enterMultiTinGeometry(this);
+	        listener.enterPolyhedralSurfaceGeometry(this);
 		}
 	}
 
 	exitRule(listener) {
 	    if(listener instanceof wktListener ) {
-	        listener.exitMultiTinGeometry(this);
+	        listener.exitPolyhedralSurfaceGeometry(this);
 		}
 	}
 
 	accept(visitor) {
 	    if ( visitor instanceof wktVisitor ) {
-	        return visitor.visitMultiTinGeometry(this);
+	        return visitor.visitPolyhedralSurfaceGeometry(this);
 	    } else {
 	        return visitor.visitChildren(this);
 	    }
@@ -2467,7 +3114,7 @@ class MultiTinGeometryContext extends antlr4.ParserRuleContext {
 
 
 
-class CircularStringGeometryContext extends antlr4.ParserRuleContext {
+class TinGeometryContext extends antlr4.ParserRuleContext {
 
     constructor(parser, parent, invokingState) {
         if(parent===undefined) {
@@ -2478,25 +3125,25 @@ class CircularStringGeometryContext extends antlr4.ParserRuleContext {
         }
         super(parent, invokingState);
         this.parser = parser;
-        this.ruleIndex = wktParser.RULE_circularStringGeometry;
+        this.ruleIndex = wktParser.RULE_tinGeometry;
     }
 
-	CIRCULARSTRING() {
-	    return this.getToken(wktParser.CIRCULARSTRING, 0);
+	TIN() {
+	    return this.getToken(wktParser.TIN, 0);
 	};
 
 	LPAR() {
 	    return this.getToken(wktParser.LPAR, 0);
 	};
 
-	point = function(i) {
+	polygonText = function(i) {
 	    if(i===undefined) {
 	        i = null;
 	    }
 	    if(i===null) {
-	        return this.getTypedRuleContexts(PointContext);
+	        return this.getTypedRuleContexts(PolygonTextContext);
 	    } else {
-	        return this.getTypedRuleContext(PointContext,i);
+	        return this.getTypedRuleContext(PolygonTextContext,i);
 	    }
 	};
 
@@ -2504,6 +3151,14 @@ class CircularStringGeometryContext extends antlr4.ParserRuleContext {
 	    return this.getToken(wktParser.RPAR, 0);
 	};
 
+	EMPTY_() {
+	    return this.getToken(wktParser.EMPTY_, 0);
+	};
+
+	dim() {
+	    return this.getTypedRuleContext(DimContext,0);
+	};
+
 	COMMA = function(i) {
 		if(i===undefined) {
 			i = null;
@@ -2518,19 +3173,19 @@ class CircularStringGeometryContext extends antlr4.ParserRuleContext {
 
 	enterRule(listener) {
 	    if(listener instanceof wktListener ) {
-	        listener.enterCircularStringGeometry(this);
+	        listener.enterTinGeometry(this);
 		}
 	}
 
 	exitRule(listener) {
 	    if(listener instanceof wktListener ) {
-	        listener.exitCircularStringGeometry(this);
+	        listener.exitTinGeometry(this);
 		}
 	}
 
 	accept(visitor) {
 	    if ( visitor instanceof wktVisitor ) {
-	        return visitor.visitCircularStringGeometry(this);
+	        return visitor.visitTinGeometry(this);
 	    } else {
 	        return visitor.visitChildren(this);
 	    }
@@ -2541,7 +3196,7 @@ class CircularStringGeometryContext extends antlr4.ParserRuleContext {
 
 
 
-class PointOrClosedPointContext extends antlr4.ParserRuleContext {
+class PolygonTextContext extends antlr4.ParserRuleContext {
 
     constructor(parser, parent, invokingState) {
         if(parent===undefined) {
@@ -2552,36 +3207,59 @@ class PointOrClosedPointContext extends antlr4.ParserRuleContext {
         }
         super(parent, invokingState);
         this.parser = parser;
-        this.ruleIndex = wktParser.RULE_pointOrClosedPoint;
+        this.ruleIndex = wktParser.RULE_polygonText;
     }
 
-	point() {
-	    return this.getTypedRuleContext(PointContext,0);
-	};
-
 	LPAR() {
 	    return this.getToken(wktParser.LPAR, 0);
 	};
 
+	lineStringText = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(LineStringTextContext);
+	    } else {
+	        return this.getTypedRuleContext(LineStringTextContext,i);
+	    }
+	};
+
 	RPAR() {
 	    return this.getToken(wktParser.RPAR, 0);
 	};
 
+	COMMA = function(i) {
+		if(i===undefined) {
+			i = null;
+		}
+	    if(i===null) {
+	        return this.getTokens(wktParser.COMMA);
+	    } else {
+	        return this.getToken(wktParser.COMMA, i);
+	    }
+	};
+
+
+	EMPTY_() {
+	    return this.getToken(wktParser.EMPTY_, 0);
+	};
+
 	enterRule(listener) {
 	    if(listener instanceof wktListener ) {
-	        listener.enterPointOrClosedPoint(this);
+	        listener.enterPolygonText(this);
 		}
 	}
 
 	exitRule(listener) {
 	    if(listener instanceof wktListener ) {
-	        listener.exitPointOrClosedPoint(this);
+	        listener.exitPolygonText(this);
 		}
 	}
 
 	accept(visitor) {
 	    if ( visitor instanceof wktVisitor ) {
-	        return visitor.visitPointOrClosedPoint(this);
+	        return visitor.visitPolygonText(this);
 	    } else {
 	        return visitor.visitChildren(this);
 	    }
@@ -2592,7 +3270,7 @@ class PointOrClosedPointContext extends antlr4.ParserRuleContext {
 
 
 
-class PolygonContext extends antlr4.ParserRuleContext {
+class LineStringTextContext extends antlr4.ParserRuleContext {
 
     constructor(parser, parent, invokingState) {
         if(parent===undefined) {
@@ -2603,21 +3281,21 @@ class PolygonContext extends antlr4.ParserRuleContext {
         }
         super(parent, invokingState);
         this.parser = parser;
-        this.ruleIndex = wktParser.RULE_polygon;
+        this.ruleIndex = wktParser.RULE_lineStringText;
     }
 
 	LPAR() {
 	    return this.getToken(wktParser.LPAR, 0);
 	};
 
-	lineString = function(i) {
+	point = function(i) {
 	    if(i===undefined) {
 	        i = null;
 	    }
 	    if(i===null) {
-	        return this.getTypedRuleContexts(LineStringContext);
+	        return this.getTypedRuleContexts(PointContext);
 	    } else {
-	        return this.getTypedRuleContext(LineStringContext,i);
+	        return this.getTypedRuleContext(PointContext,i);
 	    }
 	};
 
@@ -2643,19 +3321,19 @@ class PolygonContext extends antlr4.ParserRuleContext {
 
 	enterRule(listener) {
 	    if(listener instanceof wktListener ) {
-	        listener.enterPolygon(this);
+	        listener.enterLineStringText(this);
 		}
 	}
 
 	exitRule(listener) {
 	    if(listener instanceof wktListener ) {
-	        listener.exitPolygon(this);
+	        listener.exitLineStringText(this);
 		}
 	}
 
 	accept(visitor) {
 	    if ( visitor instanceof wktVisitor ) {
-	        return visitor.visitPolygon(this);
+	        return visitor.visitLineStringText(this);
 	    } else {
 	        return visitor.visitChildren(this);
 	    }
@@ -2666,7 +3344,7 @@ class PolygonContext extends antlr4.ParserRuleContext {
 
 
 
-class LineStringContext extends antlr4.ParserRuleContext {
+class PointOrClosedPointContext extends antlr4.ParserRuleContext {
 
     constructor(parser, parent, invokingState) {
         if(parent===undefined) {
@@ -2677,59 +3355,40 @@ class LineStringContext extends antlr4.ParserRuleContext {
         }
         super(parent, invokingState);
         this.parser = parser;
-        this.ruleIndex = wktParser.RULE_lineString;
+        this.ruleIndex = wktParser.RULE_pointOrClosedPoint;
     }
 
-	LPAR() {
-	    return this.getToken(wktParser.LPAR, 0);
+	point() {
+	    return this.getTypedRuleContext(PointContext,0);
 	};
 
-	point = function(i) {
-	    if(i===undefined) {
-	        i = null;
-	    }
-	    if(i===null) {
-	        return this.getTypedRuleContexts(PointContext);
-	    } else {
-	        return this.getTypedRuleContext(PointContext,i);
-	    }
+	LPAR() {
+	    return this.getToken(wktParser.LPAR, 0);
 	};
 
 	RPAR() {
 	    return this.getToken(wktParser.RPAR, 0);
 	};
 
-	COMMA = function(i) {
-		if(i===undefined) {
-			i = null;
-		}
-	    if(i===null) {
-	        return this.getTokens(wktParser.COMMA);
-	    } else {
-	        return this.getToken(wktParser.COMMA, i);
-	    }
-	};
-
-
 	EMPTY_() {
 	    return this.getToken(wktParser.EMPTY_, 0);
 	};
 
 	enterRule(listener) {
 	    if(listener instanceof wktListener ) {
-	        listener.enterLineString(this);
+	        listener.enterPointOrClosedPoint(this);
 		}
 	}
 
 	exitRule(listener) {
 	    if(listener instanceof wktListener ) {
-	        listener.exitLineString(this);
+	        listener.exitPointOrClosedPoint(this);
 		}
 	}
 
 	accept(visitor) {
 	    if ( visitor instanceof wktVisitor ) {
-	        return visitor.visitLineString(this);
+	        return visitor.visitPointOrClosedPoint(this);
 	    } else {
 	        return visitor.visitChildren(this);
 	    }
@@ -2754,18 +3413,17 @@ class PointContext extends antlr4.ParserRuleContext {
         this.ruleIndex = wktParser.RULE_point;
     }
 
-	DECIMAL = function(i) {
-		if(i===undefined) {
-			i = null;
-		}
+	ordinate = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
 	    if(i===null) {
-	        return this.getTokens(wktParser.DECIMAL);
+	        return this.getTypedRuleContexts(OrdinateContext);
 	    } else {
-	        return this.getToken(wktParser.DECIMAL, i);
+	        return this.getTypedRuleContext(OrdinateContext,i);
 	    }
 	};
 
-
 	enterRule(listener) {
 	    if(listener instanceof wktListener ) {
 	        listener.enterPoint(this);
@@ -2791,7 +3449,7 @@ class PointContext extends antlr4.ParserRuleContext {
 
 
 
-class NameContext extends antlr4.ParserRuleContext {
+class OrdinateContext extends antlr4.ParserRuleContext {
 
     constructor(parser, parent, invokingState) {
         if(parent===undefined) {
@@ -2802,28 +3460,40 @@ class NameContext extends antlr4.ParserRuleContext {
         }
         super(parent, invokingState);
         this.parser = parser;
-        this.ruleIndex = wktParser.RULE_name;
+        this.ruleIndex = wktParser.RULE_ordinate;
     }
 
-	STRING() {
-	    return this.getToken(wktParser.STRING, 0);
+	DECIMAL() {
+	    return this.getToken(wktParser.DECIMAL, 0);
+	};
+
+	NAN_() {
+	    return this.getToken(wktParser.NAN_, 0);
+	};
+
+	INF_() {
+	    return this.getToken(wktParser.INF_, 0);
+	};
+
+	NEG_INF_() {
+	    return this.getToken(wktParser.NEG_INF_, 0);
 	};
 
 	enterRule(listener) {
 	    if(listener instanceof wktListener ) {
-	        listener.enterName(this);
+	        listener.enterOrdinate(this);
 		}
 	}
 
 	exitRule(listener) {
 	    if(listener instanceof wktListener ) {
-	        listener.exitName(this);
+	        listener.exitOrdinate(this);
 		}
 	}
 
 	accept(visitor) {
 	    if ( visitor instanceof wktVisitor ) {
-	        return visitor.visitName(this);
+	        return visitor.visitOrdinate(this);
 	    } else {
 	        return visitor.visitChildren(this);
 	    }
@@ -2836,23 +3506,30 @@ class NameContext extends antlr4.ParserRuleContext {
 
 
 wktParser.File_Context = File_Context; 
-wktParser.GeometryCollectionContext = GeometryCollectionContext; 
 wktParser.GeometryContext = GeometryContext; 
+wktParser.DimContext = DimContext; 
 wktParser.PointGeometryContext = PointGeometryContext; 
 wktParser.LineStringGeometryContext = LineStringGeometryContext; 
+wktParser.LinearRingGeometryContext = LinearRingGeometryContext; 
 wktParser.PolygonGeometryContext = PolygonGeometryContext; 
-wktParser.MultiCurveGeometryContext = MultiCurveGeometryContext; 
-wktParser.MultiSurfaceGeometryContext = MultiSurfaceGeometryContext; 
-wktParser.CurvePolygonGeometryContext = CurvePolygonGeometryContext; 
-wktParser.CompoundCurveGeometryContext = CompoundCurveGeometryContext; 
+wktParser.TriangleGeometryContext = TriangleGeometryContext; 
 wktParser.MultiPointGeometryContext = MultiPointGeometryContext; 
 wktParser.MultiLineStringGeometryContext = MultiLineStringGeometryContext; 
 wktParser.MultiPolygonGeometryContext = MultiPolygonGeometryContext; 
-wktParser.MultiPolyhedralSurfaceGeometryContext = MultiPolyhedralSurfaceGeometryContext; 
-wktParser.MultiTinGeometryContext = MultiTinGeometryContext; 
+wktParser.GeometryCollectionContext = GeometryCollectionContext; 
 wktParser.CircularStringGeometryContext = CircularStringGeometryContext; 
+wktParser.CompoundCurveGeometryContext = CompoundCurveGeometryContext; 
+wktParser.CompoundCurveMemberContext = CompoundCurveMemberContext; 
+wktParser.ClothoidGeometryContext = ClothoidGeometryContext; 
+wktParser.CurvePolygonGeometryContext = CurvePolygonGeometryContext; 
+wktParser.MultiCurveGeometryContext = MultiCurveGeometryContext; 
+wktParser.CurveMemberContext = CurveMemberContext; 
+wktParser.MultiSurfaceGeometryContext = MultiSurfaceGeometryContext; 
+wktParser.SurfaceMemberContext = SurfaceMemberContext; 
+wktParser.PolyhedralSurfaceGeometryContext = PolyhedralSurfaceGeometryContext; 
+wktParser.TinGeometryContext = TinGeometryContext; 
+wktParser.PolygonTextContext = PolygonTextContext; 
+wktParser.LineStringTextContext = LineStringTextContext; 
 wktParser.PointOrClosedPointContext = PointOrClosedPointContext; 
-wktParser.PolygonContext = PolygonContext; 
-wktParser.LineStringContext = LineStringContext; 
 wktParser.PointContext = PointContext; 
-wktParser.NameContext = NameContext; 
+wktParser.OrdinateContext = OrdinateContext;