API reference

The supported contract of @workspace/active-geo since the public switch to P1 (P1e, [Unreleased]): the P1 projection of the API-first design v0.5 (D-42 to D-47). Two entries: the runtime . and the optional starter collection ./collections/world-50m (§ 15); both export lists are pinned by src/__tests__/public-api.test.ts. Version 0.x: workable, not yet stable. V1 is not accepted. The 0.4 API (the presentation prop, the object card, the footer's Table and Export, the layer value fields, state v1 as output, CSV v1) is gone; the migration table maps every part of it.

Phases. P1 publishes only what works. An input of a later phase does not exist in these types, and a JavaScript caller that passes one gets GeoConfigurationError with GEO_OPTION_UNAVAILABLE (§ 9): symbols and shapes, rotation, paint, shared scales (scales), the legend filter (legend.interaction: 'filter', filter props), legend overflow (P2); line layers, useGeoProjection, project/invert, a React tooltip (P3); continuous colour, image symbols, clusters, insets (P4). OUTPUT types keep the full target unions (a line layer type, the channels shape/rotation/color/width, gradient and line keys, cluster targets), so an exhaustive switch keeps compiling when a later phase makes them live; P1 never produces them.

1. GeoMap#

<GeoMap  title="…"                  // the map's accessible name; shown in the header by default; required  subtitle="…"               // a short visible line under the title (header.subtitle)  description="…"            // for assistive technology, and the export's description  layers={[…]}               // GeoLayer[], bottom first (§ 2)  projection="conic-equal-area"  height={420}               // CSS px of the stage (default 420); the width follows the container  graticule                  // meridians and parallels  locale="nl-NL"             // the notation of numbers; prop, else GeoDefaults; required  t={translate}              // the host's words; prop, else GeoDefaults; required (§ 7)  diagnostics={sink}         // prop, else GeoDefaults, else the console (§ 8)  // configuration (each also from GeoDefaults, § 6):  header legend tooltip zoom contextMenu table export attribution selection components  // state, controlled or not (§ 4):  selectedItems defaultSelectedItems onSelectionChange  view defaultView home onViewChange  highlight defaultHighlight onHighlightChange onLegendActivate  onItemActivate onTableRequest  dataset levelPath onLevelRequest  onExportComplete onExportError  ref={handle}               // GeoMapHandle (§ 5)  className="…"/>

The package default is quiet (D-45). In rest: the title (and subtitle) above the map, the map, and the source line (attribution); nothing else. The navigation appears on demand (pointer over the map, keyboard focus, a touch) in a corner over the map, keeps its place and its tab stop, and never shifts the layout. The legend appears only when there is something to explain (an encoding, a status). The menu opens on a right click, a long press, Shift+F10 or the ContextMenu key; export and the table live in the menu and the handle (D-44), never in a mandatory footer. Every part is configurable or replaceable by the host (§ 3, § 11).

Keyboard. The map is one tab stop with aria-activedescendant over the drawn objects in walking order (also Canvas points, through proxies). Arrows move, Home and End go to the first and last object, Space selects (when selection is on), Enter activates (onItemActivate; also selects when selection is on), Shift+F10 and the ContextMenu key open the menu on the object (or the map), Escape closes the tooltip and then clears a highlight, + and − zoom (zoom.keyboardShortcuts). A key typed in the menu, the legend or the table is theirs, never the map's. One announcement per action; a controlled map that refuses a change announces nothing.

Pointer and touch. A click on an object selects (when on) and shows its tooltip; one finger belongs to the page (touch-action), two fingers pan and zoom; the wheel zooms with Ctrl or Command by default (zoom.gestures.wheel); a hint says how when a gesture is not the map's. Picking follows the drawn symbol plus a tolerance (D-19); several objects at one place are offered in the menu (atPlace).

Failure. A configuration the map cannot run with throws a GeoConfigurationError during render (§ 9). Data problems never throw: they exclude objects with a reason, shown in the table's "not on the map" tab and the data alternative, and reported once to the diagnostics sink.

2. Layers, measures and encodings#

type GeoLayer = GeoAreaLayer | GeoPointLayer | GeoContextLayer;

Every data layer has id, title, and optionally visible, fit, measures, detailOrder, tooltip, label, legend (boolean | {title?: string | false}) and describe.

• Area layer (type: 'area'): features: {key, name?, geometry, values?, details?, meta?}[], optional data: {key, values?, details?}[] (records joined by key; never together with inline values: GEO_DATA_SOURCE_CONFLICT), convention (rfc7946 default, or spherical), fill (a colour or a GeoColorMapping), stroke.

• Point layer (type: 'point'): points: {key, latitude, longitude, name?, values?, details?, meta?}[], marker: {size?, fill?, stroke?, opacity?} (circles in P1), renderer ('auto' default, 'svg', 'canvas'; Canvas above the threshold of D-18).

• Context layer (type: 'context'): geometries of areas and lines; drawn, never interactive, never in the legend or the table.

Measures (W-1, D-43). A layer knows measures: {id, label, semantics?} (a number; semantics is the family's GeoValueSemantics, § 13) or {id, label, kind: 'category', categories: [{id, label?}]}. A value per object (or record) in values, keyed by measure id: a number, a category id, null/absent (missing) or {suppressed: true} (withheld). Ids are GeoIds (/^[A-Za-z0-9_][A-Za-z0-9_.-]{0,63}$/, GEO_ID_INVALID). A reading is value (with its formatted text), missing, invalid (with a reason) or suppressed. A withheld value is never shown as a number anywhere: not in the map, the tooltip, labels, the table, the copied text, CSV or an export.

Encodings. Areas encode fill; points marker.fill and marker.size.

• fill: {measure, scale, palette?, legend?} with an own classed scale: {type: 'threshold', thresholds, classLabels?}, {type: 'quantize', classes, domain?, classLabels?}, {type: 'category'}, or diverging ({type: 'diverging', reference, …}, D-28). End classes are open. palette overrides the token colours (an array by class, or a record by category id).

• size: {measure, domainMax?, maxRadius?, legend?}: the AREA of a circle is proportional to the value; zero, missing, withheld and negative sizes draw a hollow marker at the hollow radius.

• A constant is a plain value (fill: '#2a6', size: 6).

• An encoding's status is separate from the measurement: encoded, the special statuses, unrepresentable (with a reason) or constant.

Text fields. Tooltip, labels and describe read the same fields: 'name', {measure}, {encoding: 'fill' | 'size', show?: 'class' | 'value-and-class'}, {detail}, 'details'. tooltip: {title?: 'name' | false, fields?} per layer; label: {fields?, max?, placement?} per layer (area labels D-30; point labels D-31; placement order end, start, above, below by default); describe(context) => {name?, description?} overrides an object's accessible name and description (a throwing callback falls back to the default and is reported once). A label never shows a withheld value.

3. Configuration props#

Every one is a FeatureOption: absent inherits, false switches the part off, true switches it on with its defaults, an object refines.

The menu (D-44). The family's menu (the shared menu-items pipeline of Charts and Grid) on Base UI's context menu, composed from one frozen GeoMenuContext per opening (target: an object with every object at its place, the map at a position, or a legend entry; source; selectedItemCount; view; level; getMeta). Groups: host (the host's items), copy (an object's values in words; a withheld value is its status word), table ("Show in table", "Show the table"/"Hide the table"), navigation (place-bound only: "Zoom to …", "Zoom in here", "Fit the map", the starting view; never a second zoom in/out), level (the levels above the current one), export (the allowed formats, current view or whole map, one CSV per data layer, all records or the selection). An item that exists but cannot run now stays, disabled with its reason. A host item: {label, action?(context), icon?, variant?, disabled?, disabledReason?, shortcut?, keepOpen?, visible?(context), separatorBefore?, children?} or 'separator'. A keyboard opening focuses the first item; focus returns to the opener, or to the target an action claims (a table row).

The table (D-46). The package's own accessible table: one tab per data layer plus "not on the map", search, pages of 100 rows, "Show on map", reasons in words, end-aligned number columns; the hidden data alternative reads the same rows. Opened from the menu, by table.open/defaultOpen, or by revealInTable. Escape in a row returns the focus to its object on the map.

4. State, events and the controlled pattern#

Each piece of interactive state is uncontrolled (default…) or controlled (the value prop). A controlled value is the host's: the map draws the prop and only ASKS (requested: true in the change); getState() right after a refused request still reports the prop.

• Selection: selectedItems/defaultSelectedItems, onSelectionChange(selection, change); change.source is pointer, keyboard, update (objects that left the data, with removed), restore or api.

• View (W-9): view/defaultView: {mode: 'frame'} (fitted to the layers) or {mode: 'free', center, zoom}; onViewChange(view, {cause, requested}). home: 'frame', a fixed view, or {fit: 'layers', layers} (where home() goes; fit() is always the frame).

• Highlight: highlight/defaultHighlight (GeoHighlight | null: legend entry targets with their meaning fingerprints), onHighlightChange(highlight, {cause, requested}). The callback value can be fed back into the prop without a cast. A target whose MEANING changed (a different scale) is cleared with cause: 'reconcile'; mere absence keeps it dormant.

• Legend activation: onLegendActivate(activation) runs before the effect of a legend entry, Geo's own or a host legend's (useGeoLegend, activateLegendEntry), and may preventDefault().

• Items: onItemActivate(item, source) on Enter (keyboard) or the pointer and touch activation of an object.

• Host table: onTableRequest(request) ({item, focus, source, requestId, revision, dataset, signal, returnFocus}) returns or resolves {status: 'shown', focus: 'host' | 'none' | 'package'} or {status: 'unavailable', reason?}. With focus: false the host must not move the focus. A newer request or unmounting aborts signal; every reveal settles exactly once (revealed, or unavailable with no-table, item-unknown, host-refused, host-failed, not-opened, outlet-hidden, not-focusable, superseded, unmounted, stale-data).

• Levels (D-25): levelPath (top first; the last is current) and onLevelRequest(request); the request carries {level, item?, source, requestId, signal}; applying the answer is the host's.

• Exports: onExportComplete(format), onExportError(format, error).

Callbacks are read at the moment of the event (a new callback after a re-render receives the next event); a re-render with equal props reports nothing.

5. The handle#

interface GeoMapHandle {  zoomIn(): void;  zoomOut(): void;  fit(options?: {layers?}): void;  home(): void;  pan(direction: 'up' | 'down' | 'left' | 'right'): void;  zoomTo(items: GeoItemRef | readonly GeoItemRef[]): boolean;  focusItem(item: GeoItemRef): boolean;  revealInTable(    item: GeoItemRef,    options?: {focus?: boolean},  ): Promise<GeoTableRevealResult>;  exportAsPng(options?: GeoImageExportOptions): Promise<GeoExportResult>;  exportAsSvg(options?: GeoImageExportOptions): Promise<GeoExportResult>;  exportAsCsv(options: GeoCsvExportOptions): Promise<GeoExportResult>;  getFeatures(query?: GeoFeatureQuery): GeoFeatureSnapshot;  getLegendModel(): GeoLegendModel;  activateLegendEntry(entryId: string): boolean;  getEffectivePresentation(): GeoEffectivePresentation;  getState(): GeoMapState;  applyState(    state: unknown,    options?: GeoApplyStateOptions,  ): GeoApplyStateResult;  requestLevel(level: GeoLevel, options?: {item?: GeoItemRef}): void;}

Every method runs the same route as the package's own control for it (one route per action: a button, a key, a menu item and the handle produce the same events). In a controlled map the navigation methods are requests. getFeatures returns the one row model (§ 10) the table, the data alternative, the tooltip and CSV read. getEffectivePresentation says what is shown after defaults, fallbacks and the container width.

State v2 (D-47). getState() returns {version: 2, dataset, level, view, selection, layers, encodings, scales, highlight, filter} (filter is always empty in P1). applyState(state, {fields?, isCompatible?}) validates unknown input, the schema, the version (a version 1 state is migrated: reason: 'migrated-v1') and the dataset (isCompatible; default: equal identity), then restores field by field and reports per field (applied, adjusted, delegated, dropped, unchanged, with a reason) and per entry. Without fields: every restorable field present in the state. A controlled field is delegated as a request. A non-empty filter is dropped with capability-unavailable (per target and as a field) while other fields restore (partial); filter: [] is "no filter" (unchanged). A highlight with a later-phase target is dropped as a whole group. The result status is applied, partial or rejected.

6. GeoDefaults#

<GeoDefaults {...GeoConfigSource}>: defaults for every map below, nested. The map hands every provider's source (outermost first) and its own props to one schema-aware merge (v0.5 § 8): undefined inherits; false switches a feature off and clears the inherited feature configuration; true switches it on; arrays replace; [] is explicitly empty; the declared records merge field by field (legend.explanations/counts, zoom.gestures, contextMenu.features, export.image/csv, tooltip, header); a zoom.controls of another variant replaces the whole variant (foreign variant fields are dropped with variant-field-ignored). null resets a declared Resettable path to the package (or instance) default past every provider; an undeclared null is GEO_OPTION_CONFLICT. locale, t, diagnostics and components are atomic. There is no default language and no default notation.

7. Words and notation#

The package owns the keys (GeoTranslationKey), the host the words: t(key, variables); count selects the plural form (one/other). t is required: there is no default language and no hidden English fallback. englishGeoTranslator is the package's English, passed on purpose. englishGeoMessages is the complete catalogue (every key with its English words, a plural key as {one, other}), for a host that writes its own translator: the keys and their {{variables}} are versioned public contract. Wherever the map joins a label and a value, or several texts, it asks the language (geo.text.pair, geo.text.list); it never concatenates words with its own punctuation. Host data (layer titles, measure and category labels, names, details) is the host's text and is never sent through t.

locale is the notation (GeoPresentation, the family's ValuePresentation: a BCP 47 tag or a presentation object with its number format); words and notation are independent: a German translator with an English notation is legitimate. Formatting runs through the inlined @workspace/active-format; the same declaration and value give the same text as in Charts.

Direction. The map takes the page's dir. Controls, legend, menu, table and the reading side of point labels follow it; the geography and the order of the host's objects never mirror. Every visible text run is an isolated run; no bidi control character is inserted. An image export is a left-to-right document.

P1e adds the keys geo.nav.home, geo.nav.controlsHint, geo.nav.keysHint, geo.keyboardHintMenu, geo.menu.label, geo.menu.labelFor, geo.menu.showTable, geo.menu.hideTable, geo.menu.zoomHere, geo.menu.zoomTo; removed keys are listed in the CHANGELOG.

8. Diagnostics#

GeoDiagnostic {level, source: 'ActiveGeo.GeoMap', message, data?} to the sink, once per (code, path, value), never per render; data carries the code and the configuration path, never keys, names or values. Codes: presentation-value-ignored (a configuration value outside its contract, ignored), variant-field-ignored, reference-pending (a legend section names an explanation that is not there yet), text-callback-failed, data-excluded, table-focus-violation (a host moved the focus while asked not to), table-request-failed, outlet-missing, scope-second-map, export-failed.

9. Errors#

GeoConfigurationError {code, field, constraint, value?, message}, thrown during render. Codes: GEO_PRESENTATION_MISSING (no locale), GEO_TRANSLATOR_MISSING (no t), GEO_PROJECTION_INVALID, GEO_LAYER_INVALID, GEO_LAYER_ID_DUPLICATE, GEO_LAYER_OPTION_INVALID, GEO_ID_INVALID, GEO_MEASURE_INVALID, GEO_MEASURE_ID_DUPLICATE, GEO_ENCODING_REFERENCE_INVALID, GEO_SCALE_INCOMPATIBLE, GEO_PALETTE_INVALID, GEO_DATA_SOURCE_CONFLICT, GEO_LEGEND_GROUP_ID_DUPLICATE, GEO_OPTION_CONFLICT, GEO_OPTION_UNAVAILABLE (an input of a later phase; constraint names the phase).

GeoExportError {code, format, …} rejects an export (and reaches onExportError): EXPORT_BUSY, EXPORT_TOO_LARGE, EXPORT_CAPTURE_FAILED, EXPORT_NO_DATA, EXPORT_CANCELLED, EXPORT_INVALID_OPTION (§ 12).

10. Rows, identity and exclusions#

One row model (v0.5 § 11) for the snapshot, the table, the data alternative, the tooltip, CSV and a host grid: per data layer {layerType, layerId, visible, measures, detailOrder, encodings, rows}; an object row {kind: 'object', rowId, ref, keyReading, name, geometry, geometryReason, link, linkReason, issues, position?, measurements, encodings, details, selected, highlighted, filteredOut}; a record row (a value record without a drawn object) {kind: 'record', …, link, linkReason}. rowId is stable within one revision.

Keys (D-9). GeoKey = string | number: a non-empty string (exact, case-sensitive) or a finite number; 1 and "1" are two objects; 0 and -0 one. The machine identity is v1: plus the JSON of the typed key (keyReading.encoded). Every holder of a key repeated within a layer is excluded (duplicate-key).

Exclusion reasons: missing-key, invalid-key, duplicate-key, missing-geometry, unsupported-geometry, ring-too-short, non-finite-position, position-out-of-range, ring-not-closed, antimeridian-uncut, ring-zero-net-area, hole-outside-shell, densify-limit, object-empty, invalid-coordinate, latitude-out-of-range, longitude-out-of-range, not-projectable. A degenerate exterior part is excluded from its area (partial); a degenerate hole is dropped.

11. Host composition#

Host components (D-36). components: {Button?, Toggle?, Input?} render the map's own controls (navigation buttons, legend toggles, the table's search and pager, the menu button) in the host's design system. The map owns every action, its state, words, ARIA, keyboard and focus routes and layout, and checks an unavailable action again before it acts; the component owns only how the control looks. Spread the DOM props onto ONE interactive element and send ref to it; render disabled as aria-disabled (focusable), never native disabled; keep the given className; define the components once, at module scope. The menu, the tooltip, the table's tabs and rows, the steps of a compact scale and labels are Geo's own and not replaceable. Datyx's adapters for the Active UI Button, Toggle and Input: apps/admin/components/shared/geo-components.tsx.

Outlets (D-41). GeoMapScope binds one map to a GeoLegendOutlet and a GeoTableOutlet anywhere inside it (legend: {position: 'outlet'}, table: {position: 'outlet'}). The map renders its own legend and table there through a portal: the same part, the same state and ARIA, never a copy; an image export never reads an outlet. One map per scope (a second one is reported, scope-second-map). A missing outlet makes the part fall back to the map's own layout and is reported (outlet-missing); a hidden outlet answers a reveal with outlet-hidden and takes no focus.

A host legend. Inside a GeoMapScope, useGeoLegend() returns {model, activate}: the map's own resolved legend model (sections, entries with id, role, label, description, key, count, interactive, highlighted) and the map's own activation route (onLegendActivate first, cancellable, then the effect). null model outside a scope or before the first frame.

A host toolbar. Switch the package parts off (zoom: {controls: false}, contextMenu: {features: {export: false}}) and call the handle; every handle method is the same route as the package's control.

<GeoMapScope>  <nav>    <button onClick={() => void map.current?.exportAsPng()}>PNG</button>    <button onClick={() => map.current?.home()}>Home</button>  </nav>  <GeoMap    ref={map}    title="Sales"    projection="conic-equal-area"    layers={layers}    zoom={{controls: false}}    contextMenu={{features: {export: false}}}    legend={{position: 'outlet'}}    table={{position: 'outlet'}}  />  <aside>    <GeoLegendOutlet />  </aside>  <HostTab title="Table">    <GeoTableOutlet />  </HostTab></GeoMapScope>

12. Export#

exportAsPng/exportAsSvg(options?) and exportAsCsv({layerId, scope?, details?, text?, filename?, download?}), and the menu's export group, which runs the same operation. One export at a time (a second one while one runs rejects with GeoExportError EXPORT_BUSY; the menu shows its items disabled meanwhile).

• Image (GeoImageExportOptions: the export.image fields plus filename and download, default true): the current view or the fitted map; the title, description and attribution; the legend 'presentation' (what the screen explains), 'all', false, or a layout {content, position: 'bottom' | 'end', arrangement, sections}; labels placed by the export's own placement (D-30, W-7); an explicit theme (light, dark, current; export.themes declares how a host's mode is an attribute); scale (PNG pixel ratio); system fonts only (D-32). A PNG within limits.pngMaxPixels, an SVG within limits.svgMaxBytes (else GeoExportError EXPORT_TOO_LARGE; the menu shows the item disabled with its reason).

• CSV v2 (D-43): one file per data layer, one row per snapshot row. Columns csv_version (2), layer, level, row_kind (object, record), key, key_type, key_encoded, name, geometry, geometry_reason, link_status, link_reason, issues, longitude, latitude; per measure measure:<id>:value, :unit (money and price: the currency; percent: its source), :status, and with text: true :text; with details: true one detail:<id> per detail id. Text passes the family's delimited-text boundary (quoting, formula neutralisation); numbers the machine number form; a category is written as its id; a withheld value is never written. scope: 'selected' exports the selected objects.

• Result {format, filename, blob, downloadStarted, frame?, revision, presentationRevision, warnings}: the revisions captured. An export captures one consistent frame: props that change while it runs do not mix into it.

13. GeoValueSemantics#

Exactly the shape of ChartValueSemantics (active-charts): number (format?), count, money (currency, decimals?), price (currency, decimals), percent (source, preset?). Without it: integer or two decimals.

14. Styling#

One stylesheet, imported by the entry (a side effect, as in Charts), every rule under .active-geo; the private defaults on :root and .dark. Colour tokens and the font are listed in the README. The package defaults follow the host's .dark class; any host value for a --geo-* token wins. States never share a cue (D-27): selection is a solid line over the halo, focus a dashed line, highlight dims the rest of the layer, a missing value is hatched, a withheld value has its own pattern. On-demand controls are transparent and without pointer events in rest but keep their place and tab stop; reduced motion switches transitions off; forced colours map strokes, selection and focus to system colours. A host restyles the map through tokens and components, never by hiding package parts with its own CSS.

15. Starter collection (D-26)#

An optional second entry, @workspace/active-geo/collections/world-50m: Natural Earth Admin 0 – Countries at 1:50m (theme version 5.1.1, release tag v5.1.2), 242 areas. The runtime entry . never reaches it; a host that does not import it carries no geography.

import {GeoMap, englishGeoTranslator} from '@workspace/active-geo';import {  loadWorld50m,  world50m,} from '@workspace/active-geo/collections/world-50m';
const features = await loadWorld50m();<GeoMap  title="Sales by country"  projection="equal-earth"  locale="en-US"  t={englishGeoTranslator}  dataset={world50m.dataset}  attribution={world50m.attribution}  layers={[    {      type: 'area',      id: 'world',      title: 'Countries',      features,      measures: [{id: 'sales', label: 'Sales'}],      data: records, // [{key: 'NLD', values: {sales: 120}}, …], joined by key      fill: {measure: 'sales', scale: {type: 'quantize', classes: 5}},    },  ]}/>;

Metadata, no geometry. world50m is available synchronously and loads no geometry: dataset ({id: 'active-geo/world-50m', version: 'ne-5.1.1+r1'}, for dataset and restorable state), source, rights (public domain), attribution, boundaryPolicy, featureCount (242), bounds, crs, convention (rfc7946), key and transformation.

Loading. loadWorld50m() imports the geometry on its first call (a separate chunk with a code-splitting bundler, about 236 KB gzip) and resolves to the 242 areas in source order. Every call resolves to the same frozen array. A failed load rejects; the next call tries again. The package makes no network request of its own.

Areas and joining. A GeoCountryFeature is an area feature: key (ADM0_A3, the join key), name (English, display only), geometry, codes (neId, isoA3, isoA2, isoN3, wikidata), attributes. Records join by key only: no name matching, no code translation. The codes are no key (isoA3 AUS belongs to three areas). The collection follows Natural Earth's default de facto representation and takes no position on sovereignty. Known limits: 1:50m generalisation; no names in other languages.

Rebuilding. node packages/active-geo/scripts/build-world-50m.mjs fetch | build | check (sources and rights: scripts/world-50m.sources.json).

16. Environment and distribution#

Modern browsers with ES2022, ResizeObserver, Canvas 2D, Path2D and Intl.NumberFormat; a client component (SSR renders the container, the map draws after hydration). Peer dependencies React and React DOM 19; runtime d3-geo, d3-scale, @base-ui/react (menu, direction), and date-fns and @date-fns/tz, which the formatter owner reaches (standard RPS-R8). The owner entries @workspace/active-format, @workspace/active-utils/menu-items and /serialization are the closure lint-portable-closure guards (D-1, v0.5 § 14). In another repository the owners arrive as managed packages through rps:transfer and rps-apply, active-utils as the compatibility selection portable-helpers; @workspace/active-i18n is not required. Not yet proved: an external example consumer and a recorded release (ROADMAP R-69); the manifest is private: true with source exports. Transfer: docs/platform/HERBRUIKBARE-PACKAGES.md (source repository: docs/platform/HERBRUIKBARE-PACKAGES.md).

All exports, from the source#

@workspace/active-geo#

@workspace/active-geo/collections/world-50m#