@theseam/ui-common 0.2.17 → 0.3.2

package/esm2015/utils/geo-json/is-only-geometry-types.js

@@ -0,0 +1,23 @@
+/**
+ * Returns true if the GeoJSON is only specifies geometries.
+ */
+export function isOnlyGeometryTypes(featureCollection, types) {
+    if (types.length === 0) {
+        if (featureCollection.features.length > 0) {
+            // If no types are specified then there can't be any specified types found.
+            return false;
+        }
+        else {
+            // If no types are specified and there are no features then there is
+            // nothing to say a specified type isn't found.
+            return true;
+        }
+    }
+    for (const f of featureCollection.features) {
+        if (types.indexOf(f.geometry.type) === -1) {
+            return false;
+        }
+    }
+    return true;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXMtb25seS1nZW9tZXRyeS10eXBlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3VpLWNvbW1vbi91dGlscy9nZW8tanNvbi9pcy1vbmx5LWdlb21ldHJ5LXR5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBOztHQUVHO0FBQ0gsTUFBTSxVQUFVLG1CQUFtQixDQUFDLGlCQUFvQyxFQUFFLEtBQXlCO0lBQ2pHLElBQUksS0FBSyxDQUFDLE1BQU0sS0FBSyxDQUFDLEVBQUU7UUFDdEIsSUFBSSxpQkFBaUIsQ0FBQyxRQUFRLENBQUMsTUFBTSxHQUFHLENBQUMsRUFBRTtZQUN6QywyRUFBMkU7WUFDM0UsT0FBTyxLQUFLLENBQUE7U0FDYjthQUFNO1lBQ0wsb0VBQW9FO1lBQ3BFLCtDQUErQztZQUMvQyxPQUFPLElBQUksQ0FBQTtTQUNaO0tBQ0Y7SUFFRCxLQUFLLE1BQU0sQ0FBQyxJQUFJLGlCQUFpQixDQUFDLFFBQVEsRUFBRTtRQUMxQyxJQUFJLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsRUFBRTtZQUN6QyxPQUFPLEtBQUssQ0FBQTtTQUNiO0tBQ0Y7SUFFRCxPQUFPLElBQUksQ0FBQTtBQUNiLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBGZWF0dXJlQ29sbGVjdGlvbiwgR2VvbWV0cnkgfSBmcm9tICdnZW9qc29uJ1xyXG5cclxuLyoqXHJcbiAqIFJldHVybnMgdHJ1ZSBpZiB0aGUgR2VvSlNPTiBpcyBvbmx5IHNwZWNpZmllcyBnZW9tZXRyaWVzLlxyXG4gKi9cclxuZXhwb3J0IGZ1bmN0aW9uIGlzT25seUdlb21ldHJ5VHlwZXMoZmVhdHVyZUNvbGxlY3Rpb246IEZlYXR1cmVDb2xsZWN0aW9uLCB0eXBlczogR2VvbWV0cnlbJ3R5cGUnXVtdKTogYm9vbGVhbiB7XHJcbiAgaWYgKHR5cGVzLmxlbmd0aCA9PT0gMCkge1xyXG4gICAgaWYgKGZlYXR1cmVDb2xsZWN0aW9uLmZlYXR1cmVzLmxlbmd0aCA+IDApIHtcclxuICAgICAgLy8gSWYgbm8gdHlwZXMgYXJlIHNwZWNpZmllZCB0aGVuIHRoZXJlIGNhbid0IGJlIGFueSBzcGVjaWZpZWQgdHlwZXMgZm91bmQuXHJcbiAgICAgIHJldHVybiBmYWxzZVxyXG4gICAgfSBlbHNlIHtcclxuICAgICAgLy8gSWYgbm8gdHlwZXMgYXJlIHNwZWNpZmllZCBhbmQgdGhlcmUgYXJlIG5vIGZlYXR1cmVzIHRoZW4gdGhlcmUgaXNcclxuICAgICAgLy8gbm90aGluZyB0byBzYXkgYSBzcGVjaWZpZWQgdHlwZSBpc24ndCBmb3VuZC5cclxuICAgICAgcmV0dXJuIHRydWVcclxuICAgIH1cclxuICB9XHJcblxyXG4gIGZvciAoY29uc3QgZiBvZiBmZWF0dXJlQ29sbGVjdGlvbi5mZWF0dXJlcykge1xyXG4gICAgaWYgKHR5cGVzLmluZGV4T2YoZi5nZW9tZXRyeS50eXBlKSA9PT0gLTEpIHtcclxuICAgICAgcmV0dXJuIGZhbHNlXHJcbiAgICB9XHJcbiAgfVxyXG5cclxuICByZXR1cm4gdHJ1ZVxyXG59XHJcbiJdfQ==

package/esm2015/utils/geo-json/is-only-geometry-types.validator.js

@@ -0,0 +1,32 @@
+import { isEmptyInputValue } from '../form/is-empty-input-value';
+import { coerceFeatureCollection } from './coerce-feature-collection';
+import { isOnlyGeometryTypes } from './is-only-geometry-types';
+export const IS_ONLY_GEOMETRY_TYPES_VALIDATOR_NAME = 'is-only-geometry-types';
+export function isOnlyGeometryTypesValidator(types) {
+    return (control) => {
+        // Don't need to validate if there isn't a value. Use `Validators.required` for that.
+        if (isEmptyInputValue(control.value)) {
+            return null; // don't validate empty values to allow optional controls
+        }
+        const value = coerceFeatureCollection(control.value);
+        if (value === null) {
+            // If there isn't a FeatureCollection then there is nothing to validate.
+            // Use 'isFeatureCollection' to validate the value is a FeatureCollection.
+            return null;
+        }
+        if (!isOnlyGeometryTypes(value, types)) {
+            const typesNotAllowed = value.features
+                .map(f => f.geometry.type)
+                .filter(t => types.indexOf(t) === -1);
+            const distinctTypesNotAllowed = Array.from(new Set(typesNotAllowed));
+            return {
+                [IS_ONLY_GEOMETRY_TYPES_VALIDATOR_NAME]: {
+                    reason: `Only geometry type${(types.length === 1 ? '' : 's')} ${types.join(', ')} allowed.`,
+                    notAllowedGeometryTypesFound: distinctTypesNotAllowed,
+                }
+            };
+        }
+        return null;
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/utils/geo-json/merge-polygons.js

@@ -0,0 +1,35 @@
+/**
+ * Merge Polygon and MultiPolygon geometries into a single MultiPolygon. Any
+ * properties, other than 'coordinates', of the Polygons and MultiPolygons will
+ * be lost.
+ *
+ * NOTE: Polygons and MultPolygons in a GeometryCollection will not be merged.
+ */
+export function mergePolygons(featureCollection) {
+    const multiPolygon = {
+        type: 'MultiPolygon',
+        coordinates: [],
+    };
+    for (let i = 0; i < featureCollection.features.length; i++) {
+        const f = featureCollection.features[i];
+        if (f.geometry.type === 'Polygon') {
+            multiPolygon.coordinates.push(f.geometry.coordinates);
+            featureCollection.features.splice(i, 1);
+            i--;
+        }
+        else if (f.geometry.type === 'MultiPolygon') {
+            multiPolygon.coordinates.push(...f.geometry.coordinates);
+            featureCollection.features.splice(i, 1);
+            i--;
+        }
+    }
+    if (multiPolygon.coordinates.length > 0) {
+        const feature = {
+            type: 'Feature',
+            geometry: multiPolygon,
+            properties: {},
+        };
+        featureCollection.features.push(feature);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/utils/geo-json/no-inner-rings.validator.js

@@ -0,0 +1,63 @@
+import { isEmptyInputValue } from '../form/is-empty-input-value';
+import { coerceFeatureCollection } from './coerce-feature-collection';
+export const NO_INNER_RINGS_VALIDATOR_NAME = 'no-inner-rings';
+/**
+ * Validates that a FeatureCollection does not contain any Polygon with inner
+ * rings("holes").
+ *
+ * NOTE: Only considers Polygon and MultiPolygon. Does not consider
+ * GeometryCollection.
+ */
+export function noInnerRingsValidator() {
+    return (control) => {
+        // Don't need to validate if there isn't a value. Use `Validators.required` for that.
+        if (isEmptyInputValue(control.value)) {
+            return null; // don't validate empty values to allow optional controls
+        }
+        const value = coerceFeatureCollection(control.value);
+        if (value === null) {
+            // If there isn't a FeatureCollection then there is nothing to validate.
+            // Use 'isFeatureCollection' to validate the value is a FeatureCollection.
+            return null;
+        }
+        if (hasInnerRing(value)) {
+            return {
+                [NO_INNER_RINGS_VALIDATOR_NAME]: {
+                    reason: `A shape cannot have an inner ring.`
+                }
+            };
+        }
+        return null;
+    };
+}
+/**
+ * Checks if a FeatureCollection contains any geometries with an inner
+ * ring("hole").
+ *
+ * NOTE: Does not consider GeometryCollection.
+ */
+function hasInnerRing(featureCollection) {
+    for (const f of featureCollection.features) {
+        // The spec says the right-hand rule must be followed, but also specifies
+        // that tools should not reject polygons that do not follow the right-hand
+        // rule. It does specify that the first ring must be the exterior ring and
+        // the others must be the interior. So, this should be safe to just check
+        // if there are multiple rings, instead of checking their winding orders.
+        //
+        // Polygon spec: https://datatracker.ietf.org/doc/html/rfc7946#section-3.1.6
+        if (f.geometry.type === 'Polygon') {
+            if (f.geometry.coordinates.length > 1) {
+                return true;
+            }
+        }
+        else if (f.geometry.type === 'MultiPolygon') {
+            for (const coords of f.geometry.coordinates) {
+                if (coords.length > 1) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/utils/geo-json/no-kinks.validator.js

@@ -0,0 +1,39 @@
+import kinks from '@turf/kinks';
+import { isEmptyInputValue } from '../form/is-empty-input-value';
+import { coerceFeatureCollection } from './coerce-feature-collection';
+const kinkableGeometryTypes = ['LineString', 'MultiLineString', 'MultiPolygon', 'Polygon'];
+export const NO_KINKS_VALIDATOR_NAME = 'no-kinks';
+export function noKinksValidator() {
+    return (control) => {
+        // Don't need to validate if there isn't a value. Use `Validators.required` for that.
+        if (isEmptyInputValue(control.value)) {
+            return null; // don't validate empty values to allow optional controls
+        }
+        const value = coerceFeatureCollection(control.value);
+        if (value === null) {
+            return null;
+        }
+        const kinksFound = [];
+        for (const f of value.features) {
+            if (kinkableGeometryTypes.indexOf(f.geometry.type) !== -1) {
+                const _kinks = kinks(f);
+                if (_kinks.features.length > 0) {
+                    kinksFound.push({
+                        feature: f,
+                        kinks: _kinks,
+                    });
+                }
+            }
+        }
+        if (kinksFound.length > 0) {
+            return {
+                [NO_KINKS_VALIDATOR_NAME]: {
+                    reason: 'Paths should not intersect themself.',
+                    featuresWithKink: kinksFound,
+                }
+            };
+        }
+        return null;
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/utils/geo-json/read-geo-file.js

@@ -0,0 +1,99 @@
+import { __awaiter } from "tslib";
+import { isDevMode } from '@angular/core';
+import fileType from '@marklb/file-type';
+const Buffer = require('buffer/').Buffer;
+import shp from 'shpjs';
+import { readFileAsync } from '../file-utils';
+import { withoutProperty } from '../obj-utils';
+/**
+ * Reads a File, or buffer of file content, in GeoJSON or ESRI Shapefile format
+ * and returns a GeoJSON `FeatureCollection`.
+ */
+export function readGeoFile(fileOrBuffer) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        const buffer = yield coerceFileOrBufferToBuffer(fileOrBuffer);
+        if (isShpFile(buffer)) {
+            return yield parseShpFile(buffer);
+        }
+        else if (((_a = fileType(buffer)) === null || _a === void 0 ? void 0 : _a.mime) === 'application/zip') {
+            try {
+                return yield parseShpZip(buffer);
+            }
+            catch (e) {
+                // NOTE: If 'shpjs' updates or we switch to a fork, where it doesn't use
+                // node buffers, then we can remove this rethrow.
+                if (isDevMode()) {
+                    if (e.message === 'nodebuffer is not supported by this platform') {
+                        console.warn('Try adding Buffer polyfill.\n' +
+                            'Install: npm install buffer\n' +
+                            'Add `global.Buffer = global.Buffer || require(\'buffer\').Buffer` to "src/polyfills.ts"');
+                    }
+                }
+                throw e;
+            }
+        }
+        return parseGeoJson(buffer);
+    });
+}
+function coerceFileOrBufferToBuffer(fileOrBuffer) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (fileOrBuffer instanceof File) {
+            const arrBuf = yield readFileAsync(fileOrBuffer);
+            return Buffer.from(arrBuf);
+        }
+        return Buffer.from(fileOrBuffer);
+    });
+}
+// NOTE: Our current version of file-type does not detect shp files. We can
+// remove this function when file-types is upgraded.
+function isShpFile(buffer) {
+    const header = [0x27, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
+    const offset = 2;
+    if (buffer.length < (header.length + offset)) {
+        return false;
+    }
+    for (let i = 0; i < header.length; i++) {
+        if (header[i] !== buffer[i + offset]) {
+            return false;
+        }
+    }
+    return true;
+}
+function parseShpFile(buffer) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const geometries = yield shp.parseShp(buffer, undefined);
+        const featCollection = {
+            type: 'FeatureCollection',
+            features: geometries.map(geom => ({
+                type: 'Feature',
+                geometry: geom,
+                properties: {}
+            }))
+        };
+        return featCollection;
+    });
+}
+function parseShpZip(buffer) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let featCollection = yield shp.parseZip(buffer, undefined);
+        if (Array.isArray(featCollection)) {
+            if (featCollection.length === 0) {
+                throw Error(`Shape data not found.`);
+            }
+            else if (featCollection.length > 1) {
+                throw Error(`Multiple shape files not supported.`);
+            }
+            featCollection = featCollection[0];
+        }
+        return withoutProperty(featCollection, 'fileName');
+    });
+}
+function parseGeoJson(buffer) {
+    const json = JSON.parse(buffer.toString());
+    if ((json === null || json === void 0 ? void 0 : json.type) === 'FeatureCollection' && Array.isArray(json === null || json === void 0 ? void 0 : json.features)) {
+        return json;
+    }
+    throw Error(`Unable to parse as GeoJSON.`);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"read-geo-file.js","sourceRoot":"","sources":["../../../../../projects/ui-common/utils/geo-json/read-geo-file.ts"],"names":[],"mappings":"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","sourcesContent":["import { isDevMode } from '@angular/core'\nimport fileType from '@marklb/file-type'\nimport { FeatureCollection } from 'geojson'\nconst Buffer = require('buffer/').Buffer\nimport shp from 'shpjs'\n\nimport { readFileAsync } from '../file-utils'\nimport { withoutProperty } from '../obj-utils'\n\n/**\n * Reads a File, or buffer of file content, in GeoJSON or ESRI Shapefile format\n * and returns a GeoJSON `FeatureCollection`.\n */\nexport async function readGeoFile(fileOrBuffer: File | ArrayBuffer | Buffer): Promise<FeatureCollection> {\n  const buffer = await coerceFileOrBufferToBuffer(fileOrBuffer)\n\n  if (isShpFile(buffer)) {\n    return await parseShpFile(buffer)\n  } else if (fileType(buffer)?.mime === 'application/zip') {\n    try {\n      return await parseShpZip(buffer)\n    } catch (e) {\n      // NOTE: If 'shpjs' updates or we switch to a fork, where it doesn't use\n      // node buffers, then we can remove this rethrow.\n      if (isDevMode()) {\n        if (e.message === 'nodebuffer is not supported by this platform') {\n          console.warn(\n            'Try adding Buffer polyfill.\\n' +\n            'Install: npm install buffer\\n' +\n            'Add `global.Buffer = global.Buffer || require(\\'buffer\\').Buffer` to \"src/polyfills.ts\"'\n          )\n        }\n      }\n      throw e\n    }\n  }\n\n  return parseGeoJson(buffer)\n}\n\nasync function coerceFileOrBufferToBuffer(fileOrBuffer: File | ArrayBuffer | Buffer): Promise<Buffer> {\n  if (fileOrBuffer instanceof File) {\n    const arrBuf = await readFileAsync(fileOrBuffer)\n    return Buffer.from(arrBuf)\n  }\n\n  return Buffer.from(fileOrBuffer)\n}\n\n// NOTE: Our current version of file-type does not detect shp files. We can\n// remove this function when file-types is upgraded.\nfunction isShpFile(buffer: Buffer): boolean {\n  const header = [ 0x27, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ]\n  const offset = 2\n\n  if (buffer.length < (header.length + offset)) {\n    return false\n  }\n\n  for (let i = 0; i < header.length; i++) {\n    if (header[i] !== buffer[i + offset]) {\n      return false\n    }\n  }\n\n  return true\n}\n\nasync function parseShpFile(buffer: Buffer): Promise<FeatureCollection> {\n  const geometries = await shp.parseShp(buffer, undefined as any)\n  const featCollection: FeatureCollection = {\n    type: 'FeatureCollection',\n    features: geometries.map(geom => ({\n      type: 'Feature',\n      geometry: geom,\n      properties: { }\n    }))\n  }\n  return featCollection\n}\n\nasync function parseShpZip(buffer: Buffer): Promise<FeatureCollection> {\n  let featCollection = await shp.parseZip(buffer, undefined as any)\n  if (Array.isArray(featCollection)) {\n    if (featCollection.length === 0) {\n      throw Error(`Shape data not found.`)\n    } else if (featCollection.length > 1) {\n      throw Error(`Multiple shape files not supported.`)\n    }\n    featCollection = featCollection[0]\n  }\n  return withoutProperty(featCollection, 'fileName')\n}\n\nfunction parseGeoJson(buffer: Buffer): FeatureCollection {\n  const json = JSON.parse(buffer.toString())\n\n  if (json?.type === 'FeatureCollection' && Array.isArray(json?.features)) {\n    return json as FeatureCollection\n  }\n\n  throw Error(`Unable to parse as GeoJSON.`)\n}\n"]}

package/esm2015/utils/geo-json/split-multi-polygons.js

@@ -0,0 +1,29 @@
+/**
+ * Split all MultiPolygon into Polygon. Any properties, other than
+ * 'coordinates', of the MultiPolygons will be lost.
+ *
+ * NOTE: MultiPolygons in a GeometryCollection will not be split.
+ */
+export function splitMultiPolygons(featureCollection) {
+    for (let i = 0; i < featureCollection.features.length; i++) {
+        if (featureCollection.features[i]) {
+            const geometry = featureCollection.features[i].geometry;
+            if (geometry.type === 'MultiPolygon') {
+                const features = splitMultPolygon(geometry).map(p => ({
+                    type: 'Feature',
+                    geometry: p,
+                    properties: {},
+                }));
+                featureCollection.features.splice(i, 1, ...features);
+                i += Math.max(features.length - 1, 0);
+            }
+        }
+    }
+}
+function splitMultPolygon(multiPolygon) {
+    return multiPolygon.coordinates.map(c => ({
+        type: 'Polygon',
+        coordinates: c,
+    }));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/utils/is-null-or-undefined.js

@@ -1,4 +1,4 @@
 export function isNullOrUndefined(value) {
     return value === undefined || value === null;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXMtbnVsbC1vci11bmRlZmluZWQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy91aS1jb21tb24vdXRpbHMvaXMtbnVsbC1vci11bmRlZmluZWQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxVQUFVLGlCQUFpQixDQUFDLEtBQVU7SUFDMUMsT0FBTyxLQUFLLEtBQUssU0FBUyxJQUFJLEtBQUssS0FBSyxJQUFJLENBQUE7QUFDOUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBmdW5jdGlvbiBpc051bGxPclVuZGVmaW5lZCh2YWx1ZTogYW55KSB7XG4gIHJldHVybiB2YWx1ZSA9PT0gdW5kZWZpbmVkIHx8IHZhbHVlID09PSBudWxsXG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXMtbnVsbC1vci11bmRlZmluZWQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy91aS1jb21tb24vdXRpbHMvaXMtbnVsbC1vci11bmRlZmluZWQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxVQUFVLGlCQUFpQixDQUFJLEtBQTJCO0lBQzlELE9BQU8sS0FBSyxLQUFLLFNBQVMsSUFBSSxLQUFLLEtBQUssSUFBSSxDQUFBO0FBQzlDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZnVuY3Rpb24gaXNOdWxsT3JVbmRlZmluZWQ8VD4odmFsdWU6IFQgfCBudWxsIHwgdW5kZWZpbmVkKTogdmFsdWUgaXMgKG51bGwgfCB1bmRlZmluZWQpIHtcbiAgcmV0dXJuIHZhbHVlID09PSB1bmRlZmluZWQgfHwgdmFsdWUgPT09IG51bGxcbn1cbiJdfQ==

package/esm2015/utils/public-api.js

@@ -11,6 +11,16 @@ export * from './form/has-required-control';
 export * from './form/is-empty-input-value';
 export * from './operators/index';
 export * from './router/index';
+export * from './geo-json/coerce-feature-collection';
+export * from './geo-json/geo-json-to-area';
+export * from './geo-json/is-feature-collection.validator';
+export * from './geo-json/is-only-geometry-types';
+export * from './geo-json/is-only-geometry-types.validator';
+export * from './geo-json/merge-polygons';
+export * from './geo-json/no-inner-rings.validator';
+export * from './geo-json/no-kinks.validator';
+export * from './geo-json/read-geo-file';
+export * from './geo-json/split-multi-polygons';
 export * from './array-move';
 export * from './calc-percentage';
 export * from './toggle-attribute';
@@ -36,4 +46,4 @@ export * from './pad-start';
 export * from './create-padding';
 export * from './is-numeric';
 export * from './fractional-digits-count';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3VpLWNvbW1vbi91dGlscy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsbUNBQW1DLENBQUE7QUFFakQsY0FBYyx5QkFBeUIsQ0FBQTtBQUN2QyxjQUFjLHlCQUF5QixDQUFBO0FBQ3ZDLGNBQWMscUNBQXFDLENBQUE7QUFDbkQsY0FBYywrQkFBK0IsQ0FBQTtBQUM3QyxjQUFjLDhCQUE4QixDQUFBO0FBQzVDLGNBQWMscUNBQXFDLENBQUE7QUFDbkQsY0FBYyw4QkFBOEIsQ0FBQTtBQUM1QyxjQUFjLG1DQUFtQyxDQUFBO0FBQ2pELGNBQWMsNkJBQTZCLENBQUE7QUFDM0MsY0FBYyw2QkFBNkIsQ0FBQTtBQUUzQyxjQUFjLG1CQUFtQixDQUFBO0FBRWpDLGNBQWMsZ0JBQWdCLENBQUE7QUFFOUIsY0FBYyxjQUFjLENBQUE7QUFDNUIsY0FBYyxtQkFBbUIsQ0FBQTtBQUNqQyxjQUFjLG9CQUFvQixDQUFBO0FBQ2xDLGNBQWMsaUJBQWlCLENBQUE7QUFDL0IsY0FBYyxlQUFlLENBQUE7QUFDN0IsY0FBYyx3QkFBd0IsQ0FBQTtBQUN0QyxjQUFjLGNBQWMsQ0FBQTtBQUM1QixjQUFjLG9CQUFvQixDQUFBO0FBQ2xDLGNBQWMsYUFBYSxDQUFBO0FBQzNCLGNBQWMsY0FBYyxDQUFBO0FBQzVCLGNBQWMseUJBQXlCLENBQUE7QUFDdkMsY0FBYywyQkFBMkIsQ0FBQTtBQUN6QyxjQUFjLGtCQUFrQixDQUFBO0FBQ2hDLGNBQWMsZUFBZSxDQUFBO0FBQzdCLGNBQWMsd0JBQXdCLENBQUE7QUFDdEMsY0FBYyxtQkFBbUIsQ0FBQTtBQUNqQyxjQUFjLG9CQUFvQixDQUFBO0FBQ2xDLGNBQWMsZ0JBQWdCLENBQUE7QUFDOUIsY0FBYyxpQkFBaUIsQ0FBQTtBQUMvQixjQUFjLHNCQUFzQixDQUFBO0FBQ3BDLGNBQWMsV0FBVyxDQUFBO0FBQ3pCLGNBQWMsYUFBYSxDQUFBO0FBQzNCLGNBQWMsa0JBQWtCLENBQUE7QUFDaEMsY0FBYyxjQUFjLENBQUE7QUFDNUIsY0FBYywyQkFBMkIsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY2RrL2dldC1jbG9zZXN0LXdpZGdldC1jZGstZHJhZydcblxuZXhwb3J0ICogZnJvbSAnLi9mb3JtL2dldC1jb250cm9sLW5hbWUnXG5leHBvcnQgKiBmcm9tICcuL2Zvcm0vZ2V0LWNvbnRyb2wtcGF0aCdcbmV4cG9ydCAqIGZyb20gJy4vZm9ybS9vYnNlcnZlLWNvbnRyb2wtaXMtZGlmZmVyZW50J1xuZXhwb3J0ICogZnJvbSAnLi9mb3JtL29ic2VydmUtY29udHJvbC1zdGF0dXMnXG5leHBvcnQgKiBmcm9tICcuL2Zvcm0vb2JzZXJ2ZS1jb250cm9sLXZhbGlkJ1xuZXhwb3J0ICogZnJvbSAnLi9mb3JtL29ic2VydmUtY29udHJvbC12YWx1ZS1jaGFuZ2UnXG5leHBvcnQgKiBmcm9tICcuL2Zvcm0vb2JzZXJ2ZS1jb250cm9sLXZhbHVlJ1xuZXhwb3J0ICogZnJvbSAnLi9mb3JtL3dhaXQtb24tbm9uLXBlbmRpbmctc3RhdHVzJ1xuZXhwb3J0ICogZnJvbSAnLi9mb3JtL2hhcy1yZXF1aXJlZC1jb250cm9sJ1xuZXhwb3J0ICogZnJvbSAnLi9mb3JtL2lzLWVtcHR5LWlucHV0LXZhbHVlJ1xuXG5leHBvcnQgKiBmcm9tICcuL29wZXJhdG9ycy9pbmRleCdcblxuZXhwb3J0ICogZnJvbSAnLi9yb3V0ZXIvaW5kZXgnXG5cbmV4cG9ydCAqIGZyb20gJy4vYXJyYXktbW92ZSdcbmV4cG9ydCAqIGZyb20gJy4vY2FsYy1wZXJjZW50YWdlJ1xuZXhwb3J0ICogZnJvbSAnLi90b2dnbGUtYXR0cmlidXRlJ1xuZXhwb3J0ICogZnJvbSAnLi9nZXQtYXR0cmlidXRlJ1xuZXhwb3J0ICogZnJvbSAnLi9pbnB1dC1tYXNrcydcbmV4cG9ydCAqIGZyb20gJy4vaXMtbnVsbC1vci11bmRlZmluZWQnXG5leHBvcnQgKiBmcm9tICcuL2xvYWQtc3R5bGUnXG5leHBvcnQgKiBmcm9tICcuL2xvYWQtc3R5bGUtc2hlZXQnXG5leHBvcnQgKiBmcm9tICcuL29iai11dGlscydcbmV4cG9ydCAqIGZyb20gJy4vZmlsZS11dGlscydcbmV4cG9ydCAqIGZyb20gJy4vbm90LW51bGwtb3ItdW5kZWZpbmVkJ1xuZXhwb3J0ICogZnJvbSAnLi93YWl0LW9uLWNvbmRpdGlvbi1hc3luYydcbmV4cG9ydCAqIGZyb20gJy4vcG9sbGluZy10aWNrZXInXG5leHBvcnQgKiBmcm9tICcuL3JlZnJlc2hhYmxlJ1xuZXhwb3J0ICogZnJvbSAnLi93cmFwLWludG8tb2JzZXJ2YWJsZSdcbmV4cG9ydCAqIGZyb20gJy4vaXMtYWJzb2x1dGUtdXJsJ1xuZXhwb3J0ICogZnJvbSAnLi9zdWJzY3JpYmVyLWNvdW50J1xuZXhwb3J0ICogZnJvbSAnLi9oYXMtcHJvcGVydHknXG5leHBvcnQgKiBmcm9tICcuL2hhcy1hdHRyaWJ1dGUnXG5leHBvcnQgKiBmcm9tICcuL29ic2VydmUtcXVlcnktbGlzdCdcbmV4cG9ydCAqIGZyb20gJy4vcGFkLWVuZCdcbmV4cG9ydCAqIGZyb20gJy4vcGFkLXN0YXJ0J1xuZXhwb3J0ICogZnJvbSAnLi9jcmVhdGUtcGFkZGluZydcbmV4cG9ydCAqIGZyb20gJy4vaXMtbnVtZXJpYydcbmV4cG9ydCAqIGZyb20gJy4vZnJhY3Rpb25hbC1kaWdpdHMtY291bnQnXG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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