osm2geojson-lite 1.0.3 → 1.1.1

package/README.md

@@ -1,18 +1,15 @@
 osm2geojson-lite
 ============
 
+[![NPM Version](https://img.shields.io/npm/v/osm2geojson-lite)](https://www.npmjs.com/package/osm2geojson-lite) [![Codecov](https://img.shields.io/codecov/c/github/tibetty/osm2geojson-lite/master.svg)](https://codecov.io/gh/tibetty/osm2geojson-lite/)
+
+
 A lightweight (not as lightweight as xml2geojson though) yet faster convertor for [OSM](http://openstreetmap.org) [data](http://wiki.openstreetmap.org/wiki/OSM_XML) whatever in XML or JSON formats to [GeoJSON](http://www.geojson.org/) - much faster (the more complex the data source is, the more performance advantages it posesses) than osmtogeojson in most situations - implemented in pure JavaScript without any 3rd party dependency.
 
 History
 -----
 An internal function inside [query-geo-boundary](https://www.npmjs.com/package/query-geo-boundary) → stripped out to handle OSM XML only [xml2geojson-lite](https://www.npmjs.com/package/xml2geojson-lite) → this library that supports both OSM XML and OSM/Overpass JSON
 
-Changelog:
------
-* Late 2018: this repository was created and the initial version was pushed to github - almost around specific usages for myself.
-* 2019-2025: quite a few contributors had fixed quite a few bugs and also contributed some good ideas - thanks for their efforts!
-* 2025-03-03: fixed a few bugs around non-*Polygon features processing and convert it to a pure TypeScript project (codes published to [NPM](https://npmjs.org/) have become TSC compiled from now on).
-
 Usage
 -----
 
@@ -25,7 +22,7 @@ Installation:
 Usage:
 
 ```js
-    const osm2geojson = require('osm2geojson-lite');
+    import osm2geojson from 'osm2geojson-lite';
     let geojson = osm2geojson(osm, opts);
 ```
 
@@ -46,9 +43,9 @@ Converts OSM data (XML/JSON) to GeoJSON.
 
 * `osm`: the OSM XML data in String, or OSM/Overpass JSON as object or in String
 * `opts?`: optional, the options object, right now supports below properties/fields:
-    - `completeFeature/allFeatures`:  the default value is `false`. 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.
-    - `renderTagged`: the default value is `false`. 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.
-    - `suppressWay/excludeWay`: the default value is `true`. 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.
+    - `completeFeature`:  the default value is `false`. 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.
+    - `renderTagged`: the default value is `false`. When it's set to `true`, the returned geojson will include all elements with tags (i.e., tagged) until `excludeWay` changes its behavior a bit; otherwise only the unreferenced ones get returned.
+    - `excludeWay`: the default value is `true`. 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.
 
 
 Performance
@@ -58,9 +55,8 @@ Performance
 3. For each script, run as many as times seperately and then calculate the average cost time (ACT for short)
 4. The # listed in the table below are coarse lowest values of dividing the ACT of `osmtogeojson` by the one of this library
 ```
-$ cd bench
-$ node o2gl-bench.js
-$ node otg-bench.js
+$ cd test
+$ npm run bench
 ```
 1. XML
    
@@ -79,7 +75,7 @@ Correctness
 ---
 You can copy the converted results to [geojsonlint](http://geojsonlint.com) for the correctness validation.  Up until now, `osm2geojson-lite` behaves pretty well with all the samples (also quite representative) in the `data` subfolers under `test` and `bench` directories, which also outperforms `osmtogeojson`. 
 
-The client side example shipped along with this package, `test/index.html` ~~will automatically call `geojsonlint` validation service directly after each conversion, you can wait for a while to see the validation result after click the conversion button.~~ - because the CORS limitation, the direct post to geojsonlint was blocked, so I added a "copy to clipboard" button for you to ease the validation.
+The client side example shipped along with this package, `test/index.html` - due to CORS limitation, the direct post to geojsonlint is blocked, so there's a "copy to clipboard" button for you to ease the validation.
 
 Node.JS version
 ---
@@ -91,10 +87,10 @@ Dependencies
 
 License
 ---
-Copyleft
+MIT
 
 Collaborators
 ---
-* tibetty
-* HarelM
+* [tibetty](https://github.com/tibetty/)
+* [HarelM](https://github.com/HarelM)
 

package/dist/node/index.d.ts

@@ -1,10 +1,23 @@
-import { FeatureCollection, GeometryObject } from 'geojson';
+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;
-    allFeatures?: 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;
-    suppressWay?: boolean;
 }
 declare function osm2geojson(osm: string | {
     [k: string]: any;

package/dist/node/index.js

@@ -1,172 +1,168 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-const osmobjs_1 = require("./osmobjs");
 const utils_1 = require("./utils");
-const xmlparser_1 = __importDefault(require("./xmlparser"));
-function osm2geojson(osm, opts) {
-    let completeFeature = false;
-    let renderTagged = false;
-    let excludeWay = true;
-    const parseOpts = (os) => {
-        if (os) {
-            completeFeature = os.completeFeature || os.allFeatures ? true : false;
-            renderTagged = os.renderTagged ? true : false;
-            const wayOpt = os.suppressWay || os.excludeWay;
-            if (wayOpt !== undefined && !wayOpt) {
-                excludeWay = false;
-            }
-        }
-    };
-    if (opts) {
-        parseOpts(opts);
+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 };
     }
-    const detectFormat = (o) => {
-        if (o.elements) {
-            return 'json';
-        }
-        if (o.indexOf('<osm') >= 0) {
-            return 'xml';
-        }
-        if (o.trim().startsWith('{')) {
-            return 'json-raw';
-        }
-        return 'invalid';
-    };
-    let format = detectFormat(osm);
-    const refElements = new utils_1.RefElements();
-    let featureArray = [];
-    const analyzeFeaturesFromJson = (o) => {
-        for (const elem of osm.elements) {
-            switch (elem.type) {
-                case 'node':
-                    const node = new osmobjs_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 osmobjs_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 osmobjs_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;
-            }
-        }
-    };
-    const analyzeFeaturesFromXml = (o) => {
-        const xmlParser = new xmlparser_1.default({ progressive: true });
-        xmlParser.on('</osm.node>', (node) => {
-            const nd = new osmobjs_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);
+    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);
                 }
-            }
-            nd.setLatLng(node);
-            if (node.$innerNodes) {
-                for (const ind of node.$innerNodes) {
-                    if (ind.$tag === 'tag') {
-                        nd.addTag(ind.k, ind.v);
-                    }
+                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);
                 }
-            }
-        });
-        xmlParser.on('</osm.way>', (node) => {
-            const way = new osmobjs_1.Way(node.id, refElements);
-            for (const [k, v] of Object.entries(node)) {
-                if (!k.startsWith('$') && ['id'].indexOf(k) < 0) {
-                    way.addProp(k, v);
+                way.addProps((0, utils_1.purgeProps)(elem, ['id', 'type', 'tags', 'nodes', 'geometry']));
+                if (elem.geometry) {
+                    way.setLatLngArray(elem.geometry);
                 }
-            }
-            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 (elem.nodes) {
+                    for (const n of elem.nodes) {
+                        way.addNodeRef(n);
                     }
-                    else if (ind.$tag === 'tag') {
-                        way.addTag(ind.k, ind.v);
+                }
+                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);
             }
-        });
-        xmlParser.on('<osm.relation>', (node) => new osmobjs_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;
-                    }
+        }
+        nd.setLatLng(node);
+        if (node.$innerNodes) {
+            for (const ind of node.$innerNodes) {
+                if (ind.$tag === 'tag') {
+                    nd.addTag(ind.k, ind.v);
                 }
             }
-            if (node.$innerNodes) {
-                const geometry = [];
-                const nodes = [];
-                for (const ind of node.$innerNodes) {
-                    if (ind.lat && ind.lon) {
-                        geometry.push(ind);
+        }
+    });
+    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) {
-                        nodes.push(ind.ref);
+                        way.addNodeRef(ind.ref);
                     }
                 }
-                if (geometry.length > 0) {
-                    member.geometry = geometry;
+                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 (nodes.length > 0) {
-                    member.nodes = nodes;
+                else if (ind.ref) {
+                    nodes.push(ind.ref);
                 }
             }
-            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(o);
-    };
+            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) {
@@ -177,21 +173,22 @@ function osm2geojson(osm, opts) {
         }
     }
     if (format === 'json') {
-        analyzeFeaturesFromJson(osm);
+        analyzeFeaturesFromJson(osm, refElements);
     }
     else if (format === 'xml') {
-        analyzeFeaturesFromXml(osm);
+        analyzeFeaturesFromXml(osm, refElements);
     }
     refElements.bindAll();
     for (const v of refElements.values()) {
-        if (v.refCount <= 0 || (v.hasTag && renderTagged && !(v instanceof osmobjs_1.Way && excludeWay))) {
-            const features = v.toFeatureArray();
-            // return the first geometry of the first relation element
-            if (v instanceof osmobjs_1.Relation && !completeFeature && features.length > 0) {
-                return features[0].geometry;
-            }
-            featureArray = featureArray.concat(features);
+        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 };
 }

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/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>>;
+}