{"id":15887925,"url":"https://github.com/iwpnd/tile38-ts","last_synced_at":"2026-04-02T00:02:00.229Z","repository":{"id":36974022,"uuid":"501163921","full_name":"iwpnd/tile38-ts","owner":"iwpnd","description":"TypeScript client for Tile38 geo-database","archived":false,"fork":false,"pushed_at":"2026-03-22T21:35:33.000Z","size":2212,"stargazers_count":52,"open_issues_count":0,"forks_count":4,"subscribers_count":5,"default_branch":"main","last_synced_at":"2026-03-23T14:23:03.918Z","etag":null,"topics":["database","geospatial","tile38","tile38-client","typescript"],"latest_commit_sha":null,"homepage":"https://tile38.com","language":"TypeScript","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/iwpnd.png","metadata":{"files":{"readme":"README.md","changelog":"CHANGELOG.md","contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2022-06-08T08:29:39.000Z","updated_at":"2026-03-22T21:35:35.000Z","dependencies_parsed_at":"2023-11-14T08:41:52.912Z","dependency_job_id":"d1c615d5-4daf-49c6-887d-01b56733f4a8","html_url":"https://github.com/iwpnd/tile38-ts","commit_stats":{"total_commits":192,"total_committers":4,"mean_commits":48.0,"dds":"0.19270833333333337","last_synced_commit":"00f1e0d796cfd137bb9b96cc52d2d1a0a7b60758"},"previous_names":["iwpnd/tile38-ts","tiermobility/tile38-ts"],"tags_count":43,"template":false,"template_full_name":null,"purl":"pkg:github/iwpnd/tile38-ts","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/iwpnd%2Ftile38-ts","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/iwpnd%2Ftile38-ts/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/iwpnd%2Ftile38-ts/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/iwpnd%2Ftile38-ts/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/iwpnd","download_url":"https://codeload.github.com/iwpnd/tile38-ts/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/iwpnd%2Ftile38-ts/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":31293139,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-04-01T21:15:39.731Z","status":"ssl_error","status_checked_at":"2026-04-01T21:15:34.046Z","response_time":53,"last_error":"SSL_read: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["database","geospatial","tile38","tile38-client","typescript"],"created_at":"2024-10-06T06:05:43.257Z","updated_at":"2026-04-02T00:02:00.122Z","avatar_url":"https://github.com/iwpnd.png","language":"TypeScript","funding_links":[],"categories":["TypeScript"],"sub_categories":[],"readme":"\u003cbr  /\u003e\n\u003c!-- \u003cp align=\"center\"\u003e --\u003e\n\u003c!-- \u003ca  href=\"tile38-ts.png\"\u003e\n\u003cimg  src=\"tile38-ts.png\"  alt=\"Logo\"  width=\"487\"  height=\"281\"\u003e\n\u003c/a\u003e --\u003e\n\u003ch1 align=\"center\"\u003eTile38-ts\u003c/h1\u003e\n\u003cp align=\"center\"\u003e\n\u003ca  href=\"https://github.com/iwpnd/tile38-ts/issues\"\u003eReport Bug\u003c/a\u003e\n· \u003ca  href=\"https://github.com/iwpnd/tile38-ts/issues\"\u003eRequest Feature\u003c/a\u003e\n\u003c/p\u003e\n\u003c/p\u003e\n\u003cdetails  open=\"open\"\u003e\n\u003csummary\u003eTable of Contents\u003c/summary\u003e\n\u003col\u003e\n\u003cli\u003e\n\u003ca  href=\"#about-the-project\"\u003eAbout The Project\u003c/a\u003e\n\u003cul\u003e\n\u003cli\u003e\u003ca  href=\"#built-with\"\u003eBuilt With\u003c/a\u003e\u003c/li\u003e\n\u003c/ul\u003e\n\u003c/li\u003e\n\u003cli\u003e\n\u003ca  href=\"#getting-started\"\u003eGetting Started\u003c/a\u003e\n\u003cul\u003e\n\u003cli\u003e\u003ca  href=\"#requirements\"\u003eRequirements\u003c/a\u003e\u003c/li\u003e\n\u003cli\u003e\u003ca  href=\"#installation\"\u003eInstallation\u003c/a\u003e\u003c/li\u003e\n\u003c/ul\u003e\n\u003c/li\u003e\n\u003cli\u003e\u003ca  href=\"#commands\"\u003eCommands\u003c/a\u003e\u003c/li\u003e\n\u003cul\u003e\n\u003cli\u003e\u003ca  href=\"#keys\"\u003eKeys\u003c/a\u003e\u003c/li\u003e\n\u003cli\u003e\u003ca  href=\"#search\"\u003eSearch\u003c/a\u003e\u003c/li\u003e\n\u003cli\u003e\u003ca  href=\"#geofencing\"\u003eGeofencing\u003c/a\u003e\u003c/li\u003e\n\u003cli\u003e\u003ca  href=\"#server\"\u003eServer / Connection\u003c/a\u003e\u003c/li\u003e\n\u003c/ul\u003e\n\u003cli\u003e\u003ca  href=\"#roadmap\"\u003eRoadmap\u003c/a\u003e\u003c/li\u003e\n\u003cli\u003e\u003ca  href=\"#contributing\"\u003eContributing\u003c/a\u003e\u003c/li\u003e\n\u003cli\u003e\u003ca  href=\"#license\"\u003eLicense\u003c/a\u003e\u003c/li\u003e\n\u003cli\u003e\u003ca  href=\"#contact\"\u003eMaintainer\u003c/a\u003e\u003c/li\u003e\n\u003cli\u003e\u003ca  href=\"#acknowledgements\"\u003eAcknowledgements\u003c/a\u003e\u003c/li\u003e\n\u003c/ol\u003e\n\u003c/details\u003e\n\n## About The Project\n\nThis is a Typescript client for Tile38 that allows for a type-safe interaction with the worlds fastest in-memory geodatabase [Tile38](https://www.tile38.com).\n\n### Features\n\n- fully typed\n- lazy client\n- optional build-in leader/follower logic\n- easy to use and integrate\n- no external dependencies other than redis\n- build in auto-pagination\n\n### Built With\n\n- [ioredis](https://www.npmjs.com/package/ioredis)\n\n## Getting Started\n\n### Requirements\n\n```sh\n\"node\": \"\u003e=20.x\"\n\"ioredis\" \"\u003e=5.0.0\"\n```\n\n### Installation\n\n```sh\nyarn add @iwpnd/tile38-ts\n```\n\n### Import\n\n\u003e [!IMPORTANT]  \n\u003e As of 1.36.5 Tile38 supports the `-o json` start up flag on the tile38-server.\n\u003e This flag defaults the output from `RESP` to `JSON`. As `tile38-ts` is expecting\n\u003e to manage the `OUTPUT` of tile38, this will break compatibility. \n\u003e If you're using `tile38-ts`, to not change the default output.\n\n```typescript\nimport { Tile38 } from '@iwpnd/tile38-ts';\n\nconst tile38 = new Tile38('leader:9851');\n```\n\n### Leader / Follower\n\nWhen it comes to replication, Tile38 follows a leader-follower model. The leader receives all commands that `SET` data, a follower on the other hand is `read-only` and can only query data. For more on replication in Tile38 refer to the [official documentation](https://tile38.com/topics/replication).\n\nThis client is not meant to setup a replication, because this should happen in your infrastructure. But it helps you to specifically execute commands on leader or follower. This way you can make sure that the leader always has enough resources to execute `SET`s and fire `geofence` events on `webhooks`.\n\nFor now we allow for one follower `URI` to bet set alongside the leader `URI`.\n\n```typescript\nconst tile38 = new Tile38('leader:9851', 'follower:9851');\n```\n\nOnce the client is instantiated with a follower, commands can be explicitly send\nto the follower, but adding `.follower()` to your command chaining.\n\n```typescript\nawait tile38.follower().get('fleet', 'truck1').asObjects();\n```\n\n### Options\n\nWe expose `ioredis` [RedisOptions](https://redis.github.io/ioredis/index.html#RedisOptions).\n\n```typescript\nnew Tile38(\n    'leader:9851',\n    'follower:9851',\n    // e.g. to set a retry strategy\n    {\n        retryStrategy: (times) =\u003e {\n            return Math.min(times * 50, 2000);\n        },\n    }\n);\n```\n\n### Events\n\nWe expose `ioredis` [Events](https://github.com/redis/ioredis#events).\n\n```typescript\nnew Tile38()\n    .on('connect', () =\u003e console.log('connected'))\n    .on('error', console.error);\n```\n\n### Pagination\n\nTile38 has hidden limits set for the amount of objects that can be returned in one request. For most queries/searches this limit is set to `100`. This client gives you the option to either paginate the results yourself by add `.cursor()` and `.limit()` to your queries, or it abstracts pagination away from the user by adding `.all()`.\n\nLet's say your `fleet` in `Berlin` extends 100 vehicles, then\n\n```typescript\nawait tile38.within('fleet').get('cities', 'Berlin').asObjects();\n```\n\nwill only return 100 vehicle objects. Now you can either get the rest by setting the limit to the amount of vehicles you have in the city and get them all.\n\n```typescript\nawait tile38.within('fleet').limit(10000).get('cities', 'Berlin').asObjects();\n```\n\nOr, you can paginate the results in multiple concurrent requests to fit your requirements.\n\n```typescript\nawait tile38\n    .within('fleet')\n    .cursor(0)\n    .limit(100)\n    .get('cities', 'Berlin')\n    .asObjects();\nawait tile38\n    .within('fleet')\n    .cursor(100)\n    .limit(100)\n    .get('cities', 'Berlin')\n    .asObjects();\nawait tile38\n    .within('fleet')\n    .cursor(200)\n    .limit(100)\n    .get('cities', 'Berlin')\n    .asObjects();\n```\n\nOr, you use `.all()` to get all objects with a concurrency of 1 and a limit of 100:\n\n```typescript\nawait tile38\n    .follower()\n    .within('fleet')\n    .get('cities', 'Berlin')\n    .all()\n    .asObjects();\n```\n\n## Commands\n\n### Keys\n\n#### SET\n\nSet the value of an id. If a value is already associated to that key/id, it'll be overwritten.\n\n```typescript\nawait tile38\n    .set('fleet', 'truck1')\n    .fields({ maxSpeed: 90, milage: 90000 })\n    .point(33.5123, -112.2693)\n    .exec();\n\nawait tile38.set('fleet', 'truck1:driver').string('John Denton').exec();\n```\n\n**Options**\n|| |\n|--|--|\n| `.fields()` | Optional additional fields. **MUST BE** numerical|\n| `.ex(value)` | Set the specified expire time, in seconds.|\n| `.nx()` | Only set the object if it does not already exist.|\n| `.xx()` | Only set the object if it already exist.|\n\n**Input**\n| | |\n|--|--|\n| `.point(lat, lon)` | Set a simple point in latitude, longitude |\n| `.bounds(minlat, minlon, maxlat, maxlon)` | Set as minimum bounding rectangle |\n| `.object(feature)` | Set as feature |\n| `.hash(geohash)` | Set as geohash |\n| `.string(value)` | Set as string. To retrieve string values you can use `.get()`, `scan()` or `.search()` |\n\n#### FSET\n\nSet the value for one or more fields of an object. Fields must be double precision floating points. Returns the integer count of how many fields changed their values.\n\n```typescript\nawait tile38.fSet('fleet', 'truck1', { maxSpeed: 90, milage: 90000 });\n```\n\n#### FEXISTS\n\nValidate if field exists on id.\n\n```typescript\nawait tile38\n    .set('fleet', 'truck1')\n    .fields({ weight: 9001 })\n    .point(33.5123, -112.2693)\n    .exec();\n\nlet response = await tile38.fexists('fleet', 'truck1', 'weight');\nconsole.log(response.exists);\n// \u003e true\n\nresponse = await tile38.fexists('fleet', 'truck1', 'milage');\nconsole.log(response.exists);\n// \u003e false\n```\n\n**Options**\n\n| command | description                                                                                                                                                                                      |\n| ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |\n| `.xx()` | `FSET` returns error if fields are set on non-existing ids. `xx()` options changes this behaviour and instead returns `0` if id does not exist. If key does not exist `FSET` still returns error |\n\n#### GET\n\nGet the object of an id.\n\n```typescript\nawait tile38.get('fleet', 'truck1').asObject();\n```\n\nGet the object as string if set as string\n\n```typescript\nawait tile38.set('fleet', 'truck1:driver').string('John').exec();\nawait tile38.get('fleet', 'truck1').asString();\n```\n\n**Options**\n\n| command         | description                                                                                                                                       |\n| --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `.withFields()` | will also return the [fields](https://tile38.com/commands/set#fields) that belong to the object. Field values that are equal to zero are omitted. |\n\n**Output**\n\n| command              | description                       |\n| -------------------- | --------------------------------- |\n| `.asObject()`        | (default) get as object           |\n| `.asBounds()`        | get as minimum bounding rectangle |\n| `.asHash(precision)` | get as hash                       |\n| `.asPoint()`         | get as point                      |\n| `.asString()`        | get as string                     |\n\n#### EXISTS\n\nValidate id exists.\n\n```typescript\nawait tile38.set('fleet', 'truck1').point(33.5123, -112.2693).exec();\n\nlet response = await tile38.exists('fleet', 'truck1');\nconsole.log(response.exists);\n// \u003e true\n\nresponse = await tile38.exists('fleet', 'truck2');\nconsole.log(response.exists);\n// \u003e false\n```\n\n#### DEL\n\nRemove a specific object by key and id.\n\n```typescript\nawait tile38.del('fleet', 'truck1');\n```\n\n#### PDEL\n\nRemove objects that match a given pattern.\n\n```typescript\nawait tile38.pDel('fleet', 'truck*');\n```\n\n#### DROP\n\nRemove all objects in a given key.\n\n```typescript\nawait tile38.drop('fleet');\n```\n\n#### BOUNDS\n\nGet the minimum bounding rectangle for all objects in a given key\n\n```typescript\nawait tile38.bounds('fleet');\n```\n\n#### EXPIRE\n\nSet an expiration/time to live in seconds of an object.\n\n```typescript\nawait tile38.expire('fleet', 'truck1', 10);\n```\n\n#### TTL\n\nGet the expiration/time to live in seconds of an object.\n\n```typescript\nawait tile38.ttl('fleet', 'truck1', 10);\n```\n\n#### PERSIST\n\nRemove an existing expiration/time to live of an object.\n\n```typescript\nawait tile38.persist('fleet', 'truck1');\n```\n\n#### KEYS\n\nGet all keys matching a glob-style-pattern. Pattern defaults to `'*'`\n\n```typescript\nawait tile38.keys();\n```\n\n#### STATS\n\nReturn stats for one or more keys.\nThe returned `stats` array contains one or more entries, depending on the number of keys in the request.\n\n```typescript\nawait tile38.stats('fleet1', 'fleet2');\n```\n\n**Returns**\n\n| stat             | description                                     |\n| ---------------- | ----------------------------------------------- |\n| `in_memory_size` | estimated memory size in bytes                  |\n| `num_objects`    | objects in the given key                        |\n| `num_points`     | number of geographical objects in the given key |\n\n#### JSET/JSET/JDEL\n\nSet a value in a JSON document.\nJGET, JSET, and JDEL allow for working with JSON strings\n\n```typescript\nawait tile38.jSet('user', 901, 'name', 'Tom');\nawait tile38.jGet('user', 901);\n\u003e {'name': 'Tom'}\n\nawait tile38.jSet('user', 901, 'name.first', 'Tom');\nawait tile38.jSet('user', 901, 'name.first', 'Anderson');\nawait tile38.jGet('user', 901);\n\u003e {'name': { 'first': 'Tom', 'last': 'Anderson' }}\n\nawait tile38.jDel('user', 901, 'name.last');\nawait tile38.jGet('user', 901);\n\u003e {'name': { 'first': 'Tom' }}\n```\n\n#### RENAME\n\nRenames a collection `key` to `newKey`.\n\n**Options**\n\n| command | description                                                                      |\n| ------- | -------------------------------------------------------------------------------- |\n| `.nx()` | Default: false. Changes behavior on how renaming acts if `newKey` already exists |\n\nIf the `newKey` already exists it will be deleted prior to renaming.\n\n```typescript\nawait tile38.rename('fleet', 'newFleet', false);\n```\n\nIf the `newKey` already exists it will do nothing.\n\n```typescript\nawait tile38.rename('fleet', 'newFleet', true);\n```\n\n### Search\n\nSearches are [Tile38](https://tile38.com/) bread and butter. They are what make Tile38 a ultra-fast, serious and cheap alternative to [PostGIS](https://postgis.net/) for a lot of use-cases.\n\n#### WITHIN\n\n`WITHIN` searches a key for objects that are fully contained within a given bounding area.\n\n```typescript\nawait tile38.within('fleet').bounds(33.462, -112.268,  33.491, -112.245);\n\u003e{\"ok\":true,\"objects\":[{\"id\":\"1\",\"object\":{\"type\":\"Feature\",\"geometry\":{\"type\":\"Point\",\"coordinates\":[-112.2693, 33.5123]},\"properties\":{}}}],\"count\":1,\"cursor\":1,\"elapsed\":\"72.527µs\"}\n\nawait tile38.within('fleet').noFields().asCount()\n\u003e {\"ok\":true,\"count\":205,\"cursor\":0,\"elapsed\":\"2.078168ms\"}\n\nawait tile38.within('fleet').get('warehouses', 'Berlin').asCount();\n\u003e {\"ok\":true,\"count\":50,\"cursor\":0,\"elapsed\":\"2.078168ms\"}\n\nawait tile38.within('fleet').buffer(100).get('warehouses', 'Berlin').asCount();\n\u003e {\"ok\":true,\"count\":50,\"cursor\":0,\"elapsed\":\"2.078168ms\"}\n\nawait tile38\n    .within('fleet')\n    .where('weight', 1000, 1200)\n    .get('warehouses', 'Berlin').asCount();\n\u003e {\"ok\":true,\"count\":50,\"cursor\":0,\"elapsed\":\"2.078168ms\"}\n\nawait tile38\n    .within('fleet')\n    .whereIn('weight', [1000, 1001, 1002])\n    .get('warehouses', 'Berlin').asCount();\n\n\u003e {\"ok\":true,\"count\":50,\"cursor\":0,\"elapsed\":\"2.078168ms\"}\n\nawait tile38\n    .within('fleet')\n    .whereExpr(\"weight == 1000\")\n    .get('warehouses', 'Berlin').asCount();\n\n\u003e {\"ok\":true,\"count\":50,\"cursor\":0,\"elapsed\":\"2.078168ms\"}\n```\n\n**Options**\n\n| command                                   | description                                                                                                                                                                 |\n| ----------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `.cursor(value?)`                         | used to iterate through your search results. Defaults to `0` if not set explicitly                                                                                          |\n| `.limit(value?)`                          | limit the number of returned objects. Defaults to `100` if not set explicitly                                                                                               |\n| `.noFields()`                             | if not set and one of the objects in the key has fields attached, fields will be returned. Use this to suppress this behavior and don't return fields.                      |\n| `.match(pattern?)`                        | Match can be used to filtered objects considered in the search with a glob pattern. `.match('truck*')` e.g. will only consider ids that start with `truck` within your key. |\n| `.sparse(value)`                          | **caution** seems bugged since Tile38 1.22.6. Accepts values between 1 and 8. Can be used to distribute the results of a search evenly across the requested area.           |\n| `.buffer(value)`                          | Apply a buffer around area formats to increase the search area by x meters                                                                                                  |\n| `.where(fieldname, min value, max value)` | filter output by fieldname and values.                                                                                                                                      |\n| `.wherein(fieldname, values)`             | filter output by fieldname and values. Returns if field value in list of values.                                                                                            |\n| `.whereExpr(expr)`                        | filter output with [filter-expression](https://tile38.com/topics/filter-expressions).                                                                                       |\n\n**Outputs**\n\n| command                | description                                                                                                                                                                        |\n| ---------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `.asObjects()`         | return as array of objects                                                                                                                                                         |\n| `.asBounds()`          | return as array of minimum bounding rectangles: `{\"id\": string,\"bounds\":{\"sw\":{\"lat\": number,\"lon\": number},\"ne\":{\"lat\": number,\"lon\": number}}}`                                  |\n| `.asCount()`           | returns a count of the objects in the search                                                                                                                                       |\n| `.asHashes(precision)` | returns an array of `{\"id\": string,\"hash\": string}`                                                                                                                                |\n| `.asIds()`             | returns an array of ids                                                                                                                                                            |\n| `.asPoints()`          | returns objects as points: `{\"id\": string,\"point\":{\"lat\": number,\"lon\": number}`. If the searched key is a collection of `Polygon` objects, the returned points are the centroids. |\n\n**Query**\n\n| command                                   | description                                                                                                            |\n| ----------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |\n| `.get(key, id)`                           | Search a given stored item in a collection.                                                                            |\n| `.circle(lat, lon, radius)`               | Search a given circle of latitude, longitude and radius.                                                               |\n| `.bounds(minLat, minLon, maxLat, maxLon)` | Search a given bounding box.                                                                                           |\n| `.hash(value)`                            | Search a given [geohash](https://en.wikipedia.org/wiki/Geohash).                                                       |\n| `.quadkey(value)`                         | Search a given [quadkey](https://docs.microsoft.com/en-us/bingmaps/articles/bing-maps-tile-system?redirectedfrom=MSDN) |\n| `.tile(x, y, z)`                          | Search a given [tile](https://en.wikipedia.org/wiki/Tiled_web_map#Defining_a_tiled_web_map)                            |\n| `.object(value)`                          | Search a given GeoJSON polygon feature.                                                                                |\n\n#### INTERSECTS\n\nIntersects searches a key for objects that are fully contained within a given bounding area, but also returns those that intersect the requested area.\nWhen used to search a collection of keys consisting of `Point` objects (e.g. vehicle movement data) it works like a `.within()` search as `Points` cannot intersect.\nWhen used to search a collection of keys consisting of `Polygon` or `LineString` it also returns objects, that only partly overlap the requested area.\n\n```typescript\nawait  tile38.intersects('warehouses').hash('u33d').asObjects();\n\nawait tile38.intersects('fleet').get('warehouses', 'Berlin').asIds();\n\u003e {\"ok\":true,\"ids\":[\"truck1\"],\"count\":1,\"cursor\":0,\"elapsed\":\"2.078168ms\"}\n\nawait tile38\n    .intersects('fleet')\n    .where('weight', 1000, 1200)\n    .get('warehouses', 'Berlin').asCount();\n\u003e {\"ok\":true,\"count\":50,\"cursor\":0,\"elapsed\":\"2.078168ms\"}\n\nawait tile38\n    .intersects('fleet')\n    .whereIn('weight', [1000, 1001, 1002])\n    .get('warehouses', 'Berlin').asCount();\n\n\u003e {\"ok\":true,\"count\":50,\"cursor\":0,\"elapsed\":\"2.078168ms\"}\n\nawait tile38\n    .intersects('fleet')\n    .whereExpr(\"weight == 1000\")\n    .get('warehouses', 'Berlin').asCount();\n\n\u003e {\"ok\":true,\"count\":50,\"cursor\":0,\"elapsed\":\"2.078168ms\"}\n```\n\n**Options**\n\n| command                                   | description                                                                                                                                                                         |\n| ----------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `.clip()`                                 | Tells Tile38 to clip returned objects at the bounding box of the requested area. Works with `.bounds()`, `.hash()`, `.tile()` and `.quadkey()`                                      |\n| `.cursor(value?)`                         | used to iterate through your search results. Defaults to `0` if not set explicitly                                                                                                  |\n| `.limit(value?)`                          | limit the number of returned objects. Defaults to `100` if not set explicitly                                                                                                       |\n| `.noFields()`                             | if not set and one of the objects in the key has fields attached, fields will be returned. Use this to suppress this behavior and don't return fields.                              |\n| `.match(pattern?)`                        | Match can be used to filtered objects considered in the search with a glob pattern. `.match('warehouse*')` e.g. will only consider ids that start with `warehouse` within your key. |\n| `.sparse(value)`                          | **caution** seems bugged since Tile38 1.22.6. Accepts values between 1 and 8. Can be used to distribute the results of a search evenly across the requested area.                   |\n| `.buffer(value)`                          | Apply a buffer around area formats to increase the search area by x meters                                                                                                          |\n| `.where(fieldname, min value, max value)` | filter output by fieldname and values.                                                                                                                                              |\n| `.wherein(fieldname, values)`             | filter output by fieldname and values. Returns if field value in list of values.                                                                                                    |\n| `.whereExpr(expr)`                        | filter output with [filter-expression](https://tile38.com/topics/filter-expressions).                                                                                               |\n\n**Outputs**\n\n| command                | description                                                                                                                                                                        |\n| ---------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `.asObjects()`         | return as array of objects                                                                                                                                                         |\n| `.asBounds()`          | return as array of minimum bounding rectangles: `{\"id\": string,\"bounds\":{\"sw\":{\"lat\": number,\"lon\": number},\"ne\":{\"lat\": number,\"lon\": number}}}`                                  |\n| `.asCount()`           | returns a count of the objects in the search                                                                                                                                       |\n| `.asHashes(precision)` | returns an array of `{\"id\": string,\"hash\": string}`                                                                                                                                |\n| `.asIds()`             | returns an array of ids                                                                                                                                                            |\n| `.asPoints()`          | returns objects as points: `{\"id\": string,\"point\":{\"lat\": number,\"lon\": number}`. If the searched key is a collection of `Polygon` objects, the returned points are the centroids. |\n\n**Query**\n\n| command                                   | description                                                                                                            |\n| ----------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |\n| `.get(key, id)`                           | Search a given stored item in a collection.                                                                            |\n| `.circle(lat, lon, radius)`               | Search a given circle of latitude, longitude and radius.                                                               |\n| `.bounds(minLat, minLon, maxLat, maxLon)` | Search a given bounding box.                                                                                           |\n| `.hash(value)`                            | Search a given [geohash](https://en.wikipedia.org/wiki/Geohash).                                                       |\n| `.quadkey(value)`                         | Search a given [quadkey](https://docs.microsoft.com/en-us/bingmaps/articles/bing-maps-tile-system?redirectedfrom=MSDN) |\n| `.tile(x, y, z)`                          | Search a given [tile](https://en.wikipedia.org/wiki/Tiled_web_map#Defining_a_tiled_web_map)                            |\n| `.object(value)`                          | Search a given GeoJSON polygon feature.                                                                                |\n\n#### Nearby\n\n```typescript\nawait tile38.set('fleet', 'truck1').point(33.5123, -112.2693).exec();\n\nawait  tile38.nearby('fleet').point(33.5124, -112.2694).asCount();\n\u003e {\"ok\":true,\"count\":1,\"cursor\":0,\"elapsed\":\"42.8µs\"}\n\nawait  tile38.nearby('fleet').point(33.5124, -112.2694, 10).asCount();\n// because truck1 is further away than 10m\n\u003e {\"ok\":true,\"count\":0,\"cursor\":0,\"elapsed\":\"36µs\"}\n\n// asIds request\nawait  tile38.nearby('fleet').point(33.5124, -112.2694).asIds();\n\u003e {\"ok\":true,\"ids\":['truck1'],\"cursor\":0,\"elapsed\":\"36µs\"}\n// asIds with distance\nawait  tile38.nearby('fleet').distance().point(33.5124, -112.2694).asIds();\n\u003e {\"ok\":true,\"ids\":[{ \"id\":\"truck1\", \"distance\": 1 }],\"cursor\":0,\"elapsed\":\"36µs\"}\n\nawait tile38\n    .nearby('fleet')\n    .where('weight', 1000, 1200)\n    .point(33.5124, -112.2694, 10).asCount();\n\n\u003e {\"ok\":true,\"count\":50,\"cursor\":0,\"elapsed\":\"2.078168ms\"}\n\nawait tile38\n    .nearby('fleet')\n    .whereIn('weight', [1000, 1001, 1002])\n    .point(33.5124, -112.2694, 10).asCount();\n\u003e {\"ok\":true,\"count\":50,\"cursor\":0,\"elapsed\":\"2.078168ms\"}\n\nawait tile38\n    .nearby('fleet')\n    .whereExpr(\"weight == 1000\")\n    .point(33.5124, -112.2694, 10).asCount();\n\n\u003e {\"ok\":true,\"count\":50,\"cursor\":0,\"elapsed\":\"2.078168ms\"}\n```\n\n**Options**\n\n| command                                   | description                                                                                                                                                                         |\n| ----------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `.distance()`                             | Returns the distance in `meters` to the object from the query `.point()`                                                                                                            |\n| `.cursor(value?)`                         | used to iterate through your search results. Defaults to `0` if not set explicitly                                                                                                  |\n| `.limit(value?)`                          | limit the number of returned objects. Defaults to `100` if not set explicitly                                                                                                       |\n| `.noFields()`                             | if not set and one of the objects in the key has fields attached, fields will be returned. Use this to suppress this behavior and don't return fields.                              |\n| `.match(pattern?)`                        | Match can be used to filtered objects considered in the search with a glob pattern. `.match('warehouse*')` e.g. will only consider ids that start with `warehouse` within your key. |\n| `.sparse(value)`                          | **caution** seems bugged since Tile38 1.22.6. Accepts values between 1 and 8. Can be used to distribute the results of a search evenly across the requested area.                   |\n| `.where(fieldname, min value, max value)` | filter output by fieldname and values.                                                                                                                                              |\n| `.wherein(fieldname, values)`             | filter output by fieldname and values. Returns if field value in list of values.                                                                                                    |\n| `.whereExpr(expr)`                        | filter output with [filter-expression](https://tile38.com/topics/filter-expressions).                                                                                               |\n\n**Outputs**\n\n| command                | description                                                                                                                                                                        |\n| ---------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `.asObjects()`         | return as array of objects                                                                                                                                                         |\n| `.asBounds()`          | return as array of minimum bounding rectangles: `{\"id\": string,\"bounds\":{\"sw\":{\"lat\": number,\"lon\": number},\"ne\":{\"lat\": number,\"lon\": number}}}`                                  |\n| `.asCount()`           | returns a count of the objects in the search                                                                                                                                       |\n| `.asHashes(precision)` | returns an array of `{\"id\": string,\"hash\": string}`                                                                                                                                |\n| `.asIds()`             | returns an array of ids                                                                                                                                                            |\n| `.asPoints()`          | returns objects as points: `{\"id\": string,\"point\":{\"lat\": number,\"lon\": number}`. If the searched key is a collection of `Polygon` objects, the returned points are the centroids. |\n\n**Query**\n\n| command                     | description                                                                                       |\n| --------------------------- | ------------------------------------------------------------------------------------------------- |\n| `.point(lat, lon, radius?)` | Search nearby a given of latitude, longitude. If radius is set, searches nearby the given radius. |\n\n#### Scan\n\nIncrementally iterate through a given collection key.\n\n```typescript\nawait tile38.scan('fleet');\n\nawait tile38.scan('fleet').where('foo', 1, 2);\nawait tile38.scan('fleet').wherein('foo', [1, 2]);\nawait tile38.scan('fleet').whereExpr('foo == 1');\n```\n\n**Options**\n\n| command                                   | description                                                                                                                                                                         |\n| ----------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `.asc()`                                  | Values are returned in ascending order. Default if not set.                                                                                                                         |\n| `.desc()`                                 | Values are returned in descending order.                                                                                                                                            |\n| `.cursor(value?)`                         | used to iterate through your search results. Defaults to `0` if not set explicitly                                                                                                  |\n| `.limit(value?)`                          | limit the number of returned objects. Defaults to `100` if not set explicitly                                                                                                       |\n| `.noFields()`                             | if not set and one of the objects in the key has fields attached, fields will be returned. Use this to suppress this behavior and don't return fields.                              |\n| `.match(pattern?)`                        | Match can be used to filtered objects considered in the search with a glob pattern. `.match('warehouse*')` e.g. will only consider ids that start with `warehouse` within your key. |\n| `.where(fieldname, min value, max value)` | filter output by fieldname and values.                                                                                                                                              |\n| `.wherein(fieldname, values)`             | filter output by fieldname and values. Returns if field value in list of values.                                                                                                    |\n| `.whereExpr(expr)`                        | filter output with [filter-expression](https://tile38.com/topics/filter-expressions).                                                                                               |\n\n**Outputs**\n\n| command                | description                                                                                                                                                                        |\n| ---------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `.asObjects()`         | return as array of objects                                                                                                                                                         |\n| `.asBounds()`          | return as array of minimum bounding rectangles: `{\"id\": string,\"bounds\":{\"sw\":{\"lat\": number,\"lon\": number},\"ne\":{\"lat\": number,\"lon\": number}}}`                                  |\n| `.asCount()`           | returns a count of the objects in the search                                                                                                                                       |\n| `.asHashes(precision)` | returns an array of `{\"id\": string,\"hash\": string}`                                                                                                                                |\n| `.asIds()`             | returns an array of ids                                                                                                                                                            |\n| `.asPoints()`          | returns objects as points: `{\"id\": string,\"point\":{\"lat\": number,\"lon\": number}`. If the searched key is a collection of `Polygon` objects, the returned points are the centroids. |\n\n#### Search\n\nUsed to iterate through a keys string values.\n\n```typescript\nawait tile38.set('fleet', 'truck1:driver').string('John').exec();\n\nawait tile38.search('fleet').match('J*').asStringObjects();\n\u003e {\"ok\":true,\"objects\":[{\"id\":\"truck1:driver\",\"object\":\"John\"}],\"count\":1,\"cursor\":0,\"elapsed\":\"59.9µs\"}\n```\n\n**Options**\n\n| command                                   | description                                                                                                                                                                                 |\n| ----------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `.asc()`                                  | Values are returned in ascending order. Default if not set.                                                                                                                                 |\n| `.desc()`                                 | Values are returned in descending order.                                                                                                                                                    |\n| `.cursor(value?)`                         | used to iterate through your search results. Defaults to `0` if not set explicitly                                                                                                          |\n| `.limit(value?)`                          | limit the number of returned objects. Defaults to `100` if not set explicitly                                                                                                               |\n| `.noFields()`                             | if not set and one of the objects in the key has fields attached, fields will be returned. Use this to suppress this behavior and don't return fields.                                      |\n| `.match(pattern?)`                        | Match can be used to filtered objects considered in the search with a glob pattern. `.match('J*')` e.g. will only consider string values objects that have a string value starting with `J` |\n| `.where(fieldname, min value, max value)` | filter output by fieldname and values.                                                                                                                                                      |\n| `.wherein(fieldname, values)`             | filter output by fieldname and values. Returns if field value in list of values.                                                                                                            |\n| `.whereExpr(expr)`                        | filter output with [filter-expression](https://tile38.com/topics/filter-expressions).                                                                                                       |\n\n**Outputs**\n\n| command              | description                                  |\n| -------------------- | -------------------------------------------- |\n| `.asStringObjects()` | return as array of objects                   |\n| `.asCount()`         | returns a count of the objects in the search |\n| `.asIds()`           | returns an array of ids                      |\n\n### Server / Connection\n\n#### CONFIG GET / REWRITE / SET\n\nWhile `.configGet()` fetches the requested configuration, `.configSet()` can be used to change the configuration.\n\n**Important**, changes made with `.set()` will only take affect after `.configRewrite()` is used.\n\n**Options**\n\n| command          | description                                                                                                                                                          |\n| ---------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `requirepass`    | Set a password and make server password-protected, if not set defaults to `\"\"` (no password required).                                                               |\n| `leaderauth`     | If leader is password-protected, followers have to authenticate before they are allowed to follow. Set `leaderauth` to password of the leader, prior to `.follow()`. |\n| `protected-mode` | Tile38 only allows authenticated clients or connections from `localhost`. Defaults to: `\"yes\"`                                                                       |\n| `maxmemory`      | Set max memory in bytes. Get max memory in bytes/kb/mb/gb.                                                                                                           |\n| `autogc`         | Set auto garbage collection to time in seconds where server performs a garbage collection. Defaults to: `0` (no garbage collection)                                  |\n| `keep_alive`     | Time server keeps client connections alive. Defaults to: `300` (seconds)                                                                                             |\n\n```typescript\nawait tile38.configGet('keepalive');\n\u003e {\"ok\":true,\"properties\":{\"keepalive\":\"300\"},\"elapsed\":\"54.6µs\"}\n\nawait tile38.configSet('keepalive', 400);\n\u003e {\"ok\":true,\"elapsed\":\"36.9µs\"}\n\nawait tile38.configRewrite();\n\u003e {\"ok\":true,\"elapsed\":\"363µs\"}\n\nawait tile38.configGet('keepalive');\n\u003e {\"ok\":true,\"properties\":{\"keepalive\":\"400\"},\"elapsed\":\"33.8µs\"}\n```\n\n**Advanced options**\nAdvanced configuration can not be set with commands, but has to be set in a `config` file in your data directory. **Options** above, as well as advanced options can be set and are loaded on start-up.\n\n| command       | description                       |\n| ------------- | --------------------------------- |\n| `follow_host` | URI of Leader to follow           |\n| `follow_port` | PORT of Leader to follow          |\n| `follow_pos`  | ?                                 |\n| `follow_id`   | ID of Leader                      |\n| `server_id`   | Server ID of the current instance |\n| `read_only`   | Make Tile38 read-only             |\n\n#### FLUSHDB\n\nDelete all keys and hooks.\n\n```typescript\nawait tile38.flushDb();\n```\n\n#### GC\n\nInstructs the server to perform a garbage collection.\n\n```typescript\nawait tile38.gc();\n```\n\n#### READONLY\n\nSets Tile38 into read-only mode. Commands such as`.set()` and `.del()` will fail.\n\n```typescript\nawait tile38.readOnly(true);\n```\n\n#### SERVER\n\nGet Tile38 statistics. Can optionally be extended with `extended=true`.\n\n```typescript\nawait tile38.server();\n\n// extended\nawait tile38.server(true);\n```\n\n#### INFO\n\nGet Tile38 statistics. Similar to `SERVER` but with different properties.\n\n```\nawait tile38.info();\n```\n\n### Geofencing\n\n\u003e A [geofence](https://en.wikipedia.org/wiki/Geo-fence) is a virtual boundary that can detect when an object enters or exits the area. This boundary can be a radius or any [search area format](https://tile38.com/commands/intersects#area-formats), such as a [bounding box](https://tile38.com/topics/object-types#bounding-box), [GeoJSON](https://tile38.com/topics/object-types#geojson) object, etc. Tile38 can turn any standard search into a geofence monitor by adding the FENCE keyword to the search.\n\nGeofence events can be:\n\n- `inside` (object in specified area),\n- `outside` (object outside specified area),\n- `enter` (object enters specified area),\n- `exit` (object exits specified area),\n- `crosses` (object that was not in specified area, has enter/exit it).\n\nGeofence events can be send on upon commands:\n\n- `set` which sends an event when an object is `.set()`\n- `del` which sends a last event when the object that resides in the geosearch is deleted via `.del()`\n- `drop`which sends a message when the entire collection is dropped\n\n#### SETHOOK\n\nCreates a webhook that points to a geosearch (NEARBY/WITHIN/INTERSECTS). Whenever a commands creates/deletes/drops an object that fulfills the geosearch, an event is send to the specified `endpoint`.\n\n```typescript\n// sends event to endpoint, when object in 'fleet'\n// enters the area of a 500m radius around\n// latitude 33.5123 and longitude -112.2693\nawait tile38\n    .setHook('warehouse', 'http://10.0.20.78/endpoint')\n    .nearby('fleet')\n    .point(33.5123, -112.2693, 500)\n    .exec();\n```\n\n```typescript\nawait tile38.set('fleet', 'bus').point(33.5123001, -112.2693001).exec();\n// event =\n\u003e {\n  \"command\": \"set\",\n  \"group\": \"5c5203ccf5ec4e4f349fd038\",\n  \"detect\": \"inside\",\n  \"hook\": \"warehouse\",\n  \"key\": \"fleet\",\n  \"time\": \"2021-03-22T13:06:36.769273-07:00\",\n  \"id\": \"bus\",\n  \"meta\": {},\n  \"object\": { \"type\": \"Point\", \"coordinates\": [-112.2693001, 33.5123001] }\n}\n```\n\n**Geosearch**\n\n| command                       | description |\n| ----------------------------- | ----------- |\n| `.nearby(name, endpoint)`     |             |\n| `.within(name, endpoint)`     |             |\n| `.intersects(name, endpoint)` |             |\n\n**Options**\n\n| command                 | description                                                                                             |\n| ----------------------- | ------------------------------------------------------------------------------------------------------- |\n| `.meta(meta)`           | Optional add additional meta information that are send in the geofence event.                           |\n| `.ex(value)`            | Optional TTL in seconds                                                                                 |\n| `.commands(...which[])` | Select on which command a hook should send an event. Defaults to: `['set', 'del', 'drop']`              |\n| `.detect(...what[])`    | Select what events should be detected. Defaults to: `['enter', 'exit', 'crosses', 'inside', 'outside']` |\n\n**Endpoints**\n\n| endpoint   | description                                                                                                                                    |\n| ---------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |\n| HTTP/HTTPS | `http://` `https://` send messages over HTTP/S. For options see [link](https://tile38.com/commands/sethook#http--https).                       |\n| gRPC       | `grpc://` send messages over [gRPC](http://www.grpc.io/). For options see [link](https://tile38.com/commands/sethook#grpc).                    |\n| Redis      | `redis://` send messages to [Redis](https://redis.io/). For options see [link](https://tile38.com/commands/sethook#redis)                      |\n| Disque     | `disque://` send messages to [Disque](https://github.com/antirez/disque). For options see [link](https://tile38.com/commands/sethook#disque).  |\n| Kafka      | `kafka://` send messages to a [Kafka](https://kafka.apache.org/) topic. For options see [link](https://tile38.com/commands/sethook#kafka).     |\n| AMQP       | `amqp://` send messages to [RabbitMQ](https://www.rabbitmq.com/). For options see [link](https://tile38.com/commands/sethook#amqp).            |\n| MQTT       | `mqtt://` send messages to an MQTT broker. For options see [link](https://tile38.com/commands/sethook#mqtt).                                   |\n| SQS        | `sqs://` send messages to an [Amazon SQS](https://aws.amazon.com/sqs/) queue. For options see [link](https://tile38.com/commands/sethook#sqs). |\n| NATS       | `nats://` send messages to a [NATS](https://www.nats.io/) topic. For options see [link](https://tile38.com/commands/sethook#nats).             |\n\n#### SETCHAN / SUBSCRIBE / PSUBSCRIBE\n\nSimilar to `setHook()`, but opens a PUB/SUB channel.\n\n```typescript\n// Start a channel that sends event, when object in 'fleet'\n// enters the area of a 500m radius around\n// latitude 33.5123 and longitude -112.2693\nawait tile38\n    .setChan('warehouse')\n    .nearby('fleet')\n    .point(33.5123, -112.2693, 500)\n    .exec();\n```\n\nNow add a receiving channel and add an event handler.\n\n```typescript\nconst channel = await tile38.channel();\nchannel.on('message', (message) =\u003e console.log(message));\n\n// also as of tile38 v1.33.1 followers can open a channel\nconst followerChannel = await tile38.follower().channel();\nfollowerChannel.on('message', (message) =\u003e console.log(message));\n```\n\nNow that channel can:\n\n```typescript\n// be subscribed to\nawait channel.subscribe('warehouse');\n// or pattern subscribed to\nawait channel.pSubscribe('ware*');\n\n// also as of tile38 v1.33.1 followers can open a channel\nawait followerChannel.subscribe('warehouse');\n// or pattern subscribed to\nawait followerChannel.pSubscribe('ware*');\n```\n\nEvery set `.set()` results in:\n\n```typescript\nawait tile38.set('fleet', 'bus').point(33.5123001, -112.2693001).exec();\n// event =\n\u003e {\n  \"command\": \"set\",\n  \"group\": \"5c5203ccf5ec4e4f349fd038\",\n  \"detect\": \"inside\",\n  \"hook\": \"warehouse\",\n  \"key\": \"fleet\",\n  \"time\": \"2021-03-22T13:06:36.769273-07:00\",\n  \"id\": \"bus\",\n  \"meta\": {},\n  \"object\": { \"type\": \"Point\", \"coordinates\": [-112.2693001, 33.5123001] }\n}\n```\n\n```typescript\n// to unsubscribed\nawait channel.unsubscribe();\n\n// to delete\nawait tile38.delChan('warehouse');\n// or pattern delete\nawait tile38.pDelChan('ware*');\n```\n\n**Geosearch**\n\n| command             | description |\n| ------------------- | ----------- |\n| `.nearby(name)`     |             |\n| `.within(name)`     |             |\n| `.intersects(name)` |             |\n\n**Options**\n\n| coommand                | description                                                                                             |\n| ----------------------- | ------------------------------------------------------------------------------------------------------- |\n| `.meta(meta)`           | Optional addition meta information that a send in the geofence event.                                   |\n| `.ex(value)`            | Optional TTL in seconds                                                                                 |\n| `.commands(...which[])` | Select on which command a hook should send an event. Defaults to: `['set', 'del', 'drop']`              |\n| `.detect(...what[])`    | Select what events should be detected. Defaults to: `['enter', 'exit', 'crosses', 'inside', 'outside']` |\n\n## Addition Information\n\nFor more information, please refer to:\n\n- [Tile38](https://tile38.com)\n\n## Roadmap\n\nSee the [open issues](https://github.com/iwpnd/tile38-ts/issues) for a list of proposed features (and known issues).\n\n## Contributing\n\nContributions are what make the open source community such an amazing place to be learn, inspire, and create. Any contributions you make are **greatly appreciated**.\n\n1. Fork the Project\n2. Create your Feature Branch (`git checkout -b feat/amazing-feature`)\n3. Commit your Changes (`git commit -m 'fix: add some amazing feature'`)\n4. Push to the Branch (`git push origin feat/amazing-feature`)\n5. Open a Pull Request\n\n## License\n\nMIT\n\n## Maintainer\n\nVincent Priem - [@vpriem](https://github.com/vpriem)  \nBenjamin Ramser - [@iwpnd](https://github.com/iwpnd)\n\nProject Link: [https://github.com/iwpnd/tile38-ts](https://github.com/iwpnd/tile38-ts)\n\n## Acknowledgements\n\nJosh Baker - maintainer of [Tile38](https://tile38.com)\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fiwpnd%2Ftile38-ts","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fiwpnd%2Ftile38-ts","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fiwpnd%2Ftile38-ts/lists"}