osm2geojson-lite 1.1.0 → 1.1.2

package/dist/node/index.d.ts

@@ -0,0 +1,25 @@
+import type { FeatureCollection, GeometryObject } from 'geojson';
+interface IOptions {
+    /**
+     * When it's set to `true`, the returned geojson will include all elements that meet the specified conditions in `FeatureCollection` format;
+     * otherwise, only the bare geometry of the first `relation` element will be returned.
+     * @default false
+     */
+    completeFeature?: boolean;
+    /**
+     * When it's set to `true`, the returned geojson will include all elements with tags (i.e., tagged)
+     * until `suppressWay` changes its behavior a bit; otherwise only the unreferenced ones get returned.
+     * @default false
+     */
+    renderTagged?: boolean;
+    /**
+     * When it's set to `true`, the returned `FeatureCollection` will exclude all referenced `way`s even though they are tagged;
+     * otherwise the features of those `way`s will be included in the resulted result as well.
+     * @default true
+     */
+    excludeWay?: boolean;
+}
+declare function osm2geojson(osm: string | {
+    [k: string]: any;
+}, opts?: IOptions): FeatureCollection<GeometryObject>;
+export = osm2geojson;

package/dist/node/index.js

@@ -0,0 +1,196 @@
+"use strict";
+const utils_1 = require("./utils");
+const xmlparser_1 = require("./xmlparser");
+const node_1 = require("./node");
+const way_1 = require("./way");
+const relation_1 = require("./relation");
+const ref_elements_1 = require("./ref-elements");
+function parseOptions(options) {
+    if (!options) {
+        return { completeFeature: false, renderTagged: false, excludeWay: true };
+    }
+    let excludeWay = options.excludeWay === undefined || options.excludeWay;
+    let completeFeature = options.completeFeature ? true : false;
+    let renderTagged = options.renderTagged ? true : false;
+    return { completeFeature, renderTagged, excludeWay };
+}
+function detectFormat(o) {
+    if (o.elements) {
+        return 'json';
+    }
+    if (o.indexOf('<osm') >= 0) {
+        return 'xml';
+    }
+    if (o.trim().startsWith('{')) {
+        return 'json-raw';
+    }
+    return 'invalid';
+}
+;
+function analyzeFeaturesFromJson(osm, refElements) {
+    for (const elem of osm.elements) {
+        switch (elem.type) {
+            case 'node':
+                const node = new node_1.Node(elem.id, refElements);
+                if (elem.tags) {
+                    node.addTags(elem.tags);
+                }
+                node.addProps((0, utils_1.purgeProps)(elem, ['id', 'type', 'tags', 'lat', 'lon']));
+                node.setLatLng(elem);
+                break;
+            case 'way':
+                const way = new way_1.Way(elem.id, refElements);
+                if (elem.tags) {
+                    way.addTags(elem.tags);
+                }
+                way.addProps((0, utils_1.purgeProps)(elem, ['id', 'type', 'tags', 'nodes', 'geometry']));
+                if (elem.geometry) {
+                    way.setLatLngArray(elem.geometry);
+                }
+                else if (elem.nodes) {
+                    for (const n of elem.nodes) {
+                        way.addNodeRef(n);
+                    }
+                }
+                break;
+            case 'relation':
+                const relation = new relation_1.Relation(elem.id, refElements);
+                if (elem.bounds) {
+                    relation.setBounds([parseFloat(elem.bounds.minlon), parseFloat(elem.bounds.minlat), parseFloat(elem.bounds.maxlon), parseFloat(elem.bounds.maxlat)]);
+                }
+                if (elem.tags) {
+                    relation.addTags(elem.tags);
+                }
+                relation.addProps((0, utils_1.purgeProps)(elem, ['id', 'type', 'tags', 'bounds', 'members']));
+                if (elem.members) {
+                    for (const member of elem.members) {
+                        relation.addMember(member);
+                    }
+                }
+            default:
+                break;
+        }
+    }
+}
+function analyzeFeaturesFromXml(osm, refElements) {
+    const xmlParser = new xmlparser_1.XmlParser({ progressive: true });
+    xmlParser.on('</osm.node>', (node) => {
+        const nd = new node_1.Node(node.id, refElements);
+        for (const [k, v] of Object.entries(node)) {
+            if (!k.startsWith('$') && ['id', 'lon', 'lat'].indexOf(k) < 0) {
+                nd.addProp(k, v);
+            }
+        }
+        nd.setLatLng(node);
+        if (node.$innerNodes) {
+            for (const ind of node.$innerNodes) {
+                if (ind.$tag === 'tag') {
+                    nd.addTag(ind.k, ind.v);
+                }
+            }
+        }
+    });
+    xmlParser.on('</osm.way>', (node) => {
+        const way = new way_1.Way(node.id, refElements);
+        for (const [k, v] of Object.entries(node)) {
+            if (!k.startsWith('$') && ['id'].indexOf(k) < 0) {
+                way.addProp(k, v);
+            }
+        }
+        if (node.$innerNodes) {
+            for (const ind of node.$innerNodes) {
+                if (ind.$tag === 'nd') {
+                    if (ind.lon && ind.lat) {
+                        way.addLatLng(ind);
+                    }
+                    else if (ind.ref) {
+                        way.addNodeRef(ind.ref);
+                    }
+                }
+                else if (ind.$tag === 'tag') {
+                    way.addTag(ind.k, ind.v);
+                }
+            }
+        }
+    });
+    xmlParser.on('<osm.relation>', (node) => new relation_1.Relation(node.id, refElements));
+    xmlParser.on('</osm.relation.member>', (node, parent) => {
+        const relation = refElements.get(`relation/${parent === null || parent === void 0 ? void 0 : parent.id}`);
+        const member = {
+            type: node.type,
+            role: node.role ? node.role : '',
+            ref: node.ref,
+        };
+        if (node.lat && node.lon) {
+            member.lat = node.lat, member.lon = node.lon, member.tags = {};
+            for (const [k, v] of Object.entries(node)) {
+                if (!k.startsWith('$') && ['type', 'lat', 'lon'].indexOf(k) < 0) {
+                    member[k] = v;
+                }
+            }
+        }
+        if (node.$innerNodes) {
+            const geometry = [];
+            const nodes = [];
+            for (const ind of node.$innerNodes) {
+                if (ind.lat && ind.lon) {
+                    geometry.push(ind);
+                }
+                else if (ind.ref) {
+                    nodes.push(ind.ref);
+                }
+            }
+            if (geometry.length > 0) {
+                member.geometry = geometry;
+            }
+            else if (nodes.length > 0) {
+                member.nodes = nodes;
+            }
+        }
+        relation.addMember(member);
+    });
+    xmlParser.on('</osm.relation.bounds>', (node, parent) => {
+        refElements.get(`relation/${parent === null || parent === void 0 ? void 0 : parent.id}`).setBounds([parseFloat(node.minlon), parseFloat(node.minlat), parseFloat(node.maxlon), parseFloat(node.maxlat)]);
+    });
+    xmlParser.on('</osm.relation.tag>', (node, parent) => {
+        refElements.get(`relation/${parent === null || parent === void 0 ? void 0 : parent.id}`).addTag(node.k, node.v);
+    });
+    xmlParser.parse(osm);
+}
+;
+function osm2geojson(osm, opts) {
+    let { completeFeature, renderTagged, excludeWay } = parseOptions(opts);
+    let format = detectFormat(osm);
+    const refElements = new ref_elements_1.RefElements();
+    let featureArray = [];
+    if (format === 'json-raw') {
+        osm = JSON.parse(osm);
+        if (osm.elements) {
+            format = 'json';
+        }
+        else {
+            format = 'invalid';
+        }
+    }
+    if (format === 'json') {
+        analyzeFeaturesFromJson(osm, refElements);
+    }
+    else if (format === 'xml') {
+        analyzeFeaturesFromXml(osm, refElements);
+    }
+    refElements.bindAll();
+    for (const v of refElements.values()) {
+        if (v.refCount > 0 && (!v.hasTag || !renderTagged || (v instanceof way_1.Way && excludeWay))) {
+            continue;
+        }
+        const features = v.toFeatureArray();
+        // return the first geometry of the first relation element
+        if (v instanceof relation_1.Relation && !completeFeature && features.length > 0) {
+            return features[0].geometry;
+        }
+        featureArray = featureArray.concat(features);
+    }
+    return { type: 'FeatureCollection', features: featureArray };
+}
+;
+module.exports = osm2geojson;

package/dist/node/late-binder.d.ts

@@ -0,0 +1,8 @@
+export declare class LateBinder<T> {
+    private container;
+    private valueFunc;
+    private ctx;
+    private args;
+    constructor(container: (T | LateBinder<T>)[], valueFunc: (...args: any[]) => T | undefined, ctx: any, args: any[]);
+    bind(): void;
+}

package/dist/node/late-binder.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LateBinder = void 0;
+class LateBinder {
+    constructor(container, valueFunc, ctx, args) {
+        this.container = container;
+        this.valueFunc = valueFunc;
+        this.ctx = ctx;
+        this.args = args;
+    }
+    bind() {
+        const v = this.valueFunc.apply(this.ctx, this.args);
+        const idx = this.container.indexOf(this);
+        if (idx < 0) {
+            return;
+        }
+        const args = [idx, 1];
+        if (v) {
+            args.push(v);
+        }
+        Array.prototype.splice.apply(this.container, args);
+    }
+}
+exports.LateBinder = LateBinder;

package/dist/node/node.d.ts

@@ -0,0 +1,14 @@
+import { OsmObject } from "./osm-object";
+import type { RefElements } from "./ref-elements";
+import type { Feature } from "geojson";
+export type LatLon = {
+    lat: string;
+    lon: string;
+};
+export declare class Node extends OsmObject {
+    private latLng;
+    constructor(id: string, refElems: RefElements);
+    setLatLng(latLng: LatLon): void;
+    toFeatureArray(): Array<Feature<any, any>>;
+    getLatLng(): LatLon | undefined;
+}

package/dist/node/node.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Node = void 0;
+const osm_object_1 = require("./osm-object");
+const utils_1 = require("./utils");
+class Node extends osm_object_1.OsmObject {
+    constructor(id, refElems) {
+        super('node', id, refElems);
+    }
+    setLatLng(latLng) {
+        this.latLng = latLng;
+    }
+    toFeatureArray() {
+        if (this.latLng) {
+            return [{
+                    type: 'Feature',
+                    id: this.getCompositeId(),
+                    properties: this.getProps(),
+                    geometry: {
+                        type: 'Point',
+                        coordinates: (0, utils_1.strArrayToFloat)([this.latLng.lon, this.latLng.lat]),
+                    },
+                }];
+        }
+        return [];
+    }
+    getLatLng() {
+        return this.latLng;
+    }
+}
+exports.Node = Node;

package/dist/node/osm-object.d.ts

@@ -0,0 +1,25 @@
+import type { RefElements } from './ref-elements';
+import type { Feature } from 'geojson';
+export declare abstract class OsmObject {
+    refCount: number;
+    hasTag: boolean;
+    protected refElems: RefElements;
+    private type;
+    private id;
+    private tags;
+    private props;
+    constructor(type: string, id: string, refElems: RefElements);
+    addTags(tags: {
+        [k: string]: string;
+    }): void;
+    addTag(k: string, v: string): void;
+    addProp(k: string, v: any): void;
+    addProps(props: {
+        [k: string]: string;
+    }): void;
+    getCompositeId(): string;
+    getProps(): {
+        [k: string]: string;
+    };
+    abstract toFeatureArray(): Array<Feature<any, any>>;
+}

package/dist/node/osm-object.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OsmObject = void 0;
+class OsmObject {
+    constructor(type, id, refElems) {
+        this.type = type;
+        this.id = id;
+        this.refElems = refElems;
+        this.tags = {};
+        this.props = { id: this.getCompositeId() };
+        this.refCount = 0;
+        this.hasTag = false;
+        if (refElems) {
+            refElems.add(this.getCompositeId(), this);
+        }
+    }
+    addTags(tags) {
+        this.tags = Object.assign(this.tags, tags);
+        this.hasTag = true;
+    }
+    addTag(k, v) {
+        this.tags[k] = v;
+        this.hasTag = true;
+    }
+    addProp(k, v) {
+        this.props[k] = v;
+    }
+    addProps(props) {
+        this.props = Object.assign(this.props, props);
+    }
+    getCompositeId() {
+        return `${this.type}/${this.id}`;
+    }
+    getProps() {
+        return Object.assign(this.props, this.tags);
+    }
+}
+exports.OsmObject = OsmObject;

package/dist/node/polytags.json

@@ -0,0 +1,84 @@
+{
+  "building": {},
+  "highway": {
+    "whitelist": [
+      "services",
+      "rest_area",
+      "escape",
+      "elevator"
+    ]
+  },
+  "natural": {
+    "blacklist": [
+      "coastline",
+      "cliff",
+      "ridge",
+      "arete",
+      "tree_row"
+    ]
+  },
+  "landuse": {},
+  "waterway": {
+    "whitelist": [
+      "riverbank",
+      "dock",
+      "boatyard",
+      "dam"
+    ]
+  },
+  "amenity": {},
+  "leisure": {},
+  "barrier": {
+    "whitelist": [
+      "city_wall",
+      "ditch",
+      "hedge",
+      "retaining_wall",
+      "wall",
+      "spikes"
+    ]
+  },
+  "railway": {
+    "whitelist": [
+      "station",
+      "turntable",
+      "roundhouse",
+      "platform"
+    ]
+  },
+  "area": {},
+  "boundary": {},
+  "man_made": {
+    "blacklist": [
+      "cutline",
+      "embankment",
+      "pipeline"
+    ]
+  },
+  "power": {
+    "whitelist": [
+      "plant",
+      "substation",
+      "generator",
+      "transformer"
+    ]
+  },
+  "place": {},
+  "shop": {},
+  "aeroway": {
+    "blacklist": [
+      "taxiway"
+    ]
+  },
+  "tourism": {},
+  "historic": {},
+  "public_transport": {},
+  "office": {},
+  "building:part": {},
+  "military": {},
+  "ruins": {},
+  "area:highway": {},
+  "craft": {},
+  "golf": {},
+  "indoor": {}
+}

package/dist/node/ref-elements.d.ts

@@ -0,0 +1,9 @@
+import { LateBinder } from "./late-binder";
+import type { OsmObject } from "./osm-object";
+export declare class RefElements extends Map<string, OsmObject> {
+    private binders;
+    constructor();
+    add(k: string, v: OsmObject): void;
+    addBinder(binder: LateBinder<any>): void;
+    bindAll(): void;
+}

package/dist/node/ref-elements.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RefElements = void 0;
+class RefElements extends Map {
+    constructor() {
+        super();
+        this.binders = [];
+    }
+    add(k, v) {
+        this.set(k, v);
+    }
+    addBinder(binder) {
+        this.binders.push(binder);
+    }
+    bindAll() {
+        this.binders.forEach((binder) => binder.bind());
+    }
+}
+exports.RefElements = RefElements;

package/dist/node/relation.d.ts

@@ -0,0 +1,20 @@
+import { OsmObject } from "./osm-object";
+import { Way } from "./way";
+import { LateBinder } from "./late-binder";
+import type { RefElements } from "./ref-elements";
+import type { Feature } from "geojson";
+export declare class Relation extends OsmObject {
+    private relations;
+    private nodes;
+    private bounds;
+    ways: (LateBinder<Way> | Way)[];
+    roles: string[];
+    constructor(id: string, refElems: RefElements);
+    setBounds(bounds: any[]): void;
+    addMember(member: {
+        [k: string]: any;
+    }): void;
+    private constructStringGeometry;
+    private constructPolygonGeometry;
+    toFeatureArray(): Array<Feature<any, any>>;
+}

package/dist/node/relation.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Relation = void 0;
+const osm_object_1 = require("./osm-object");
+const way_1 = require("./way");
+const node_1 = require("./node");
+const way_collection_1 = require("./way-collection");
+const late_binder_1 = require("./late-binder");
+const utils_1 = require("./utils");
+class Relation extends osm_object_1.OsmObject {
+    constructor(id, refElems) {
+        super('relation', id, refElems);
+        this.relations = [];
+        this.nodes = [];
+        this.bounds = undefined;
+        this.ways = [];
+        this.roles = [];
+    }
+    setBounds(bounds) {
+        this.bounds = bounds;
+    }
+    addMember(member) {
+        switch (member.type) {
+            // super relation, need to do combination
+            case 'relation':
+                let binder = new late_binder_1.LateBinder(this.relations, (id) => {
+                    const relation = this.refElems.get(`relation/${id}`);
+                    if (relation) {
+                        relation.refCount++;
+                        return relation;
+                    }
+                }, this, [member.ref]);
+                this.relations.push(binder);
+                this.refElems.addBinder(binder);
+                break;
+            case 'way':
+                if (!member.role) {
+                    member.role = '';
+                }
+                if (member.geometry) {
+                    const way = new way_1.Way(member.ref, this.refElems);
+                    way.setLatLngArray(member.geometry);
+                    way.refCount++;
+                    this.ways.push(way);
+                    this.roles.push(member.role);
+                }
+                else if (member.nodes) {
+                    const way = new way_1.Way(member.ref, this.refElems);
+                    for (const nid of member.nodes) {
+                        way.addNodeRef(nid);
+                    }
+                    way.refCount++;
+                    this.ways.push(way);
+                    this.roles.push(member.role);
+                }
+                else {
+                    let binder = new late_binder_1.LateBinder(this.ways, (nid) => {
+                        const way = this.refElems.get(`way/${nid}`);
+                        if (way) {
+                            way.refCount++;
+                            return way;
+                        }
+                    }, this, [member.ref]);
+                    this.ways.push(binder);
+                    this.roles.push(member.role);
+                    this.refElems.addBinder(binder);
+                }
+                break;
+            case 'node':
+                let node = null;
+                if (member.lat && member.lon) {
+                    node = new node_1.Node(member.ref, this.refElems);
+                    node.setLatLng({ lon: member.lon, lat: member.lat });
+                    if (member.tags) {
+                        node.addTags(member.tags);
+                    }
+                    for (const [k, v] of Object.entries(member)) {
+                        if (['id', 'type', 'lat', 'lon'].indexOf(k) < 0) {
+                            node.addProp(k, v);
+                        }
+                    }
+                    node.refCount++;
+                    this.nodes.push(node);
+                }
+                else {
+                    let binder = new late_binder_1.LateBinder(this.nodes, (id) => {
+                        const nn = this.refElems.get(`node/${id}`);
+                        if (nn) {
+                            nn.refCount++;
+                            return nn;
+                        }
+                    }, this, [member.ref]);
+                    this.nodes.push(binder);
+                    this.refElems.addBinder(binder);
+                }
+                break;
+        }
+    }
+    constructStringGeometry(ws) {
+        const strings = ws ? ws.mergeWays() : [];
+        if (strings.length === 0) {
+            return null;
+        }
+        return {
+            type: 'MultiLineString',
+            coordinates: strings,
+        };
+    }
+    constructPolygonGeometry(ows, iws) {
+        const outerRings = ows ? ows.toRings('counterclockwise') : [];
+        const innerRings = iws ? iws.toRings('clockwise') : [];
+        if (outerRings.length > 0) {
+            const compositPolyons = [];
+            let ring;
+            for (ring of outerRings) {
+                compositPolyons.push([ring]);
+            }
+            // link inner polygons to outer containers
+            ring = innerRings.shift();
+            while (ring) {
+                for (const idx in outerRings) {
+                    if ((0, utils_1.pointInsidePolygon)((0, utils_1.first)(ring), outerRings[idx])) {
+                        compositPolyons[idx].push(ring);
+                        break;
+                    }
+                }
+                ring = innerRings.shift();
+            }
+            // construct the Polygon/MultiPolygon geometry
+            if (compositPolyons.length === 1) {
+                return {
+                    type: 'Polygon',
+                    coordinates: compositPolyons[0],
+                };
+            }
+            return {
+                type: 'MultiPolygon',
+                coordinates: compositPolyons,
+            };
+        }
+        return null;
+    }
+    toFeatureArray() {
+        const polygonFeatures = [];
+        const stringFeatures = [];
+        let pointFeatures = [];
+        for (const relation of this.relations) {
+            if (!relation) {
+                continue;
+            }
+            for (let i = 0; i < relation.ways.length; i++) {
+                const way = relation.ways[i];
+                this.ways.push(way);
+                this.roles.push(relation.roles[i]);
+            }
+        }
+        let templateFeature = {
+            type: 'Feature',
+            id: this.getCompositeId(),
+            bbox: this.bounds,
+            properties: this.getProps(),
+            geometry: null
+        };
+        if (!this.bounds) {
+            delete templateFeature.bbox;
+        }
+        if (this.roles.some((r) => r === 'outer')) {
+            const outerWayCollection = new way_collection_1.WayCollection();
+            const innerWayCollection = new way_collection_1.WayCollection();
+            for (let i = 0; i < this.ways.length; i++) {
+                const way = this.ways[i];
+                const role = this.roles[i];
+                if (role === 'outer') {
+                    outerWayCollection.addWay(way);
+                }
+                else if (role === 'inner') {
+                    innerWayCollection.addWay(way);
+                }
+            }
+            let feature = Object.assign({}, templateFeature);
+            let geometry = this.constructPolygonGeometry(outerWayCollection, innerWayCollection);
+            if (geometry) {
+                feature.geometry = geometry;
+                polygonFeatures.push(feature);
+            }
+        }
+        else {
+            const wayCollection = new way_collection_1.WayCollection();
+            for (let way of this.ways) {
+                wayCollection.addWay(way);
+            }
+            let geometry = this.constructStringGeometry(wayCollection);
+            if (geometry) {
+                let feature = Object.assign({}, templateFeature);
+                feature.geometry = geometry;
+                stringFeatures.push(feature);
+            }
+        }
+        for (let node of this.nodes) {
+            pointFeatures = pointFeatures.concat(node.toFeatureArray());
+        }
+        return [...polygonFeatures, ...stringFeatures, ...pointFeatures];
+    }
+}
+exports.Relation = Relation;

package/dist/node/utils.d.ts

@@ -0,0 +1,22 @@
+export declare function purgeProps(obj: {
+    [k: string]: any;
+}, blacklist: string[]): {
+    [k: string]: any;
+};
+export declare function first<T>(a: T[]): T;
+export declare function last<T>(a: T[]): T;
+export declare function coordsToKey<T>(a: T[]): string;
+export declare function addToMap<T>(m: {
+    [k: string]: T[];
+}, k: string, v: T): void;
+export declare function removeFromMap<T>(m: {
+    [k: string]: T[];
+}, k: string, v: T): void;
+export declare function getFirstFromMap<T>(m: {
+    [k: string]: T[];
+}, k: string): T | null;
+export declare function isRing(a: number[][]): boolean;
+export declare function ringDirection(a: number[][], xIdx?: number, yIdx?: number): string;
+export declare function pointInsidePolygon(pt: number[], polygon: number[][], xIdx?: number, yIdx?: number): boolean;
+export declare function strArrayArrayToFloat(el: string[][]): number[][];
+export declare function strArrayToFloat(el: string[]): number[];

package/dist/node/utils.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.purgeProps = purgeProps;
+exports.first = first;
+exports.last = last;
+exports.coordsToKey = coordsToKey;
+exports.addToMap = addToMap;
+exports.removeFromMap = removeFromMap;
+exports.getFirstFromMap = getFirstFromMap;
+exports.isRing = isRing;
+exports.ringDirection = ringDirection;
+exports.pointInsidePolygon = pointInsidePolygon;
+exports.strArrayArrayToFloat = strArrayArrayToFloat;
+exports.strArrayToFloat = strArrayToFloat;
+function purgeProps(obj, blacklist) {
+    if (obj) {
+        const rs = Object.assign({}, obj);
+        if (blacklist) {
+            for (const prop of blacklist) {
+                delete rs[prop];
+            }
+        }
+        return rs;
+    }
+    return {};
+}
+function first(a) { return a[0]; }
+function last(a) { return a[a.length - 1]; }
+function coordsToKey(a) { return a.join(','); }
+function addToMap(m, k, v) {
+    const a = m[k];
+    if (a) {
+        a.push(v);
+    }
+    else {
+        m[k] = [v];
+    }
+}
+function removeFromMap(m, k, v) {
+    const a = m[k];
+    let idx = -1;
+    if (a) {
+        idx = a.indexOf(v);
+    }
+    if (idx >= 0) {
+        a.splice(idx, 1);
+    }
+}
+function getFirstFromMap(m, k) {
+    const a = m[k];
+    if (a && a.length > 0) {
+        return a[0];
+    }
+    return null;
+}
+// need 3+ different points to form a ring, here using > 3 is 'coz a the first and the last points are actually the same
+function isRing(a) {
+    return a.length > 3 && coordsToKey(first(a)) === coordsToKey(last(a));
+}
+function ringDirection(a, xIdx, yIdx) {
+    xIdx = xIdx || 0, yIdx = yIdx || 1;
+    // get the index of the point which has the maximum x value
+    const m = a.reduce((maxxIdx, v, idx) => a[maxxIdx][xIdx || 0] > v[xIdx || 0] ? maxxIdx : idx, 0);
+    // 'coz the first point is virtually the same one as the last point,
+    // we need to skip a.length - 1 for left when m = 0,
+    // and skip 0 for right when m = a.length - 1;
+    const l = m <= 0 ? a.length - 2 : m - 1;
+    const r = m >= a.length - 1 ? 1 : m + 1;
+    const xa = a[l][xIdx];
+    const xb = a[m][xIdx];
+    const xc = a[r][xIdx];
+    const ya = a[l][yIdx];
+    const yb = a[m][yIdx];
+    const yc = a[r][yIdx];
+    const det = (xb - xa) * (yc - ya) - (xc - xa) * (yb - ya);
+    return det < 0 ? 'clockwise' : 'counterclockwise';
+}
+;
+function pointInsidePolygon(pt, polygon, xIdx, yIdx) {
+    xIdx = xIdx || 0, yIdx = yIdx || 1;
+    let result = false;
+    for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+        if ((polygon[i][xIdx] <= pt[xIdx] && pt[xIdx] < polygon[j][xIdx] ||
+            polygon[j][xIdx] <= pt[xIdx] && pt[xIdx] < polygon[i][xIdx]) &&
+            pt[yIdx] < (polygon[j][yIdx] - polygon[i][yIdx]) * (pt[xIdx] - polygon[i][xIdx]) / (polygon[j][xIdx] - polygon[i][xIdx]) + polygon[i][yIdx]) {
+            result = !result;
+        }
+    }
+    return result;
+}
+;
+function strArrayArrayToFloat(el) {
+    return el.map(strArrayToFloat);
+}
+function strArrayToFloat(el) {
+    return el.map(parseFloat);
+}

package/dist/node/way-collection.d.ts

@@ -0,0 +1,14 @@
+import type { Way } from "./way";
+export declare class WayCollection extends Array {
+    private firstMap;
+    private lastMap;
+    constructor();
+    addWay(way: Way): void;
+    mergeWays(): number[][][];
+    /**
+     * Try to find the next way to add to the current way.
+     * It first tries the next way in the array, and if this doesn't work, try any other way.
+     */
+    private getNextWay;
+    toRings(direction: string): number[][][];
+}

package/dist/node/way-collection.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WayCollection = void 0;
+const utils_1 = require("./utils");
+class WayCollection extends Array {
+    constructor() {
+        super();
+        this.firstMap = {};
+        this.lastMap = {};
+    }
+    addWay(way) {
+        const w = way.toCoordsArray();
+        if (w.length > 0) {
+            this.push(w);
+            (0, utils_1.addToMap)(this.firstMap, (0, utils_1.coordsToKey)((0, utils_1.first)(w)), w);
+            (0, utils_1.addToMap)(this.lastMap, (0, utils_1.coordsToKey)((0, utils_1.last)(w)), w);
+        }
+    }
+    mergeWays() {
+        const strings = [];
+        let way = this.shift();
+        while (way) {
+            (0, utils_1.removeFromMap)(this.firstMap, (0, utils_1.coordsToKey)((0, utils_1.first)(way)), way);
+            (0, utils_1.removeFromMap)(this.lastMap, (0, utils_1.coordsToKey)((0, utils_1.last)(way)), way);
+            let current = way;
+            let next;
+            do {
+                let nextWay = this.getNextWay(current);
+                next = nextWay.next;
+                let mergeType = nextWay.mergeType;
+                if (!next) {
+                    continue;
+                }
+                this.splice(this.indexOf(next), 1);
+                (0, utils_1.removeFromMap)(this.firstMap, (0, utils_1.coordsToKey)((0, utils_1.first)(next)), next);
+                (0, utils_1.removeFromMap)(this.lastMap, (0, utils_1.coordsToKey)((0, utils_1.last)(next)), next);
+                switch (mergeType) {
+                    case 0 /* MergeType.EndStart */:
+                        current = current.concat(next.slice(1));
+                        break;
+                    case 1 /* MergeType.EndEnd */:
+                        next.reverse();
+                        current = current.concat(next.slice(1));
+                        break;
+                    case 2 /* MergeType.StartStart */:
+                        current.reverse();
+                        current = current.concat(next.slice(1));
+                        break;
+                    case 3 /* MergeType.StartEnd */:
+                        current = next.concat(current.slice(1));
+                        break;
+                }
+            } while (next);
+            strings.push((0, utils_1.strArrayArrayToFloat)(current));
+            way = this.shift();
+        }
+        return strings;
+    }
+    /**
+     * Try to find the next way to add to the current way.
+     * It first tries the next way in the array, and if this doesn't work, try any other way.
+     */
+    getNextWay(current) {
+        const lastKey = (0, utils_1.coordsToKey)((0, utils_1.last)(current));
+        const firstKey = (0, utils_1.coordsToKey)((0, utils_1.first)(current));
+        // Step 1: Prefer the next way in the array if it connects
+        let next = this.length > 0 ? this[0] : null;
+        if (next) {
+            const nextFirstKey = (0, utils_1.coordsToKey)((0, utils_1.first)(next));
+            const nextLastKey = (0, utils_1.coordsToKey)((0, utils_1.last)(next));
+            if (lastKey === nextFirstKey) {
+                return { next, mergeType: 0 /* MergeType.EndStart */ };
+            }
+            if (lastKey === nextLastKey) {
+                return { next, mergeType: 1 /* MergeType.EndEnd */ };
+            }
+            if (firstKey === nextFirstKey) {
+                return { next, mergeType: 2 /* MergeType.StartStart */ };
+            }
+            if (firstKey === nextLastKey) {
+                return { next, mergeType: 3 /* MergeType.StartEnd */ };
+            }
+        }
+        // Step 2: Fallback to map-based lookup if no sequential match
+        next = (0, utils_1.getFirstFromMap)(this.firstMap, lastKey);
+        if (next) {
+            return { next, mergeType: 0 /* MergeType.EndStart */ };
+        }
+        next = (0, utils_1.getFirstFromMap)(this.lastMap, lastKey);
+        return { next, mergeType: 1 /* MergeType.EndEnd */ };
+    }
+    toRings(direction) {
+        const strings = this.mergeWays();
+        const rings = [];
+        let str = strings.shift();
+        while (str) {
+            if ((0, utils_1.isRing)(str)) {
+                if ((0, utils_1.ringDirection)(str) !== direction) {
+                    str.reverse();
+                }
+                rings.push(str);
+            }
+            str = strings.shift();
+        }
+        return rings;
+    }
+}
+exports.WayCollection = WayCollection;

package/dist/node/way.d.ts

@@ -0,0 +1,21 @@
+import { Feature } from "geojson";
+import { OsmObject } from "./osm-object";
+import { LatLon } from "./node";
+import type { RefElements } from "./ref-elements";
+export declare class Way extends OsmObject {
+    private latLngArray;
+    private isPolygon;
+    constructor(id: string, refElems: RefElements);
+    addLatLng(latLng: LatLon): void;
+    setLatLngArray(latLngArray: Array<LatLon & {
+        [k: string]: any;
+    }>): void;
+    addNodeRef(ref: string): void;
+    addTags(tags: {
+        [k: string]: string;
+    }): void;
+    addTag(k: string, v: string): void;
+    toCoordsArray(): string[][];
+    toFeatureArray(): Array<Feature<any, any>>;
+    private analyzeTag;
+}

package/dist/node/way.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Way = void 0;
+const osm_object_1 = require("./osm-object");
+const late_binder_1 = require("./late-binder");
+const utils_1 = require("./utils");
+const polytags_json_1 = __importDefault(require("./polytags.json"));
+class Way extends osm_object_1.OsmObject {
+    constructor(id, refElems) {
+        super('way', id, refElems);
+        this.latLngArray = [];
+        this.isPolygon = false;
+    }
+    addLatLng(latLng) {
+        this.latLngArray.push(latLng);
+    }
+    setLatLngArray(latLngArray) {
+        this.latLngArray = latLngArray;
+    }
+    addNodeRef(ref) {
+        const binder = new late_binder_1.LateBinder(this.latLngArray, (id) => {
+            const node = this.refElems.get(`node/${id}`);
+            if (node) {
+                node.refCount++;
+                return node.getLatLng();
+            }
+        }, this, [ref]);
+        this.latLngArray.push(binder);
+        this.refElems.addBinder(binder);
+    }
+    addTags(tags) {
+        super.addTags(tags);
+        for (const [k, v] of Object.entries(tags)) {
+            this.analyzeTag(k, v);
+        }
+    }
+    addTag(k, v) {
+        super.addTag(k, v);
+        this.analyzeTag(k, v);
+    }
+    toCoordsArray() {
+        return this.latLngArray.map((latLng) => [latLng.lon, latLng.lat]);
+    }
+    toFeatureArray() {
+        let coordsArrayString = this.toCoordsArray();
+        if (coordsArrayString.length > 1) {
+            const coordsArray = (0, utils_1.strArrayArrayToFloat)(coordsArrayString);
+            const feature = {
+                type: 'Feature',
+                id: this.getCompositeId(),
+                properties: this.getProps(),
+                geometry: {
+                    type: 'LineString',
+                    coordinates: coordsArray,
+                },
+            };
+            if (this.isPolygon && (0, utils_1.isRing)(coordsArray)) {
+                if ((0, utils_1.ringDirection)(coordsArray) !== 'counterclockwise') {
+                    coordsArray.reverse();
+                }
+                feature.geometry = {
+                    type: 'Polygon',
+                    coordinates: [coordsArray],
+                };
+                return [feature];
+            }
+            return [feature];
+        }
+        return [];
+    }
+    analyzeTag(k, v) {
+        const o = polytags_json_1.default[k];
+        if (o) {
+            this.isPolygon = true;
+            if (o.whitelist) {
+                this.isPolygon = o.whitelist.indexOf(v) >= 0 ? true : false;
+            }
+            else if (o.blacklist) {
+                this.isPolygon = o.blacklist.indexOf(v) >= 0 ? false : true;
+            }
+        }
+    }
+}
+exports.Way = Way;

package/dist/node/xmlparser.d.ts

@@ -0,0 +1,32 @@
+export declare class XmlParser {
+    private queryParent;
+    private progressive;
+    private parentMap;
+    private evtListeners;
+    constructor(opts: any);
+    parse(xml: string, parent?: any, dir?: string): any[];
+    getParent(node: any): any;
+    addListener(evt: string, func: (node: {
+        [k: string]: any;
+    }, parent?: {
+        [k: string]: any;
+    }) => void): void;
+    removeListener(evt: string, func: (node: {
+        [k: string]: any;
+    }, parent?: {
+        [k: string]: any;
+    }) => void): void;
+    on(evt: string, func: (node: {
+        [k: string]: any;
+    }, parent?: {
+        [k: string]: any;
+    }) => void): void;
+    off(evt: string, func: (node: {
+        [k: string]: any;
+    }, parent?: {
+        [k: string]: any;
+    }) => void): void;
+    private $addListener;
+    private $removeListener;
+    private emit;
+}

package/dist/node/xmlparser.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XmlParser = void 0;
+function conditioned(evt) {
+    return evt.match(/^(.+?)\[(.+?)\]>$/g) !== null;
+}
+function parseEvent(evt) {
+    const match = /^(.+?)\[(.+?)\]>$/g.exec(evt);
+    if (match) {
+        return { evt: match[1] + '>', exp: match[2] };
+    }
+    return { evt };
+}
+function genConditionFunc(cond) {
+    const body = 'return ' + cond.replace(/(\$.+?)(?=[=!.])/g, 'node.$&') + ';';
+    return new Function('node', body);
+}
+class XmlParser {
+    constructor(opts) {
+        this.queryParent = false;
+        this.progressive = false;
+        this.parentMap = new WeakMap();
+        if (opts) {
+            this.queryParent = opts.queryParent ? true : false;
+            this.progressive = opts.progressive;
+            if (this.queryParent) {
+                this.parentMap = new WeakMap();
+            }
+        }
+        this.evtListeners = {};
+    }
+    parse(xml, parent, dir) {
+        dir = dir ? dir + '.' : '';
+        const nodeRegEx = /<([^ >\/]+)(.*?)>/mg;
+        const nodes = [];
+        let nodeMatch = nodeRegEx.exec(xml);
+        while (nodeMatch) {
+            const tag = nodeMatch[1];
+            const node = { $tag: tag };
+            const fullTag = dir + tag;
+            const attrText = nodeMatch[2].trim();
+            let closed = false;
+            if (attrText.endsWith('/') || tag.startsWith('?') || tag.startsWith('!')) {
+                closed = true;
+            }
+            const attRegEx1 = /([^ ]+?)="(.+?)"/g;
+            const attRegEx2 = /([^ ]+?)='(.+?)'/g;
+            let attMatch = attRegEx1.exec(attrText);
+            let hasAttrs = false;
+            while (attMatch) {
+                hasAttrs = true;
+                node[attMatch[1]] = attMatch[2];
+                attMatch = attRegEx1.exec(attrText);
+            }
+            if (!hasAttrs) {
+                attMatch = attRegEx2.exec(attrText);
+                while (attMatch) {
+                    hasAttrs = true;
+                    node[attMatch[1]] = attMatch[2];
+                    attMatch = attRegEx2.exec(attrText);
+                }
+            }
+            if (!hasAttrs && attrText !== '') {
+                node.text = attrText;
+            }
+            if (this.progressive) {
+                this.emit(`<${fullTag}>`, node, parent);
+            }
+            if (!closed) {
+                const innerRegEx = new RegExp(`([^]+?)<\/${tag}>`, 'g');
+                innerRegEx.lastIndex = nodeRegEx.lastIndex;
+                const innerMatch = innerRegEx.exec(xml);
+                if (innerMatch && innerMatch[1]) {
+                    nodeRegEx.lastIndex = innerRegEx.lastIndex;
+                    const innerNodes = this.parse(innerMatch[1], node, fullTag);
+                    if (innerNodes.length > 0) {
+                        node.$innerNodes = innerNodes;
+                    }
+                    else {
+                        node.$innerText = innerMatch[1];
+                    }
+                }
+            }
+            if (this.queryParent && parent) {
+                this.parentMap.set(node, parent);
+            }
+            if (this.progressive) {
+                this.emit(`</${fullTag}>`, node, parent);
+            }
+            nodes.push(node);
+            nodeMatch = nodeRegEx.exec(xml);
+        }
+        return nodes;
+    }
+    getParent(node) {
+        if (this.queryParent) {
+            return this.parentMap.get(node);
+        }
+        return null;
+    }
+    // support javascript condition for the last tag
+    addListener(evt, func) {
+        if (conditioned(evt)) {
+            // func.prototype = evt;
+            const ev = parseEvent(evt);
+            if (ev.exp) {
+                func.condition = genConditionFunc(ev.exp);
+            }
+            evt = ev.evt;
+        }
+        this.$addListener(evt, func);
+    }
+    removeListener(evt, func) {
+        if (conditioned(evt)) {
+            const ev = parseEvent(evt);
+            evt = ev.evt;
+        }
+        this.$removeListener(evt, func);
+    }
+    on(evt, func) {
+        this.addListener(evt, func);
+    }
+    off(evt, func) {
+        this.removeListener(evt, func);
+    }
+    $addListener(evt, func) {
+        const funcs = this.evtListeners[evt];
+        if (funcs) {
+            funcs.push(func);
+        }
+        else {
+            this.evtListeners[evt] = [func];
+        }
+    }
+    $removeListener(evt, func) {
+        const funcs = this.evtListeners[evt];
+        let idx = -1;
+        if (funcs) {
+            idx = funcs.indexOf(func);
+        }
+        if (idx >= 0) {
+            funcs.splice(idx, 1);
+        }
+    }
+    emit(evt, ...args) {
+        const funcs = this.evtListeners[evt];
+        if (funcs) {
+            for (const func of funcs) {
+                if (func.condition) {
+                    if (func.condition.apply(null, args) === true) {
+                        func.apply(null, args);
+                    }
+                }
+                else {
+                    func.apply(null, args);
+                }
+            }
+        }
+    }
+}
+exports.XmlParser = XmlParser;

package/dist/web/osm2geojson-lite.js

@@ -0,0 +1 @@
+!function(e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e():"function"==typeof define&&define.amd?define([],e):("undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:this).osm2geojson=e()}(function(){return function s(o,i,n){function a(t,e){if(!i[t]){if(!o[t]){var r="function"==typeof require&&require;if(!e&&r)return r(t,!0);if(l)return l(t,!0);throw(e=new Error("Cannot find module '"+t+"'")).code="MODULE_NOT_FOUND",e}r=i[t]={exports:{}},o[t][0].call(r.exports,function(e){return a(o[t][1][e]||e)},r,r.exports,s,o,i,n)}return i[t].exports}for(var l="function"==typeof require&&require,e=0;e<n.length;e++)a(n[e]);return a}({1:[function(e,t,r){let v=e("./utils"),b=e("./xmlparser"),w=e("./node"),x=e("./way"),L=e("./relation"),T=e("./ref-elements");t.exports=function(e,t){var{completeFeature:r,renderTagged:s,excludeWay:o}=(t=t)?(a=void 0===t.excludeWay||t.excludeWay,{completeFeature:!!t.completeFeature,renderTagged:!!t.renderTagged,excludeWay:a}):{completeFeature:!1,renderTagged:!1,excludeWay:!0};let i=(t=e).elements?"json":0<=t.indexOf("<osm")?"xml":t.trim().startsWith("{")?"json-raw":"invalid";var l,n,a=new T.RefElements;let d=[];if("json-raw"===i&&(e=JSON.parse(e),i=e.elements?"json":"invalid"),"json"===i){var u,h=a;for(u of e.elements)switch(u.type){case"node":var f=new w.Node(u.id,h);u.tags&&f.addTags(u.tags),f.addProps((0,v.purgeProps)(u,["id","type","tags","lat","lon"])),f.setLatLng(u);break;case"way":var c=new x.Way(u.id,h);if(u.tags&&c.addTags(u.tags),c.addProps((0,v.purgeProps)(u,["id","type","tags","nodes","geometry"])),u.geometry)c.setLatLngArray(u.geometry);else if(u.nodes)for(var p of u.nodes)c.addNodeRef(p);break;case"relation":var g=new L.Relation(u.id,h);if(u.bounds&&g.setBounds([parseFloat(u.bounds.minlon),parseFloat(u.bounds.minlat),parseFloat(u.bounds.maxlon),parseFloat(u.bounds.maxlat)]),u.tags&&g.addTags(u.tags),g.addProps((0,v.purgeProps)(u,["id","type","tags","bounds","members"])),u.members)for(var y of u.members)g.addMember(y)}}else"xml"===i&&(t=e,l=a,(e=new b.XmlParser({progressive:!0})).on("</osm.node>",e=>{var t,r,s=new w.Node(e.id,l);for([t,r]of Object.entries(e))!t.startsWith("$")&&["id","lon","lat"].indexOf(t)<0&&s.addProp(t,r);if(s.setLatLng(e),e.$innerNodes)for(var o of e.$innerNodes)"tag"===o.$tag&&s.addTag(o.k,o.v)}),e.on("</osm.way>",e=>{var t,r,s=new x.Way(e.id,l);for([t,r]of Object.entries(e))!t.startsWith("$")&&["id"].indexOf(t)<0&&s.addProp(t,r);if(e.$innerNodes)for(var o of e.$innerNodes)"nd"===o.$tag?o.lon&&o.lat?s.addLatLng(o):o.ref&&s.addNodeRef(o.ref):"tag"===o.$tag&&s.addTag(o.k,o.v)}),e.on("<osm.relation>",e=>new L.Relation(e.id,l)),e.on("</osm.relation.member>",(e,t)=>{var t=l.get("relation/"+(null==t?void 0:t.id)),r={type:e.type,role:e.role||"",ref:e.ref};if(e.lat&&e.lon){r.lat=e.lat,r.lon=e.lon,r.tags={};for(var[s,o]of Object.entries(e))!s.startsWith("$")&&["type","lat","lon"].indexOf(s)<0&&(r[s]=o)}if(e.$innerNodes){var i,n=[],a=[];for(i of e.$innerNodes)i.lat&&i.lon?n.push(i):i.ref&&a.push(i.ref);0<n.length?r.geometry=n:0<a.length&&(r.nodes=a)}t.addMember(r)}),e.on("</osm.relation.bounds>",(e,t)=>{l.get("relation/"+(null==t?void 0:t.id)).setBounds([parseFloat(e.minlon),parseFloat(e.minlat),parseFloat(e.maxlon),parseFloat(e.maxlat)])}),e.on("</osm.relation.tag>",(e,t)=>{l.get("relation/"+(null==t?void 0:t.id)).addTag(e.k,e.v)}),e.parse(t));a.bindAll();for(n of a.values())if(!(0<n.refCount)||n.hasTag&&s&&!(n instanceof x.Way&&o)){var m=n.toFeatureArray();if(n instanceof L.Relation&&!r&&0<m.length)return m[0].geometry;d=d.concat(m)}return{type:"FeatureCollection",features:d}}},{"./node":3,"./ref-elements":6,"./relation":7,"./utils":8,"./way":10,"./xmlparser":11}],2:[function(e,t,r){Object.defineProperty(r,"__esModule",{value:!0}),r.LateBinder=void 0;r.LateBinder=class{constructor(e,t,r,s){this.container=e,this.valueFunc=t,this.ctx=r,this.args=s}bind(){var e=this.valueFunc.apply(this.ctx,this.args),t=this.container.indexOf(this);t<0||(t=[t,1],e&&t.push(e),Array.prototype.splice.apply(this.container,t))}}},{}],3:[function(e,t,r){Object.defineProperty(r,"__esModule",{value:!0}),r.Node=void 0;var s=e("./osm-object");let o=e("./utils");class i extends s.OsmObject{constructor(e,t){super("node",e,t)}setLatLng(e){this.latLng=e}toFeatureArray(){return this.latLng?[{type:"Feature",id:this.getCompositeId(),properties:this.getProps(),geometry:{type:"Point",coordinates:(0,o.strArrayToFloat)([this.latLng.lon,this.latLng.lat])}}]:[]}getLatLng(){return this.latLng}}r.Node=i},{"./osm-object":4,"./utils":8}],4:[function(e,t,r){Object.defineProperty(r,"__esModule",{value:!0}),r.OsmObject=void 0;r.OsmObject=class{constructor(e,t,r){this.type=e,this.id=t,this.refElems=r,this.tags={},this.props={id:this.getCompositeId()},this.refCount=0,this.hasTag=!1,r&&r.add(this.getCompositeId(),this)}addTags(e){this.tags=Object.assign(this.tags,e),this.hasTag=!0}addTag(e,t){this.tags[e]=t,this.hasTag=!0}addProp(e,t){this.props[e]=t}addProps(e){this.props=Object.assign(this.props,e)}getCompositeId(){return this.type+"/"+this.id}getProps(){return Object.assign(this.props,this.tags)}}},{}],5:[function(e,t,r){t.exports={building:{},highway:{whitelist:["services","rest_area","escape","elevator"]},natural:{blacklist:["coastline","cliff","ridge","arete","tree_row"]},landuse:{},waterway:{whitelist:["riverbank","dock","boatyard","dam"]},amenity:{},leisure:{},barrier:{whitelist:["city_wall","ditch","hedge","retaining_wall","wall","spikes"]},railway:{whitelist:["station","turntable","roundhouse","platform"]},area:{},boundary:{},man_made:{blacklist:["cutline","embankment","pipeline"]},power:{whitelist:["plant","substation","generator","transformer"]},place:{},shop:{},aeroway:{blacklist:["taxiway"]},tourism:{},historic:{},public_transport:{},office:{},"building:part":{},military:{},ruins:{},"area:highway":{},craft:{},golf:{},indoor:{}}},{}],6:[function(e,t,r){Object.defineProperty(r,"__esModule",{value:!0}),r.RefElements=void 0;class s extends Map{constructor(){super(),this.binders=[]}add(e,t){this.set(e,t)}addBinder(e){this.binders.push(e)}bindAll(){this.binders.forEach(e=>e.bind())}}r.RefElements=s},{}],7:[function(e,t,r){Object.defineProperty(r,"__esModule",{value:!0}),r.Relation=void 0;var s=e("./osm-object");let a=e("./way"),l=e("./node"),g=e("./way-collection"),d=e("./late-binder"),n=e("./utils");class o extends s.OsmObject{constructor(e,t){super("relation",e,t),this.relations=[],this.nodes=[],this.bounds=void 0,this.ways=[],this.roles=[]}setBounds(e){this.bounds=e}addMember(e){switch(e.type){case"relation":var t=new d.LateBinder(this.relations,e=>{e=this.refElems.get("relation/"+e);if(e)return e.refCount++,e},this,[e.ref]);this.relations.push(t),this.refElems.addBinder(t);break;case"way":if(e.role||(e.role=""),e.geometry){t=new a.Way(e.ref,this.refElems);t.setLatLngArray(e.geometry),t.refCount++,this.ways.push(t),this.roles.push(e.role)}else if(e.nodes){var r,s=new a.Way(e.ref,this.refElems);for(r of e.nodes)s.addNodeRef(r);s.refCount++,this.ways.push(s),this.roles.push(e.role)}else{t=new d.LateBinder(this.ways,e=>{e=this.refElems.get("way/"+e);if(e)return e.refCount++,e},this,[e.ref]);this.ways.push(t),this.roles.push(e.role),this.refElems.addBinder(t)}break;case"node":var o=null;if(e.lat&&e.lon){(o=new l.Node(e.ref,this.refElems)).setLatLng({lon:e.lon,lat:e.lat}),e.tags&&o.addTags(e.tags);for(var[i,n]of Object.entries(e))["id","type","lat","lon"].indexOf(i)<0&&o.addProp(i,n);o.refCount++,this.nodes.push(o)}else{t=new d.LateBinder(this.nodes,e=>{e=this.refElems.get("node/"+e);if(e)return e.refCount++,e},this,[e.ref]);this.nodes.push(t),this.refElems.addBinder(t)}}}constructStringGeometry(e){e=e?e.mergeWays():[];return 0===e.length?null:{type:"MultiLineString",coordinates:e}}constructPolygonGeometry(e,t){var r=e?e.toRings("counterclockwise"):[],s=t?t.toRings("clockwise"):[];if(0<r.length){var o=[];let e;for(e of r)o.push([e]);for(e=s.shift();e;){for(var i in r)if((0,n.pointInsidePolygon)((0,n.first)(e),r[i])){o[i].push(e);break}e=s.shift()}return 1===o.length?{type:"Polygon",coordinates:o[0]}:{type:"MultiPolygon",coordinates:o}}return null}toFeatureArray(){var t,e=[],r=[];let s=[];for(t of this.relations)if(t)for(let e=0;e<t.ways.length;e++){var o=t.ways[e];this.ways.push(o),this.roles.push(t.roles[e])}var i,n={type:"Feature",id:this.getCompositeId(),bbox:this.bounds,properties:this.getProps(),geometry:null};if(this.bounds||delete n.bbox,this.roles.some(e=>"outer"===e)){var a=new g.WayCollection,l=new g.WayCollection;for(let e=0;e<this.ways.length;e++){var d=this.ways[e],u=this.roles[e];"outer"===u?a.addWay(d):"inner"===u&&l.addWay(d)}var h=Object.assign({},n),f=this.constructPolygonGeometry(a,l);f&&(h.geometry=f,e.push(h))}else{var c,p=new g.WayCollection;for(c of this.ways)p.addWay(c);f=this.constructStringGeometry(p);f&&((h=Object.assign({},n)).geometry=f,r.push(h))}for(i of this.nodes)s=s.concat(i.toFeatureArray());return[...e,...r,...s]}}r.Relation=o},{"./late-binder":2,"./node":3,"./osm-object":4,"./utils":8,"./way":10,"./way-collection":9}],8:[function(e,t,r){function s(e){return e[0]}function o(e){return e[e.length-1]}function i(e){return e.join(",")}function n(e){return e.map(parseFloat)}Object.defineProperty(r,"__esModule",{value:!0}),r.purgeProps=function(e,t){if(e){var r=Object.assign({},e);if(t)for(var s of t)delete r[s];return r}return{}},r.first=s,r.last=o,r.coordsToKey=i,r.addToMap=function(e,t,r){var s=e[t];s?s.push(r):e[t]=[r]},r.removeFromMap=function(e,t,r){let s=e[t],o=-1;s&&(o=s.indexOf(r));0<=o&&s.splice(o,1)},r.getFirstFromMap=function(e,t){e=e[t];if(e&&0<e.length)return e[0];return null},r.isRing=function(e){return 3<e.length&&i(e[0])===i(o(e))},r.ringDirection=function(s,o,e){o=o||0,e=e||1;var t=s.reduce((e,t,r)=>s[e][o||0]>t[o||0]?e:r,0),r=t<=0?s.length-2:t-1,i=t>=s.length-1?1:t+1,n=s[r][o],a=s[t][o],l=s[i][o],r=s[r][e],t=s[t][e],i=s[i][e],e=(a-n)*(i-r)-(l-n)*(t-r);return e<0?"clockwise":"counterclockwise"},r.pointInsidePolygon=function(r,s,o,i){o=o||0,i=i||1;let n=!1;for(let e=0,t=s.length-1;e<s.length;t=e++)(s[e][o]<=r[o]&&r[o]<s[t][o]||s[t][o]<=r[o]&&r[o]<s[e][o])&&r[i]<(s[t][i]-s[e][i])*(r[o]-s[e][o])/(s[t][o]-s[e][o])+s[e][i]&&(n=!n);return n},r.strArrayArrayToFloat=function(e){return e.map(n)},r.strArrayToFloat=n},{}],9:[function(e,t,r){Object.defineProperty(r,"__esModule",{value:!0}),r.WayCollection=void 0;let i=e("./utils");class s extends Array{constructor(){super(),this.firstMap={},this.lastMap={}}addWay(e){e=e.toCoordsArray();0<e.length&&(this.push(e),(0,i.addToMap)(this.firstMap,(0,i.coordsToKey)((0,i.first)(e)),e),(0,i.addToMap)(this.lastMap,(0,i.coordsToKey)((0,i.last)(e)),e))}mergeWays(){var r=[];let s=this.shift();for(;s;){(0,i.removeFromMap)(this.firstMap,(0,i.coordsToKey)((0,i.first)(s)),s),(0,i.removeFromMap)(this.lastMap,(0,i.coordsToKey)((0,i.last)(s)),s);let e=s,t;do{var o=this.getNextWay(e),o=(t=o.next,o.mergeType);if(t)switch(this.splice(this.indexOf(t),1),(0,i.removeFromMap)(this.firstMap,(0,i.coordsToKey)((0,i.first)(t)),t),(0,i.removeFromMap)(this.lastMap,(0,i.coordsToKey)((0,i.last)(t)),t),o){case 0:e=e.concat(t.slice(1));break;case 1:t.reverse(),e=e.concat(t.slice(1));break;case 2:e.reverse(),e=e.concat(t.slice(1));break;case 3:e=t.concat(e.slice(1))}}while(t);r.push((0,i.strArrayArrayToFloat)(e)),s=this.shift()}return r}getNextWay(e){var t=(0,i.coordsToKey)((0,i.last)(e)),e=(0,i.coordsToKey)((0,i.first)(e)),r=0<this.length?this[0]:null;if(r){var s=(0,i.coordsToKey)((0,i.first)(r)),o=(0,i.coordsToKey)((0,i.last)(r));if(t===s)return{next:r,mergeType:0};if(t===o)return{next:r,mergeType:1};if(e===s)return{next:r,mergeType:2};if(e===o)return{next:r,mergeType:3}}return(r=(0,i.getFirstFromMap)(this.firstMap,t))?{next:r,mergeType:0}:{next:(0,i.getFirstFromMap)(this.lastMap,t),mergeType:1}}toRings(e){var t=this.mergeWays(),r=[];let s=t.shift();for(;s;)(0,i.isRing)(s)&&((0,i.ringDirection)(s)!==e&&s.reverse(),r.push(s)),s=t.shift();return r}}r.WayCollection=s},{"./utils":8}],10:[function(e,t,r){var s=this&&this.__importDefault||function(e){return e&&e.__esModule?e:{default:e}},o=(Object.defineProperty(r,"__esModule",{value:!0}),r.Way=void 0,e("./osm-object"));let i=e("./late-binder"),n=e("./utils"),a=s(e("./polytags.json"));class l extends o.OsmObject{constructor(e,t){super("way",e,t),this.latLngArray=[],this.isPolygon=!1}addLatLng(e){this.latLngArray.push(e)}setLatLngArray(e){this.latLngArray=e}addNodeRef(e){e=new i.LateBinder(this.latLngArray,e=>{e=this.refElems.get("node/"+e);if(e)return e.refCount++,e.getLatLng()},this,[e]);this.latLngArray.push(e),this.refElems.addBinder(e)}addTags(e){super.addTags(e);for(var[t,r]of Object.entries(e))this.analyzeTag(t,r)}addTag(e,t){super.addTag(e,t),this.analyzeTag(e,t)}toCoordsArray(){return this.latLngArray.map(e=>[e.lon,e.lat])}toFeatureArray(){var e,t=this.toCoordsArray();return 1<t.length?(t=(0,n.strArrayArrayToFloat)(t),e={type:"Feature",id:this.getCompositeId(),properties:this.getProps(),geometry:{type:"LineString",coordinates:t}},this.isPolygon&&(0,n.isRing)(t)&&("counterclockwise"!==(0,n.ringDirection)(t)&&t.reverse(),e.geometry={type:"Polygon",coordinates:[t]}),[e]):[]}analyzeTag(e,t){e=a.default[e];e&&(this.isPolygon=!0,e.whitelist?this.isPolygon=0<=e.whitelist.indexOf(t):e.blacklist&&(this.isPolygon=!(0<=e.blacklist.indexOf(t))))}}r.Way=l},{"./late-binder":2,"./osm-object":4,"./polytags.json":5,"./utils":8}],11:[function(e,t,r){function o(e){return null!==e.match(/^(.+?)\[(.+?)\]>$/g)}function i(e){var t=/^(.+?)\[(.+?)\]>$/g.exec(e);return t?{evt:t[1]+">",exp:t[2]}:{evt:e}}Object.defineProperty(r,"__esModule",{value:!0}),r.XmlParser=void 0;class s{constructor(e){this.queryParent=!1,this.progressive=!1,this.parentMap=new WeakMap,e&&(this.queryParent=!!e.queryParent,this.progressive=e.progressive,this.queryParent)&&(this.parentMap=new WeakMap),this.evtListeners={}}parse(s,o,i){i=i?i+".":"";var n=/<([^ >\/]+)(.*?)>/gm,a=[];let l=n.exec(s);for(;l;){var d=l[1],u={$tag:d},h=i+d,f=l[2].trim();let e=!1;(f.endsWith("/")||d.startsWith("?")||d.startsWith("!"))&&(e=!0);var c,p=/([^ ]+?)="(.+?)"/g,g=/([^ ]+?)='(.+?)'/g;let t=p.exec(f),r=!1;for(;t;)r=!0,u[t[1]]=t[2],t=p.exec(f);if(!r)for(t=g.exec(f);t;)r=!0,u[t[1]]=t[2],t=g.exec(f);r||""===f||(u.text=f),this.progressive&&this.emit(`<${h}>`,u,o),e||((d=new RegExp(`([^]+?)</${d}>`,"g")).lastIndex=n.lastIndex,(c=d.exec(s))&&c[1]&&(n.lastIndex=d.lastIndex,0<(d=this.parse(c[1],u,h)).length?u.$innerNodes=d:u.$innerText=c[1])),this.queryParent&&o&&this.parentMap.set(u,o),this.progressive&&this.emit(`</${h}>`,u,o),a.push(u),l=n.exec(s)}return a}getParent(e){return this.queryParent?this.parentMap.get(e):null}addListener(e,t){var r,s;o(e)&&((r=i(e)).exp&&(t.condition=(s="return "+(s=r.exp).replace(/(\$.+?)(?=[=!.])/g,"node.$&")+";",new Function("node",s))),e=r.evt),this.$addListener(e,t)}removeListener(e,t){o(e)&&(e=i(e).evt),this.$removeListener(e,t)}on(e,t){this.addListener(e,t)}off(e,t){this.removeListener(e,t)}$addListener(e,t){var r=this.evtListeners[e];r?r.push(t):this.evtListeners[e]=[t]}$removeListener(e,t){e=this.evtListeners[e];let r=-1;0<=(r=e?e.indexOf(t):r)&&e.splice(r,1)}emit(e,...t){e=this.evtListeners[e];if(e)for(var r of e)(!r.condition||!0===r.condition.apply(null,t))&&r.apply(null,t)}}r.XmlParser=s},{}]},{},[1])(1)});

package/package.json

@@ -44,7 +44,7 @@
     "polygon",
     "multipolygon"
   ],
-  "license": "ISC",
+  "license": "MIT",
   "main": "dist/node/index.js",
   "types": "dist/node/index.d.ts",
   "name": "osm2geojson-lite",
@@ -61,7 +61,7 @@
   "optionalDependencies": {
     "@types/geojson": "^7946.0.16"
   },
-  "version": "1.1.0",
+  "version": "1.1.2",
   "directories": {
     "lib": "lib",
     "test": "test"