var __getOwnPropNames = Object.getOwnPropertyNames;
var __commonJS = (cb, mod) => function __require() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
// E:/项目/孝感海绵城市/XiaoGanWXMini/node_modules/terraformer/terraformer.js
var require_terraformer = __commonJS({
"E:/项目/孝感海绵城市/XiaoGanWXMini/node_modules/terraformer/terraformer.js"(exports, module) {
(function(root, factory) {
if (typeof module === "object" && typeof module.exports === "object") {
exports = module.exports = factory();
}
if (typeof window === "object") {
root.Terraformer = factory();
}
})(exports, function() {
"use strict";
var exports2 = {}, EarthRadius = 6378137, DegreesPerRadian = 57.29577951308232, RadiansPerDegree = 0.017453292519943, MercatorCRS = {
"type": "link",
"properties": {
"href": "http://spatialreference.org/ref/sr-org/6928/ogcwkt/",
"type": "ogcwkt"
}
}, GeographicCRS = {
"type": "link",
"properties": {
"href": "http://spatialreference.org/ref/epsg/4326/ogcwkt/",
"type": "ogcwkt"
}
};
function isArray(obj) {
return Object.prototype.toString.call(obj) === "[object Array]";
}
function warn() {
var args = Array.prototype.slice.apply(arguments);
if (typeof console !== void 0 && console.warn) {
console.warn.apply(console, args);
}
}
function extend(destination, source) {
for (var k in source) {
if (source.hasOwnProperty(k)) {
destination[k] = source[k];
}
}
return destination;
}
function calculateBounds(geojson) {
if (geojson.type) {
switch (geojson.type) {
case "Point":
return [geojson.coordinates[0], geojson.coordinates[1], geojson.coordinates[0], geojson.coordinates[1]];
case "MultiPoint":
return calculateBoundsFromArray(geojson.coordinates);
case "LineString":
return calculateBoundsFromArray(geojson.coordinates);
case "MultiLineString":
return calculateBoundsFromNestedArrays(geojson.coordinates);
case "Polygon":
return calculateBoundsFromNestedArrays(geojson.coordinates);
case "MultiPolygon":
return calculateBoundsFromNestedArrayOfArrays(geojson.coordinates);
case "Feature":
return geojson.geometry ? calculateBounds(geojson.geometry) : null;
case "FeatureCollection":
return calculateBoundsForFeatureCollection(geojson);
case "GeometryCollection":
return calculateBoundsForGeometryCollection(geojson);
default:
throw new Error("Unknown type: " + geojson.type);
}
}
return null;
}
function calculateBoundsFromNestedArrays(array) {
var x1 = null, x2 = null, y1 = null, y2 = null;
for (var i2 = 0; i2 < array.length; i2++) {
var inner = array[i2];
for (var j = 0; j < inner.length; j++) {
var lonlat = inner[j];
var lon = lonlat[0];
var lat = lonlat[1];
if (x1 === null) {
x1 = lon;
} else if (lon < x1) {
x1 = lon;
}
if (x2 === null) {
x2 = lon;
} else if (lon > x2) {
x2 = lon;
}
if (y1 === null) {
y1 = lat;
} else if (lat < y1) {
y1 = lat;
}
if (y2 === null) {
y2 = lat;
} else if (lat > y2) {
y2 = lat;
}
}
}
return [x1, y1, x2, y2];
}
function calculateBoundsFromNestedArrayOfArrays(array) {
var x1 = null, x2 = null, y1 = null, y2 = null;
for (var i2 = 0; i2 < array.length; i2++) {
var inner = array[i2];
for (var j = 0; j < inner.length; j++) {
var innerinner = inner[j];
for (var k = 0; k < innerinner.length; k++) {
var lonlat = innerinner[k];
var lon = lonlat[0];
var lat = lonlat[1];
if (x1 === null) {
x1 = lon;
} else if (lon < x1) {
x1 = lon;
}
if (x2 === null) {
x2 = lon;
} else if (lon > x2) {
x2 = lon;
}
if (y1 === null) {
y1 = lat;
} else if (lat < y1) {
y1 = lat;
}
if (y2 === null) {
y2 = lat;
} else if (lat > y2) {
y2 = lat;
}
}
}
}
return [x1, y1, x2, y2];
}
function calculateBoundsFromArray(array) {
var x1 = null, x2 = null, y1 = null, y2 = null;
for (var i2 = 0; i2 < array.length; i2++) {
var lonlat = array[i2];
var lon = lonlat[0];
var lat = lonlat[1];
if (x1 === null) {
x1 = lon;
} else if (lon < x1) {
x1 = lon;
}
if (x2 === null) {
x2 = lon;
} else if (lon > x2) {
x2 = lon;
}
if (y1 === null) {
y1 = lat;
} else if (lat < y1) {
y1 = lat;
}
if (y2 === null) {
y2 = lat;
} else if (lat > y2) {
y2 = lat;
}
}
return [x1, y1, x2, y2];
}
function calculateBoundsForFeatureCollection(featureCollection) {
var extents = [], extent;
for (var i2 = featureCollection.features.length - 1; i2 >= 0; i2--) {
extent = calculateBounds(featureCollection.features[i2].geometry);
extents.push([extent[0], extent[1]]);
extents.push([extent[2], extent[3]]);
}
return calculateBoundsFromArray(extents);
}
function calculateBoundsForGeometryCollection(geometryCollection) {
var extents = [], extent;
for (var i2 = geometryCollection.geometries.length - 1; i2 >= 0; i2--) {
extent = calculateBounds(geometryCollection.geometries[i2]);
extents.push([extent[0], extent[1]]);
extents.push([extent[2], extent[3]]);
}
return calculateBoundsFromArray(extents);
}
function calculateEnvelope(geojson) {
var bounds = calculateBounds(geojson);
return {
x: bounds[0],
y: bounds[1],
w: Math.abs(bounds[0] - bounds[2]),
h: Math.abs(bounds[1] - bounds[3])
};
}
function radToDeg(rad) {
return rad * DegreesPerRadian;
}
function degToRad(deg) {
return deg * RadiansPerDegree;
}
function eachPosition(coordinates, func) {
for (var i2 = 0; i2 < coordinates.length; i2++) {
if (typeof coordinates[i2][0] === "number") {
coordinates[i2] = func(coordinates[i2]);
}
if (typeof coordinates[i2] === "object") {
coordinates[i2] = eachPosition(coordinates[i2], func);
}
}
return coordinates;
}
function positionToGeographic(position) {
var x = position[0];
var y = position[1];
return [radToDeg(x / EarthRadius) - Math.floor((radToDeg(x / EarthRadius) + 180) / 360) * 360, radToDeg(Math.PI / 2 - 2 * Math.atan(Math.exp(-1 * y / EarthRadius)))];
}
function positionToMercator(position) {
var lng = position[0];
var lat = Math.max(Math.min(position[1], 89.99999), -89.99999);
return [degToRad(lng) * EarthRadius, EarthRadius / 2 * Math.log((1 + Math.sin(degToRad(lat))) / (1 - Math.sin(degToRad(lat))))];
}
function applyConverter(geojson, converter, noCrs) {
if (geojson.type === "Point") {
geojson.coordinates = converter(geojson.coordinates);
} else if (geojson.type === "Feature") {
geojson.geometry = applyConverter(geojson.geometry, converter, true);
} else if (geojson.type === "FeatureCollection") {
for (var f = 0; f < geojson.features.length; f++) {
geojson.features[f] = applyConverter(geojson.features[f], converter, true);
}
} else if (geojson.type === "GeometryCollection") {
for (var g = 0; g < geojson.geometries.length; g++) {
geojson.geometries[g] = applyConverter(geojson.geometries[g], converter, true);
}
} else {
geojson.coordinates = eachPosition(geojson.coordinates, converter);
}
if (!noCrs) {
if (converter === positionToMercator) {
geojson.crs = MercatorCRS;
}
}
if (converter === positionToGeographic) {
delete geojson.crs;
}
return geojson;
}
function toMercator(geojson) {
return applyConverter(geojson, positionToMercator);
}
function toGeographic(geojson) {
return applyConverter(geojson, positionToGeographic);
}
function cmp(a, b) {
if (a < b) {
return -1;
} else if (a > b) {
return 1;
} else {
return 0;
}
}
function compSort(p1, p2) {
if (p1[0] > p2[0]) {
return -1;
} else if (p1[0] < p2[0]) {
return 1;
} else if (p1[1] > p2[1]) {
return -1;
} else if (p1[1] < p2[1]) {
return 1;
} else {
return 0;
}
}
function turn(p, q, r) {
return cmp((q[0] - p[0]) * (r[1] - p[1]) - (r[0] - p[0]) * (q[1] - p[1]), 0);
}
function euclideanDistance(p, q) {
var dx = q[0] - p[0];
var dy = q[1] - p[1];
return dx * dx + dy * dy;
}
function nextHullPoint(points, p) {
var q = p;
for (var r in points) {
var t = turn(p, q, points[r]);
if (t === -1 || t === 0 && euclideanDistance(p, points[r]) > euclideanDistance(p, q)) {
q = points[r];
}
}
return q;
}
function convexHull(points) {
if (points.length === 0) {
return [];
} else if (points.length === 1) {
return points;
}
var hull = [points.sort(compSort)[0]];
for (var p = 0; p < hull.length; p++) {
var q = nextHullPoint(points, hull[p]);
if (q !== hull[0]) {
hull.push(q);
}
}
return hull;
}
function isConvex(points) {
var ltz;
for (var i2 = 0; i2 < points.length - 3; i2++) {
var p1 = points[i2];
var p2 = points[i2 + 1];
var p3 = points[i2 + 2];
var v = [p2[0] - p1[0], p2[1] - p1[1]];
var res = p3[0] * v[1] - p3[1] * v[0] + v[0] * p1[1] - v[1] * p1[0];
if (i2 === 0) {
if (res < 0) {
ltz = true;
} else {
ltz = false;
}
} else {
if (ltz && res > 0 || !ltz && res < 0) {
return false;
}
}
}
return true;
}
function coordinatesContainPoint(coordinates, point) {
var contains = false;
for (var i2 = -1, l = coordinates.length, j = l - 1; ++i2 < l; j = i2) {
if ((coordinates[i2][1] <= point[1] && point[1] < coordinates[j][1] || coordinates[j][1] <= point[1] && point[1] < coordinates[i2][1]) && point[0] < (coordinates[j][0] - coordinates[i2][0]) * (point[1] - coordinates[i2][1]) / (coordinates[j][1] - coordinates[i2][1]) + coordinates[i2][0]) {
contains = !contains;
}
}
return contains;
}
function polygonContainsPoint(polygon, point) {
if (polygon && polygon.length) {
if (polygon.length === 1) {
return coordinatesContainPoint(polygon[0], point);
} else {
if (coordinatesContainPoint(polygon[0], point)) {
for (var i2 = 1; i2 < polygon.length; i2++) {
if (coordinatesContainPoint(polygon[i2], point)) {
return false;
}
}
return true;
} else {
return false;
}
}
} else {
return false;
}
}
function edgeIntersectsEdge(a1, a2, b1, b2) {
var ua_t = (b2[0] - b1[0]) * (a1[1] - b1[1]) - (b2[1] - b1[1]) * (a1[0] - b1[0]);
var ub_t = (a2[0] - a1[0]) * (a1[1] - b1[1]) - (a2[1] - a1[1]) * (a1[0] - b1[0]);
var u_b = (b2[1] - b1[1]) * (a2[0] - a1[0]) - (b2[0] - b1[0]) * (a2[1] - a1[1]);
if (u_b !== 0) {
var ua = ua_t / u_b;
var ub = ub_t / u_b;
if (0 <= ua && ua <= 1 && 0 <= ub && ub <= 1) {
return true;
}
}
return false;
}
function isNumber(n) {
return !isNaN(parseFloat(n)) && isFinite(n);
}
function arraysIntersectArrays(a, b) {
if (isNumber(a[0][0])) {
if (isNumber(b[0][0])) {
for (var i2 = 0; i2 < a.length - 1; i2++) {
for (var j = 0; j < b.length - 1; j++) {
if (edgeIntersectsEdge(a[i2], a[i2 + 1], b[j], b[j + 1])) {
return true;
}
}
}
} else {
for (var k = 0; k < b.length; k++) {
if (arraysIntersectArrays(a, b[k])) {
return true;
}
}
}
} else {
for (var l = 0; l < a.length; l++) {
if (arraysIntersectArrays(a[l], b)) {
return true;
}
}
}
return false;
}
function closedPolygon(coordinates) {
var outer = [];
for (var i2 = 0; i2 < coordinates.length; i2++) {
var inner = coordinates[i2].slice();
if (pointsEqual(inner[0], inner[inner.length - 1]) === false) {
inner.push(inner[0]);
}
outer.push(inner);
}
return outer;
}
function pointsEqual(a, b) {
for (var i2 = 0; i2 < a.length; i2++) {
if (a[i2] !== b[i2]) {
return false;
}
}
return true;
}
function coordinatesEqual(a, b) {
if (a.length !== b.length) {
return false;
}
var na = a.slice().sort(compSort);
var nb = b.slice().sort(compSort);
for (var i2 = 0; i2 < na.length; i2++) {
if (na[i2].length !== nb[i2].length) {
return false;
}
for (var j = 0; j < na.length; j++) {
if (na[i2][j] !== nb[i2][j]) {
return false;
}
}
}
return true;
}
var excludeFromJSON = ["length"];
function Primitive(geojson) {
if (geojson) {
switch (geojson.type) {
case "Point":
return new Point(geojson);
case "MultiPoint":
return new MultiPoint(geojson);
case "LineString":
return new LineString(geojson);
case "MultiLineString":
return new MultiLineString(geojson);
case "Polygon":
return new Polygon(geojson);
case "MultiPolygon":
return new MultiPolygon(geojson);
case "Feature":
return new Feature(geojson);
case "FeatureCollection":
return new FeatureCollection(geojson);
case "GeometryCollection":
return new GeometryCollection(geojson);
default:
throw new Error("Unknown type: " + geojson.type);
}
}
}
Primitive.prototype.toMercator = function() {
return toMercator(this);
};
Primitive.prototype.toGeographic = function() {
return toGeographic(this);
};
Primitive.prototype.envelope = function() {
return calculateEnvelope(this);
};
Primitive.prototype.bbox = function() {
return calculateBounds(this);
};
Primitive.prototype.convexHull = function() {
var coordinates = [], i2, j;
if (this.type === "Point") {
return null;
} else if (this.type === "LineString" || this.type === "MultiPoint") {
if (this.coordinates && this.coordinates.length >= 3) {
coordinates = this.coordinates;
} else {
return null;
}
} else if (this.type === "Polygon" || this.type === "MultiLineString") {
if (this.coordinates && this.coordinates.length > 0) {
for (i2 = 0; i2 < this.coordinates.length; i2++) {
coordinates = coordinates.concat(this.coordinates[i2]);
}
if (coordinates.length < 3) {
return null;
}
} else {
return null;
}
} else if (this.type === "MultiPolygon") {
if (this.coordinates && this.coordinates.length > 0) {
for (i2 = 0; i2 < this.coordinates.length; i2++) {
for (j = 0; j < this.coordinates[i2].length; j++) {
coordinates = coordinates.concat(this.coordinates[i2][j]);
}
}
if (coordinates.length < 3) {
return null;
}
} else {
return null;
}
} else if (this.type === "Feature") {
var primitive = new Primitive(this.geometry);
return primitive.convexHull();
}
return new Polygon({
type: "Polygon",
coordinates: closedPolygon([convexHull(coordinates)])
});
};
Primitive.prototype.toJSON = function() {
var obj = {};
for (var key in this) {
if (this.hasOwnProperty(key) && excludeFromJSON.indexOf(key) === -1) {
obj[key] = this[key];
}
}
obj.bbox = calculateBounds(this);
return obj;
};
Primitive.prototype.contains = function(primitive) {
return new Primitive(primitive).within(this);
};
Primitive.prototype.within = function(primitive) {
var coordinates, i2, j, contains;
if (primitive.type === "Feature") {
primitive = primitive.geometry;
}
if (primitive.type === "Point") {
if (this.type === "Point") {
return pointsEqual(this.coordinates, primitive.coordinates);
}
}
if (primitive.type === "MultiLineString") {
if (this.type === "Point") {
for (i2 = 0; i2 < primitive.coordinates.length; i2++) {
var linestring = { type: "LineString", coordinates: primitive.coordinates[i2] };
if (this.within(linestring)) {
return true;
}
}
}
}
if (primitive.type === "LineString" || primitive.type === "MultiPoint") {
if (this.type === "Point") {
for (i2 = 0; i2 < primitive.coordinates.length; i2++) {
if (this.coordinates.length !== primitive.coordinates[i2].length) {
return false;
}
if (pointsEqual(this.coordinates, primitive.coordinates[i2])) {
return true;
}
}
}
}
if (primitive.type === "Polygon") {
if (this.type === "Polygon") {
if (primitive.coordinates.length === this.coordinates.length) {
for (i2 = 0; i2 < this.coordinates.length; i2++) {
if (coordinatesEqual(this.coordinates[i2], primitive.coordinates[i2])) {
return true;
}
}
}
if (this.coordinates.length && polygonContainsPoint(primitive.coordinates, this.coordinates[0][0])) {
return !arraysIntersectArrays(closedPolygon(this.coordinates), closedPolygon(primitive.coordinates));
} else {
return false;
}
} else if (this.type === "Point") {
return polygonContainsPoint(primitive.coordinates, this.coordinates);
} else if (this.type === "LineString" || this.type === "MultiPoint") {
if (!this.coordinates || this.coordinates.length === 0) {
return false;
}
for (i2 = 0; i2 < this.coordinates.length; i2++) {
if (polygonContainsPoint(primitive.coordinates, this.coordinates[i2]) === false) {
return false;
}
}
return true;
} else if (this.type === "MultiLineString") {
for (i2 = 0; i2 < this.coordinates.length; i2++) {
var ls = new LineString(this.coordinates[i2]);
if (ls.within(primitive) === false) {
contains++;
return false;
}
}
return true;
} else if (this.type === "MultiPolygon") {
for (i2 = 0; i2 < this.coordinates.length; i2++) {
var p1 = new Primitive({ type: "Polygon", coordinates: this.coordinates[i2] });
if (p1.within(primitive) === false) {
return false;
}
}
return true;
}
}
if (primitive.type === "MultiPolygon") {
if (this.type === "Point") {
if (primitive.coordinates.length) {
for (i2 = 0; i2 < primitive.coordinates.length; i2++) {
coordinates = primitive.coordinates[i2];
if (polygonContainsPoint(coordinates, this.coordinates) && arraysIntersectArrays([this.coordinates], primitive.coordinates) === false) {
return true;
}
}
}
return false;
} else if (this.type === "Polygon") {
for (i2 = 0; i2 < this.coordinates.length; i2++) {
if (primitive.coordinates[i2].length === this.coordinates.length) {
for (j = 0; j < this.coordinates.length; j++) {
if (coordinatesEqual(this.coordinates[j], primitive.coordinates[i2][j])) {
return true;
}
}
}
}
if (arraysIntersectArrays(this.coordinates, primitive.coordinates) === false) {
if (primitive.coordinates.length) {
for (i2 = 0; i2 < primitive.coordinates.length; i2++) {
coordinates = primitive.coordinates[i2];
if (polygonContainsPoint(coordinates, this.coordinates[0][0]) === false) {
contains = false;
} else {
contains = true;
}
}
return contains;
}
}
} else if (this.type === "LineString" || this.type === "MultiPoint") {
for (i2 = 0; i2 < primitive.coordinates.length; i2++) {
var p = { type: "Polygon", coordinates: primitive.coordinates[i2] };
if (this.within(p)) {
return true;
}
return false;
}
} else if (this.type === "MultiLineString") {
for (i2 = 0; i2 < this.coordinates.length; i2++) {
var lines = new LineString(this.coordinates[i2]);
if (lines.within(primitive) === false) {
return false;
}
}
return true;
} else if (this.type === "MultiPolygon") {
for (i2 = 0; i2 < primitive.coordinates.length; i2++) {
var mpoly = { type: "Polygon", coordinates: primitive.coordinates[i2] };
if (this.within(mpoly) === false) {
return false;
}
}
return true;
}
}
return false;
};
Primitive.prototype.intersects = function(primitive) {
if (primitive.type === "Feature") {
primitive = primitive.geometry;
}
var p = new Primitive(primitive);
if (this.within(primitive) || p.within(this)) {
return true;
}
if (this.type !== "Point" && this.type !== "MultiPoint" && primitive.type !== "Point" && primitive.type !== "MultiPoint") {
return arraysIntersectArrays(this.coordinates, primitive.coordinates);
} else if (this.type === "Feature") {
var inner = new Primitive(this.geometry);
return inner.intersects(primitive);
}
warn("Type " + this.type + " to " + primitive.type + " intersection is not supported by intersects");
return false;
};
function Point(input) {
var args = Array.prototype.slice.call(arguments);
if (input && input.type === "Point" && input.coordinates) {
extend(this, input);
} else if (input && isArray(input)) {
this.coordinates = input;
} else if (args.length >= 2) {
this.coordinates = args;
} else {
throw "Terraformer: invalid input for Terraformer.Point";
}
this.type = "Point";
}
Point.prototype = new Primitive();
Point.prototype.constructor = Point;
function MultiPoint(input) {
if (input && input.type === "MultiPoint" && input.coordinates) {
extend(this, input);
} else if (isArray(input)) {
this.coordinates = input;
} else {
throw "Terraformer: invalid input for Terraformer.MultiPoint";
}
this.type = "MultiPoint";
}
MultiPoint.prototype = new Primitive();
MultiPoint.prototype.constructor = MultiPoint;
MultiPoint.prototype.forEach = function(func) {
for (var i2 = 0; i2 < this.coordinates.length; i2++) {
func.apply(this, [this.coordinates[i2], i2, this.coordinates]);
}
return this;
};
MultiPoint.prototype.addPoint = function(point) {
this.coordinates.push(point);
return this;
};
MultiPoint.prototype.insertPoint = function(point, index) {
this.coordinates.splice(index, 0, point);
return this;
};
MultiPoint.prototype.removePoint = function(remove) {
if (typeof remove === "number") {
this.coordinates.splice(remove, 1);
} else {
this.coordinates.splice(this.coordinates.indexOf(remove), 1);
}
return this;
};
MultiPoint.prototype.get = function(i2) {
return new Point(this.coordinates[i2]);
};
function LineString(input) {
if (input && input.type === "LineString" && input.coordinates) {
extend(this, input);
} else if (isArray(input)) {
this.coordinates = input;
} else {
throw "Terraformer: invalid input for Terraformer.LineString";
}
this.type = "LineString";
}
LineString.prototype = new Primitive();
LineString.prototype.constructor = LineString;
LineString.prototype.addVertex = function(point) {
this.coordinates.push(point);
return this;
};
LineString.prototype.insertVertex = function(point, index) {
this.coordinates.splice(index, 0, point);
return this;
};
LineString.prototype.removeVertex = function(remove) {
this.coordinates.splice(remove, 1);
return this;
};
function MultiLineString(input) {
if (input && input.type === "MultiLineString" && input.coordinates) {
extend(this, input);
} else if (isArray(input)) {
this.coordinates = input;
} else {
throw "Terraformer: invalid input for Terraformer.MultiLineString";
}
this.type = "MultiLineString";
}
MultiLineString.prototype = new Primitive();
MultiLineString.prototype.constructor = MultiLineString;
MultiLineString.prototype.forEach = function(func) {
for (var i2 = 0; i2 < this.coordinates.length; i2++) {
func.apply(this, [this.coordinates[i2], i2, this.coordinates]);
}
};
MultiLineString.prototype.get = function(i2) {
return new LineString(this.coordinates[i2]);
};
function Polygon(input) {
if (input && input.type === "Polygon" && input.coordinates) {
extend(this, input);
} else if (isArray(input)) {
this.coordinates = input;
} else {
throw "Terraformer: invalid input for Terraformer.Polygon";
}
this.type = "Polygon";
}
Polygon.prototype = new Primitive();
Polygon.prototype.constructor = Polygon;
Polygon.prototype.addVertex = function(point) {
this.insertVertex(point, this.coordinates[0].length - 1);
return this;
};
Polygon.prototype.insertVertex = function(point, index) {
this.coordinates[0].splice(index, 0, point);
return this;
};
Polygon.prototype.removeVertex = function(remove) {
this.coordinates[0].splice(remove, 1);
return this;
};
Polygon.prototype.close = function() {
this.coordinates = closedPolygon(this.coordinates);
};
Polygon.prototype.hasHoles = function() {
return this.coordinates.length > 1;
};
Polygon.prototype.holes = function() {
var holes = [];
if (this.hasHoles()) {
for (var i2 = 1; i2 < this.coordinates.length; i2++) {
holes.push(new Polygon([this.coordinates[i2]]));
}
}
return holes;
};
function MultiPolygon(input) {
if (input && input.type === "MultiPolygon" && input.coordinates) {
extend(this, input);
} else if (isArray(input)) {
this.coordinates = input;
} else {
throw "Terraformer: invalid input for Terraformer.MultiPolygon";
}
this.type = "MultiPolygon";
}
MultiPolygon.prototype = new Primitive();
MultiPolygon.prototype.constructor = MultiPolygon;
MultiPolygon.prototype.forEach = function(func) {
for (var i2 = 0; i2 < this.coordinates.length; i2++) {
func.apply(this, [this.coordinates[i2], i2, this.coordinates]);
}
};
MultiPolygon.prototype.get = function(i2) {
return new Polygon(this.coordinates[i2]);
};
MultiPolygon.prototype.close = function() {
var outer = [];
this.forEach(function(polygon) {
outer.push(closedPolygon(polygon));
});
this.coordinates = outer;
return this;
};
function Feature(input) {
if (input && input.type === "Feature") {
extend(this, input);
} else if (input && input.type && input.coordinates) {
this.geometry = input;
} else {
throw "Terraformer: invalid input for Terraformer.Feature";
}
this.type = "Feature";
}
Feature.prototype = new Primitive();
Feature.prototype.constructor = Feature;
function FeatureCollection(input) {
if (input && input.type === "FeatureCollection" && input.features) {
extend(this, input);
} else if (isArray(input)) {
this.features = input;
} else {
throw "Terraformer: invalid input for Terraformer.FeatureCollection";
}
this.type = "FeatureCollection";
}
FeatureCollection.prototype = new Primitive();
FeatureCollection.prototype.constructor = FeatureCollection;
FeatureCollection.prototype.forEach = function(func) {
for (var i2 = 0; i2 < this.features.length; i2++) {
func.apply(this, [this.features[i2], i2, this.features]);
}
};
FeatureCollection.prototype.get = function(id) {
var found;
this.forEach(function(feature) {
if (feature.id === id) {
found = feature;
}
});
return new Feature(found);
};
function GeometryCollection(input) {
if (input && input.type === "GeometryCollection" && input.geometries) {
extend(this, input);
} else if (isArray(input)) {
this.geometries = input;
} else if (input.coordinates && input.type) {
this.type = "GeometryCollection";
this.geometries = [input];
} else {
throw "Terraformer: invalid input for Terraformer.GeometryCollection";
}
this.type = "GeometryCollection";
}
GeometryCollection.prototype = new Primitive();
GeometryCollection.prototype.constructor = GeometryCollection;
GeometryCollection.prototype.forEach = function(func) {
for (var i2 = 0; i2 < this.geometries.length; i2++) {
func.apply(this, [this.geometries[i2], i2, this.geometries]);
}
};
GeometryCollection.prototype.get = function(i2) {
return new Primitive(this.geometries[i2]);
};
function createCircle(center, radius, interpolate) {
var mercatorPosition = positionToMercator(center);
var steps = interpolate || 64;
var polygon = {
type: "Polygon",
coordinates: [[]]
};
for (var i2 = 1; i2 <= steps; i2++) {
var radians = i2 * (360 / steps) * Math.PI / 180;
polygon.coordinates[0].push([mercatorPosition[0] + radius * Math.cos(radians), mercatorPosition[1] + radius * Math.sin(radians)]);
}
polygon.coordinates = closedPolygon(polygon.coordinates);
return toGeographic(polygon);
}
function Circle(center, radius, interpolate) {
var steps = interpolate || 64;
var rad = radius || 250;
if (!center || center.length < 2 || !rad || !steps) {
throw new Error("Terraformer: missing parameter for Terraformer.Circle");
}
extend(this, new Feature({
type: "Feature",
geometry: createCircle(center, rad, steps),
properties: {
radius: rad,
center,
steps
}
}));
}
Circle.prototype = new Primitive();
Circle.prototype.constructor = Circle;
Circle.prototype.recalculate = function() {
this.geometry = createCircle(this.properties.center, this.properties.radius, this.properties.steps);
return this;
};
Circle.prototype.center = function(coordinates) {
if (coordinates) {
this.properties.center = coordinates;
this.recalculate();
}
return this.properties.center;
};
Circle.prototype.radius = function(radius) {
if (radius) {
this.properties.radius = radius;
this.recalculate();
}
return this.properties.radius;
};
Circle.prototype.steps = function(steps) {
if (steps) {
this.properties.steps = steps;
this.recalculate();
}
return this.properties.steps;
};
Circle.prototype.toJSON = function() {
var output = Primitive.prototype.toJSON.call(this);
return output;
};
exports2.Primitive = Primitive;
exports2.Point = Point;
exports2.MultiPoint = MultiPoint;
exports2.LineString = LineString;
exports2.MultiLineString = MultiLineString;
exports2.Polygon = Polygon;
exports2.MultiPolygon = MultiPolygon;
exports2.Feature = Feature;
exports2.FeatureCollection = FeatureCollection;
exports2.GeometryCollection = GeometryCollection;
exports2.Circle = Circle;
exports2.toMercator = toMercator;
exports2.toGeographic = toGeographic;
exports2.Tools = {};
exports2.Tools.positionToMercator = positionToMercator;
exports2.Tools.positionToGeographic = positionToGeographic;
exports2.Tools.applyConverter = applyConverter;
exports2.Tools.toMercator = toMercator;
exports2.Tools.toGeographic = toGeographic;
exports2.Tools.createCircle = createCircle;
exports2.Tools.calculateBounds = calculateBounds;
exports2.Tools.calculateEnvelope = calculateEnvelope;
exports2.Tools.coordinatesContainPoint = coordinatesContainPoint;
exports2.Tools.polygonContainsPoint = polygonContainsPoint;
exports2.Tools.arraysIntersectArrays = arraysIntersectArrays;
exports2.Tools.coordinatesContainPoint = coordinatesContainPoint;
exports2.Tools.coordinatesEqual = coordinatesEqual;
exports2.Tools.convexHull = convexHull;
exports2.Tools.isConvex = isConvex;
exports2.MercatorCRS = MercatorCRS;
exports2.GeographicCRS = GeographicCRS;
return exports2;
});
}
});
// E:/项目/孝感海绵城市/XiaoGanWXMini/node_modules/terraformer-wkt-parser/terraformer-wkt-parser.js
var require_terraformer_wkt_parser = __commonJS({
"E:/项目/孝感海绵城市/XiaoGanWXMini/node_modules/terraformer-wkt-parser/terraformer-wkt-parser.js"(exports, module) {
(function(root, factory) {
if (typeof module === "object" && typeof module.exports === "object") {
exports = module.exports = factory(require_terraformer());
} else if (typeof navigator === "object") {
if (!root.Terraformer) {
throw new Error("Terraformer.WKT requires the core Terraformer library. http://github.com/esri/terraformer");
}
root.Terraformer.WKT = factory(root.Terraformer);
}
})(exports, function(Terraformer) {
var exports2 = {};
var parser = function() {
var parser2 = {
trace: function trace() {
},
yy: {},
symbols_: { "error": 2, "expressions": 3, "point": 4, "EOF": 5, "linestring": 6, "polygon": 7, "multipoint": 8, "multilinestring": 9, "multipolygon": 10, "coordinate": 11, "DOUBLE_TOK": 12, "ptarray": 13, "COMMA": 14, "ring_list": 15, "ring": 16, "(": 17, ")": 18, "POINT": 19, "Z": 20, "ZM": 21, "M": 22, "EMPTY": 23, "point_untagged": 24, "polygon_list": 25, "polygon_untagged": 26, "point_list": 27, "LINESTRING": 28, "POLYGON": 29, "MULTIPOINT": 30, "MULTILINESTRING": 31, "MULTIPOLYGON": 32, "$accept": 0, "$end": 1 },
terminals_: { 2: "error", 5: "EOF", 12: "DOUBLE_TOK", 14: "COMMA", 17: "(", 18: ")", 19: "POINT", 20: "Z", 21: "ZM", 22: "M", 23: "EMPTY", 28: "LINESTRING", 29: "POLYGON", 30: "MULTIPOINT", 31: "MULTILINESTRING", 32: "MULTIPOLYGON" },
productions_: [0, [3, 2], [3, 2], [3, 2], [3, 2], [3, 2], [3, 2], [11, 2], [11, 3], [11, 4], [13, 3], [13, 1], [15, 3], [15, 1], [16, 3], [4, 4], [4, 5], [4, 5], [4, 5], [4, 2], [24, 1], [24, 3], [25, 3], [25, 1], [26, 3], [27, 3], [27, 1], [6, 4], [6, 5], [6, 5], [6, 5], [6, 2], [7, 4], [7, 5], [7, 5], [7, 5], [7, 2], [8, 4], [8, 5], [8, 5], [8, 5], [8, 2], [9, 4], [9, 5], [9, 5], [9, 5], [9, 2], [10, 4], [10, 5], [10, 5], [10, 5], [10, 2]],
performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate, $, _$) {
var $0 = $.length - 1;
switch (yystate) {
case 1:
return $[$0 - 1];
break;
case 2:
return $[$0 - 1];
break;
case 3:
return $[$0 - 1];
break;
case 4:
return $[$0 - 1];
break;
case 5:
return $[$0 - 1];
break;
case 6:
return $[$0 - 1];
break;
case 7:
this.$ = new PointArray([Number($[$0 - 1]), Number($[$0])]);
break;
case 8:
this.$ = new PointArray([Number($[$0 - 2]), Number($[$0 - 1]), Number($[$0])]);
break;
case 9:
this.$ = new PointArray([Number($[$0 - 3]), Number($[$0 - 2]), Number($[$0 - 1]), Number($[$0])]);
break;
case 10:
this.$ = $[$0 - 2].addPoint($[$0]);
break;
case 11:
this.$ = $[$0];
break;
case 12:
this.$ = $[$0 - 2].addRing($[$0]);
break;
case 13:
this.$ = new RingList($[$0]);
break;
case 14:
this.$ = new Ring($[$0 - 1]);
break;
case 15:
this.$ = { "type": "Point", "coordinates": $[$0 - 1].data[0] };
break;
case 16:
this.$ = { "type": "Point", "coordinates": $[$0 - 1].data[0], "properties": { z: true } };
break;
case 17:
this.$ = { "type": "Point", "coordinates": $[$0 - 1].data[0], "properties": { z: true, m: true } };
break;
case 18:
this.$ = { "type": "Point", "coordinates": $[$0 - 1].data[0], "properties": { m: true } };
break;
case 19:
this.$ = { "type": "Point", "coordinates": [] };
break;
case 20:
this.$ = $[$0];
break;
case 21:
this.$ = $[$0 - 1];
break;
case 22:
this.$ = $[$0 - 2].addPolygon($[$0]);
break;
case 23:
this.$ = new PolygonList($[$0]);
break;
case 24:
this.$ = $[$0 - 1];
break;
case 25:
this.$ = $[$0 - 2].addPoint($[$0]);
break;
case 26:
this.$ = $[$0];
break;
case 27:
this.$ = { "type": "LineString", "coordinates": $[$0 - 1].data };
break;
case 28:
this.$ = { "type": "LineString", "coordinates": $[$0 - 1].data, "properties": { z: true } };
break;
case 29:
this.$ = { "type": "LineString", "coordinates": $[$0 - 1].data, "properties": { m: true } };
break;
case 30:
this.$ = { "type": "LineString", "coordinates": $[$0 - 1].data, "properties": { z: true, m: true } };
break;
case 31:
this.$ = { "type": "LineString", "coordinates": [] };
break;
case 32:
this.$ = { "type": "Polygon", "coordinates": $[$0 - 1].toJSON() };
break;
case 33:
this.$ = { "type": "Polygon", "coordinates": $[$0 - 1].toJSON(), "properties": { z: true } };
break;
case 34:
this.$ = { "type": "Polygon", "coordinates": $[$0 - 1].toJSON(), "properties": { m: true } };
break;
case 35:
this.$ = { "type": "Polygon", "coordinates": $[$0 - 1].toJSON(), "properties": { z: true, m: true } };
break;
case 36:
this.$ = { "type": "Polygon", "coordinates": [] };
break;
case 37:
this.$ = { "type": "MultiPoint", "coordinates": $[$0 - 1].data };
break;
case 38:
this.$ = { "type": "MultiPoint", "coordinates": $[$0 - 1].data, "properties": { z: true } };
break;
case 39:
this.$ = { "type": "MultiPoint", "coordinates": $[$0 - 1].data, "properties": { m: true } };
break;
case 40:
this.$ = { "type": "MultiPoint", "coordinates": $[$0 - 1].data, "properties": { z: true, m: true } };
break;
case 41:
this.$ = { "type": "MultiPoint", "coordinates": [] };
break;
case 42:
this.$ = { "type": "MultiLineString", "coordinates": $[$0 - 1].toJSON() };
break;
case 43:
this.$ = { "type": "MultiLineString", "coordinates": $[$0 - 1].toJSON(), "properties": { z: true } };
break;
case 44:
this.$ = { "type": "MultiLineString", "coordinates": $[$0 - 1].toJSON(), "properties": { m: true } };
break;
case 45:
this.$ = { "type": "MultiLineString", "coordinates": $[$0 - 1].toJSON(), "properties": { z: true, m: true } };
break;
case 46:
this.$ = { "type": "MultiLineString", "coordinates": [] };
break;
case 47:
this.$ = { "type": "MultiPolygon", "coordinates": $[$0 - 1].toJSON() };
break;
case 48:
this.$ = { "type": "MultiPolygon", "coordinates": $[$0 - 1].toJSON(), "properties": { z: true } };
break;
case 49:
this.$ = { "type": "MultiPolygon", "coordinates": $[$0 - 1].toJSON(), "properties": { m: true } };
break;
case 50:
this.$ = { "type": "MultiPolygon", "coordinates": $[$0 - 1].toJSON(), "properties": { z: true, m: true } };
break;
case 51:
this.$ = { "type": "MultiPolygon", "coordinates": [] };
break;
}
},
table: [{ 3: 1, 4: 2, 6: 3, 7: 4, 8: 5, 9: 6, 10: 7, 19: [1, 8], 28: [1, 9], 29: [1, 10], 30: [1, 11], 31: [1, 12], 32: [1, 13] }, { 1: [3] }, { 5: [1, 14] }, { 5: [1, 15] }, { 5: [1, 16] }, { 5: [1, 17] }, { 5: [1, 18] }, { 5: [1, 19] }, { 17: [1, 20], 20: [1, 21], 21: [1, 22], 22: [1, 23], 23: [1, 24] }, { 17: [1, 25], 20: [1, 26], 21: [1, 28], 22: [1, 27], 23: [1, 29] }, { 17: [1, 30], 20: [1, 31], 21: [1, 33], 22: [1, 32], 23: [1, 34] }, { 17: [1, 35], 20: [1, 36], 21: [1, 38], 22: [1, 37], 23: [1, 39] }, { 17: [1, 40], 20: [1, 41], 21: [1, 43], 22: [1, 42], 23: [1, 44] }, { 17: [1, 45], 20: [1, 46], 21: [1, 48], 22: [1, 47], 23: [1, 49] }, { 1: [2, 1] }, { 1: [2, 2] }, { 1: [2, 3] }, { 1: [2, 4] }, { 1: [2, 5] }, { 1: [2, 6] }, { 11: 51, 12: [1, 52], 13: 50 }, { 17: [1, 53] }, { 17: [1, 54] }, { 17: [1, 55] }, { 5: [2, 19] }, { 11: 58, 12: [1, 52], 17: [1, 59], 24: 57, 27: 56 }, { 17: [1, 60] }, { 17: [1, 61] }, { 17: [1, 62] }, { 5: [2, 31] }, { 15: 63, 16: 64, 17: [1, 65] }, { 17: [1, 66] }, { 17: [1, 67] }, { 17: [1, 68] }, { 5: [2, 36] }, { 11: 58, 12: [1, 52], 17: [1, 59], 24: 57, 27: 69 }, { 17: [1, 70] }, { 17: [1, 71] }, { 17: [1, 72] }, { 5: [2, 41] }, { 15: 73, 16: 64, 17: [1, 65] }, { 17: [1, 74] }, { 17: [1, 75] }, { 17: [1, 76] }, { 5: [2, 46] }, { 17: [1, 79], 25: 77, 26: 78 }, { 17: [1, 80] }, { 17: [1, 81] }, { 17: [1, 82] }, { 5: [2, 51] }, { 14: [1, 84], 18: [1, 83] }, { 14: [2, 11], 18: [2, 11] }, { 12: [1, 85] }, { 11: 51, 12: [1, 52], 13: 86 }, { 11: 51, 12: [1, 52], 13: 87 }, { 11: 51, 12: [1, 52], 13: 88 }, { 14: [1, 90], 18: [1, 89] }, { 14: [2, 26], 18: [2, 26] }, { 14: [2, 20], 18: [2, 20] }, { 11: 91, 12: [1, 52] }, { 11: 58, 12: [1, 52], 17: [1, 59], 24: 57, 27: 92 }, { 11: 58, 12: [1, 52], 17: [1, 59], 24: 57, 27: 93 }, { 11: 58, 12: [1, 52], 17: [1, 59], 24: 57, 27: 94 }, { 14: [1, 96], 18: [1, 95] }, { 14: [2, 13], 18: [2, 13] }, { 11: 51, 12: [1, 52], 13: 97 }, { 15: 98, 16: 64, 17: [1, 65] }, { 15: 99, 16: 64, 17: [1, 65] }, { 15: 100, 16: 64, 17: [1, 65] }, { 14: [1, 90], 18: [1, 101] }, { 11: 58, 12: [1, 52], 17: [1, 59], 24: 57, 27: 102 }, { 11: 58, 12: [1, 52], 17: [1, 59], 24: 57, 27: 103 }, { 11: 58, 12: [1, 52], 17: [1, 59], 24: 57, 27: 104 }, { 14: [1, 96], 18: [1, 105] }, { 15: 106, 16: 64, 17: [1, 65] }, { 15: 107, 16: 64, 17: [1, 65] }, { 15: 108, 16: 64, 17: [1, 65] }, { 14: [1, 110], 18: [1, 109] }, { 14: [2, 23], 18: [2, 23] }, { 15: 111, 16: 64, 17: [1, 65] }, { 17: [1, 79], 25: 112, 26: 78 }, { 17: [1, 79], 25: 113, 26: 78 }, { 17: [1, 79], 25: 114, 26: 78 }, { 5: [2, 15] }, { 11: 115, 12: [1, 52] }, { 12: [1, 116], 14: [2, 7], 18: [2, 7] }, { 14: [1, 84], 18: [1, 117] }, { 14: [1, 84], 18: [1, 118] }, { 14: [1, 84], 18: [1, 119] }, { 5: [2, 27] }, { 11: 58, 12: [1, 52], 17: [1, 59], 24: 120 }, { 18: [1, 121] }, { 14: [1, 90], 18: [1, 122] }, { 14: [1, 90], 18: [1, 123] }, { 14: [1, 90], 18: [1, 124] }, { 5: [2, 32] }, { 16: 125, 17: [1, 65] }, { 14: [1, 84], 18: [1, 126] }, { 14: [1, 96], 18: [1, 127] }, { 14: [1, 96], 18: [1, 128] }, { 14: [1, 96], 18: [1, 129] }, { 5: [2, 37] }, { 14: [1, 90], 18: [1, 130] }, { 14: [1, 90], 18: [1, 131] }, { 14: [1, 90], 18: [1, 132] }, { 5: [2, 42] }, { 14: [1, 96], 18: [1, 133] }, { 14: [1, 96], 18: [1, 134] }, { 14: [1, 96], 18: [1, 135] }, { 5: [2, 47] }, { 17: [1, 79], 26: 136 }, { 14: [1, 96], 18: [1, 137] }, { 14: [1, 110], 18: [1, 138] }, { 14: [1, 110], 18: [1, 139] }, { 14: [1, 110], 18: [1, 140] }, { 14: [2, 10], 18: [2, 10] }, { 12: [1, 141], 14: [2, 8], 18: [2, 8] }, { 5: [2, 16] }, { 5: [2, 17] }, { 5: [2, 18] }, { 14: [2, 25], 18: [2, 25] }, { 14: [2, 21], 18: [2, 21] }, { 5: [2, 28] }, { 5: [2, 29] }, { 5: [2, 30] }, { 14: [2, 12], 18: [2, 12] }, { 14: [2, 14], 18: [2, 14] }, { 5: [2, 33] }, { 5: [2, 34] }, { 5: [2, 35] }, { 5: [2, 38] }, { 5: [2, 39] }, { 5: [2, 40] }, { 5: [2, 43] }, { 5: [2, 44] }, { 5: [2, 45] }, { 14: [2, 22], 18: [2, 22] }, { 14: [2, 24], 18: [2, 24] }, { 5: [2, 48] }, { 5: [2, 49] }, { 5: [2, 50] }, { 14: [2, 9], 18: [2, 9] }],
defaultActions: { 14: [2, 1], 15: [2, 2], 16: [2, 3], 17: [2, 4], 18: [2, 5], 19: [2, 6], 24: [2, 19], 29: [2, 31], 34: [2, 36], 39: [2, 41], 44: [2, 46], 49: [2, 51], 83: [2, 15], 89: [2, 27], 95: [2, 32], 101: [2, 37], 105: [2, 42], 109: [2, 47], 117: [2, 16], 118: [2, 17], 119: [2, 18], 122: [2, 28], 123: [2, 29], 124: [2, 30], 127: [2, 33], 128: [2, 34], 129: [2, 35], 130: [2, 38], 131: [2, 39], 132: [2, 40], 133: [2, 43], 134: [2, 44], 135: [2, 45], 138: [2, 48], 139: [2, 49], 140: [2, 50] },
parseError: function parseError(str, hash) {
throw new Error(str);
},
parse: function parse2(input) {
var self = this, stack = [0], vstack = [null], lstack = [], table = this.table, yytext = "", yylineno = 0, yyleng = 0, recovering = 0, TERROR = 2, EOF = 1;
this.lexer.setInput(input);
this.lexer.yy = this.yy;
this.yy.lexer = this.lexer;
this.yy.parser = this;
if (typeof this.lexer.yylloc == "undefined")
this.lexer.yylloc = {};
var yyloc = this.lexer.yylloc;
lstack.push(yyloc);
var ranges = this.lexer.options && this.lexer.options.ranges;
if (typeof this.yy.parseError === "function")
this.parseError = this.yy.parseError;
function popStack(n) {
stack.length = stack.length - 2 * n;
vstack.length = vstack.length - n;
lstack.length = lstack.length - n;
}
function lex() {
var token;
token = self.lexer.lex() || 1;
if (typeof token !== "number") {
token = self.symbols_[token] || token;
}
return token;
}
var symbol, preErrorSymbol, state, action, a, r, yyval = {}, p, len, newState, expected;
while (true) {
state = stack[stack.length - 1];
if (this.defaultActions[state]) {
action = this.defaultActions[state];
} else {
if (symbol === null || typeof symbol == "undefined") {
symbol = lex();
}
action = table[state] && table[state][symbol];
}
if (typeof action === "undefined" || !action.length || !action[0]) {
var errStr = "";
if (!recovering) {
expected = [];
for (p in table[state])
if (this.terminals_[p] && p > 2) {
expected.push("'" + this.terminals_[p] + "'");
}
if (this.lexer.showPosition) {
errStr = "Parse error on line " + (yylineno + 1) + ":\n" + this.lexer.showPosition() + "\nExpecting " + expected.join(", ") + ", got '" + (this.terminals_[symbol] || symbol) + "'";
} else {
errStr = "Parse error on line " + (yylineno + 1) + ": Unexpected " + (symbol == 1 ? "end of input" : "'" + (this.terminals_[symbol] || symbol) + "'");
}
this.parseError(errStr, { text: this.lexer.match, token: this.terminals_[symbol] || symbol, line: this.lexer.yylineno, loc: yyloc, expected });
}
}
if (action[0] instanceof Array && action.length > 1) {
throw new Error("Parse Error: multiple actions possible at state: " + state + ", token: " + symbol);
}
switch (action[0]) {
case 1:
stack.push(symbol);
vstack.push(this.lexer.yytext);
lstack.push(this.lexer.yylloc);
stack.push(action[1]);
symbol = null;
if (!preErrorSymbol) {
yyleng = this.lexer.yyleng;
yytext = this.lexer.yytext;
yylineno = this.lexer.yylineno;
yyloc = this.lexer.yylloc;
if (recovering > 0)
recovering--;
} else {
symbol = preErrorSymbol;
preErrorSymbol = null;
}
break;
case 2:
len = this.productions_[action[1]][1];
yyval.$ = vstack[vstack.length - len];
yyval._$ = { first_line: lstack[lstack.length - (len || 1)].first_line, last_line: lstack[lstack.length - 1].last_line, first_column: lstack[lstack.length - (len || 1)].first_column, last_column: lstack[lstack.length - 1].last_column };
if (ranges) {
yyval._$.range = [lstack[lstack.length - (len || 1)].range[0], lstack[lstack.length - 1].range[1]];
}
r = this.performAction.call(yyval, yytext, yyleng, yylineno, this.yy, action[1], vstack, lstack);
if (typeof r !== "undefined") {
return r;
}
if (len) {
stack = stack.slice(0, -1 * len * 2);
vstack = vstack.slice(0, -1 * len);
lstack = lstack.slice(0, -1 * len);
}
stack.push(this.productions_[action[1]][0]);
vstack.push(yyval.$);
lstack.push(yyval._$);
newState = table[stack[stack.length - 2]][stack[stack.length - 1]];
stack.push(newState);
break;
case 3:
return true;
}
}
return true;
}
};
var lexer = function() {
var lexer2 = {
EOF: 1,
parseError: function parseError(str, hash) {
if (this.yy.parser) {
this.yy.parser.parseError(str, hash);
} else {
throw new Error(str);
}
},
setInput: function(input) {
this._input = input;
this._more = this._less = this.done = false;
this.yylineno = this.yyleng = 0;
this.yytext = this.matched = this.match = "";
this.conditionStack = ["INITIAL"];
this.yylloc = { first_line: 1, first_column: 0, last_line: 1, last_column: 0 };
if (this.options.ranges)
this.yylloc.range = [0, 0];
this.offset = 0;
return this;
},
input: function() {
var ch = this._input[0];
this.yytext += ch;
this.yyleng++;
this.offset++;
this.match += ch;
this.matched += ch;
var lines = ch.match(/(?:\r\n?|\n).*/g);
if (lines) {
this.yylineno++;
this.yylloc.last_line++;
} else {
this.yylloc.last_column++;
}
if (this.options.ranges)
this.yylloc.range[1]++;
this._input = this._input.slice(1);
return ch;
},
unput: function(ch) {
var len = ch.length;
var lines = ch.split(/(?:\r\n?|\n)/g);
this._input = ch + this._input;
this.yytext = this.yytext.substr(0, this.yytext.length - len - 1);
this.offset -= len;
var oldLines = this.match.split(/(?:\r\n?|\n)/g);
this.match = this.match.substr(0, this.match.length - 1);
this.matched = this.matched.substr(0, this.matched.length - 1);
if (lines.length - 1)
this.yylineno -= lines.length - 1;
var r = this.yylloc.range;
this.yylloc = {
first_line: this.yylloc.first_line,
last_line: this.yylineno + 1,
first_column: this.yylloc.first_column,
last_column: lines ? (lines.length === oldLines.length ? this.yylloc.first_column : 0) + oldLines[oldLines.length - lines.length].length - lines[0].length : this.yylloc.first_column - len
};
if (this.options.ranges) {
this.yylloc.range = [r[0], r[0] + this.yyleng - len];
}
return this;
},
more: function() {
this._more = true;
return this;
},
less: function(n) {
this.unput(this.match.slice(n));
},
pastInput: function() {
var past = this.matched.substr(0, this.matched.length - this.match.length);
return (past.length > 20 ? "..." : "") + past.substr(-20).replace(/\n/g, "");
},
upcomingInput: function() {
var next = this.match;
if (next.length < 20) {
next += this._input.substr(0, 20 - next.length);
}
return (next.substr(0, 20) + (next.length > 20 ? "..." : "")).replace(/\n/g, "");
},
showPosition: function() {
var pre = this.pastInput();
var c = new Array(pre.length + 1).join("-");
return pre + this.upcomingInput() + "\n" + c + "^";
},
next: function() {
if (this.done) {
return this.EOF;
}
if (!this._input)
this.done = true;
var token, match, tempMatch, index, col, lines;
if (!this._more) {
this.yytext = "";
this.match = "";
}
var rules = this._currentRules();
for (var i2 = 0; i2 < rules.length; i2++) {
tempMatch = this._input.match(this.rules[rules[i2]]);
if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {
match = tempMatch;
index = i2;
if (!this.options.flex)
break;
}
}
if (match) {
lines = match[0].match(/(?:\r\n?|\n).*/g);
if (lines)
this.yylineno += lines.length;
this.yylloc = {
first_line: this.yylloc.last_line,
last_line: this.yylineno + 1,
first_column: this.yylloc.last_column,
last_column: lines ? lines[lines.length - 1].length - lines[lines.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + match[0].length
};
this.yytext += match[0];
this.match += match[0];
this.matches = match;
this.yyleng = this.yytext.length;
if (this.options.ranges) {
this.yylloc.range = [this.offset, this.offset += this.yyleng];
}
this._more = false;
this._input = this._input.slice(match[0].length);
this.matched += match[0];
token = this.performAction.call(this, this.yy, this, rules[index], this.conditionStack[this.conditionStack.length - 1]);
if (this.done && this._input)
this.done = false;
if (token)
return token;
else
return;
}
if (this._input === "") {
return this.EOF;
} else {
return this.parseError(
"Lexical error on line " + (this.yylineno + 1) + ". Unrecognized text.\n" + this.showPosition(),
{ text: "", token: null, line: this.yylineno }
);
}
},
lex: function lex() {
var r = this.next();
if (typeof r !== "undefined") {
return r;
} else {
return this.lex();
}
},
begin: function begin(condition) {
this.conditionStack.push(condition);
},
popState: function popState() {
return this.conditionStack.pop();
},
_currentRules: function _currentRules() {
return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules;
},
topState: function() {
return this.conditionStack[this.conditionStack.length - 2];
},
pushState: function begin(condition) {
this.begin(condition);
}
};
lexer2.options = {};
lexer2.performAction = function anonymous(yy, yy_, $avoiding_name_collisions, YY_START) {
var YYSTATE = YY_START;
switch ($avoiding_name_collisions) {
case 0:
break;
case 1:
return 17;
break;
case 2:
return 18;
break;
case 3:
return 12;
break;
case 4:
return 19;
break;
case 5:
return 28;
break;
case 6:
return 29;
break;
case 7:
return 30;
break;
case 8:
return 31;
break;
case 9:
return 32;
break;
case 10:
return 14;
break;
case 11:
return 23;
break;
case 12:
return 22;
break;
case 13:
return 20;
break;
case 14:
return 21;
break;
case 15:
return 5;
break;
case 16:
return "INVALID";
break;
}
};
lexer2.rules = [/^(?:\s+)/, /^(?:\()/, /^(?:\))/, /^(?:-?[0-9]+(\.[0-9]+)?([eE][\-\+]?[0-9]+)?)/, /^(?:POINT\b)/, /^(?:LINESTRING\b)/, /^(?:POLYGON\b)/, /^(?:MULTIPOINT\b)/, /^(?:MULTILINESTRING\b)/, /^(?:MULTIPOLYGON\b)/, /^(?:,)/, /^(?:EMPTY\b)/, /^(?:M\b)/, /^(?:Z\b)/, /^(?:ZM\b)/, /^(?:$)/, /^(?:.)/];
lexer2.conditions = { "INITIAL": { "rules": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], "inclusive": true } };
return lexer2;
}();
parser2.lexer = lexer;
function Parser() {
this.yy = {};
}
Parser.prototype = parser2;
parser2.Parser = Parser;
return new Parser();
}();
function PointArray(point) {
this.data = [point];
this.type = "PointArray";
}
PointArray.prototype.addPoint = function(point) {
if (point.type === "PointArray") {
this.data = this.data.concat(point.data);
} else {
this.data.push(point);
}
return this;
};
PointArray.prototype.toJSON = function() {
return this.data;
};
function Ring(point) {
this.data = point;
this.type = "Ring";
}
Ring.prototype.toJSON = function() {
var data = [];
for (var i2 = 0; i2 < this.data.data.length; i2++) {
data.push(this.data.data[i2]);
}
return data;
};
function RingList(ring) {
this.data = [ring];
this.type = "RingList";
}
RingList.prototype.addRing = function(ring) {
this.data.push(ring);
return this;
};
RingList.prototype.toJSON = function() {
var data = [];
for (var i2 = 0; i2 < this.data.length; i2++) {
data.push(this.data[i2].toJSON());
}
if (data.length === 1) {
return data;
} else {
return data;
}
};
function PolygonList(polygon) {
this.data = [polygon];
this.type = "PolygonList";
}
PolygonList.prototype.addPolygon = function(polygon) {
this.data.push(polygon);
return this;
};
PolygonList.prototype.toJSON = function() {
var data = [];
for (var i2 = 0; i2 < this.data.length; i2++) {
data = data.concat([this.data[i2].toJSON()]);
}
return data;
};
function _parse() {
return parser.parse.apply(parser, arguments);
}
function parse(element) {
var res, primitive;
try {
res = parser.parse(element);
} catch (err) {
throw Error("Unable to parse: " + err);
}
return Terraformer.Primitive(res);
}
function arrayToRing(arr) {
var parts = [], ret = "";
for (var i2 = 0; i2 < arr.length; i2++) {
parts.push(arr[i2].join(" "));
}
ret += "(" + parts.join(", ") + ")";
return ret;
}
function pointToWKTPoint(primitive) {
var ret = "POINT ";
if (primitive.coordinates === void 0 || primitive.coordinates.length === 0) {
ret += "EMPTY";
return ret;
} else if (primitive.coordinates.length === 3) {
if (primitive.properties && primitive.properties.m === true) {
ret += "M ";
} else {
ret += "Z ";
}
} else if (primitive.coordinates.length === 4) {
ret += "ZM ";
}
ret += "(" + primitive.coordinates.join(" ") + ")";
return ret;
}
function lineStringToWKTLineString(primitive) {
var ret = "LINESTRING ";
if (primitive.coordinates === void 0 || primitive.coordinates.length === 0 || primitive.coordinates[0].length === 0) {
ret += "EMPTY";
return ret;
} else if (primitive.coordinates[0].length === 3) {
if (primitive.properties && primitive.properties.m === true) {
ret += "M ";
} else {
ret += "Z ";
}
} else if (primitive.coordinates[0].length === 4) {
ret += "ZM ";
}
ret += arrayToRing(primitive.coordinates);
return ret;
}
function polygonToWKTPolygon(primitive) {
var ret = "POLYGON ";
if (primitive.coordinates === void 0 || primitive.coordinates.length === 0 || primitive.coordinates[0].length === 0) {
ret += "EMPTY";
return ret;
} else if (primitive.coordinates[0][0].length === 3) {
if (primitive.properties && primitive.properties.m === true) {
ret += "M ";
} else {
ret += "Z ";
}
} else if (primitive.coordinates[0][0].length === 4) {
ret += "ZM ";
}
ret += "(";
var parts = [];
for (var i2 = 0; i2 < primitive.coordinates.length; i2++) {
parts.push(arrayToRing(primitive.coordinates[i2]));
}
ret += parts.join(", ");
ret += ")";
return ret;
}
function multiPointToWKTMultiPoint(primitive) {
var ret = "MULTIPOINT ";
if (primitive.coordinates === void 0 || primitive.coordinates.length === 0 || primitive.coordinates[0].length === 0) {
ret += "EMPTY";
return ret;
} else if (primitive.coordinates[0].length === 3) {
if (primitive.properties && primitive.properties.m === true) {
ret += "M ";
} else {
ret += "Z ";
}
} else if (primitive.coordinates[0].length === 4) {
ret += "ZM ";
}
ret += arrayToRing(primitive.coordinates);
return ret;
}
function multiLineStringToWKTMultiLineString(primitive) {
var ret = "MULTILINESTRING ";
if (primitive.coordinates === void 0 || primitive.coordinates.length === 0 || primitive.coordinates[0].length === 0) {
ret += "EMPTY";
return ret;
} else if (primitive.coordinates[0][0].length === 3) {
if (primitive.properties && primitive.properties.m === true) {
ret += "M ";
} else {
ret += "Z ";
}
} else if (primitive.coordinates[0][0].length === 4) {
ret += "ZM ";
}
ret += "(";
var parts = [];
for (var i2 = 0; i2 < primitive.coordinates.length; i2++) {
parts.push(arrayToRing(primitive.coordinates[i2]));
}
ret += parts.join(", ");
ret += ")";
return ret;
}
function multiPolygonToWKTMultiPolygon(primitive) {
var ret = "MULTIPOLYGON ";
if (primitive.coordinates === void 0 || primitive.coordinates.length === 0 || primitive.coordinates[0].length === 0 || primitive.coordinates[0][0].length === 0) {
ret += "EMPTY";
return ret;
} else if (primitive.coordinates[0][0][0].length === 3) {
if (primitive.properties && primitive.properties.m === true) {
ret += "M ";
} else {
ret += "Z ";
}
} else if (primitive.coordinates[0][0][0].length === 4) {
ret += "ZM ";
}
ret += "(";
var inner = [];
for (var c = 0; c < primitive.coordinates.length; c++) {
var it = "(";
var parts = [];
for (var i2 = 0; i2 < primitive.coordinates[c].length; i2++) {
parts.push(arrayToRing(primitive.coordinates[c][i2]));
}
it += parts.join(", ");
it += ")";
inner.push(it);
}
ret += inner.join(", ");
ret += ")";
return ret;
}
function convert(primitive) {
switch (primitive.type) {
case "Point":
return pointToWKTPoint(primitive);
case "LineString":
return lineStringToWKTLineString(primitive);
case "Polygon":
return polygonToWKTPolygon(primitive);
case "MultiPoint":
return multiPointToWKTMultiPoint(primitive);
case "MultiLineString":
return multiLineStringToWKTMultiLineString(primitive);
case "MultiPolygon":
return multiPolygonToWKTMultiPolygon(primitive);
case "GeometryCollection":
var ret = "GEOMETRYCOLLECTION";
var parts = [];
for (i = 0; i < primitive.geometries.length; i++) {
parts.push(convert(primitive.geometries[i]));
}
return ret + "(" + parts.join(", ") + ")";
default:
throw Error("Unknown Type: " + primitive.type);
}
}
exports2.parser = parser;
exports2.Parser = parser.Parser;
exports2.parse = parse;
exports2.convert = convert;
return exports2;
});
}
});
export default require_terraformer_wkt_parser();
//# sourceMappingURL=terraformer-wkt-parser.js.map
