@strategicprojects/rpic 0.12.1 → 0.14.0

package/README.md

@@ -76,13 +76,52 @@ call that asks for the other build rejects instead of silently reusing the
 first build. In Node, pass the math artifact's bytes:
 `ready(readFileSync(new URL('…/pkg/rpic_wasm_math_bg.wasm', import.meta.url)), { math: true })`.
 
+### Maps (geopic: drawings as GeoJSON)
+
+A third, opt-in build georeferences a drawing in the browser: the result is an
+RFC 7946 `FeatureCollection` (WGS84) for Leaflet, MapLibre, OpenLayers…
+The drawing is placed by `geo_lon`/`geo_lat`/`geo_scale`/`geo_bearing` in the
+source, by control points, or by the options below (which override them) —
+the contract is [docs/geopic.md](https://github.com/milkway/rpic-lang/blob/main/docs/geopic.md).
+
+```js
+await rpic.ready(undefined, { geo: true }); // browser: fetches pkg/rpic_wasm_geo_bg.wasm
+
+const { geojson, warnings, registration } = rpic.compileGeoJSON(
+  'geo_scale = 1000\narrow from Recife to Olinda\n"Recife" at Recife below',
+  {
+    anchor: [-34.8711, -8.0631],
+    features: { Recife: [-34.8711, -8.0631], Olinda: [-34.8553, -8.0089] },
+  }
+);
+L.geoJSON(geojson).addTo(map); // e.g. Leaflet
+```
+
+`features` names points the source may use without defining them: names the
+source defines are control points of its own geometry, the others are
+injected as places (or invisible boxes, given a `bbox: [w, s, e, n]`, so
+`Zone.n` follows the extent). Names must be pic labels (`/^[A-Z][A-Za-z0-9_]*$/`)
+and are validated before anything compiles. Options: `frame` (`'enu'` |
+`'mercator'`), `anchor`, `scale` (m per inch), `bearing` (° clockwise from
+north), `features`, `flatten`, `viewScale`, `screenClasses`, `circuits`,
+`texlabels`. A georeferencing failure throws a `GeoError` whose `info` is
+`{ kind, message, hint }` (`no_registration`, `invalid_anchor`, …); pic errors
+throw the usual error with `errorInfo`. Nothing is dropped silently: every loss
+(an unsupported style, ignored `animate` timelines…) is in `warnings`, next to
+the engine's own warnings; pic `print` lines are in `diagnostics`. Numeric
+options must be finite (`scale`/`flatten`/`viewScale` > 0) or the call throws.
+`geoToCanvas(registration, [[lon, lat], …])` maps points back onto the canvas.
+In Node, pass the bytes of `pkg/rpic_wasm_geo_bg.wasm` to `ready(…, { geo: true })`.
+
 ## API
 
 | Function | Description |
 |----------|-------------|
-| `ready(wasmInput?, {math?})` | Initialize WASM. Browser: no arg. Node: pass `.wasm` bytes/URL. `math: true` loads the math-enabled build; conflicting later calls reject. |
-| `compile(src, {circuits?, texlabels?, scene?, flatten?, outline?})` | → `{ svg, animations, diagnostics, warnings, objects, scene? }` (throws on a pic error with `errorInfo`). `scene: true` adds the device-independent resolved draw list ([docs/scene.md](https://github.com/milkway/rpic-lang/blob/main/docs/scene.md)); `flatten` (inches) delivers its curves as polylines. |
+| `ready(wasmInput?, {math?, geo?})` | Initialize WASM. Browser: no arg. Node: pass `.wasm` bytes/URL. `math: true` loads the math-enabled build, `geo: true` the geo-enabled one; conflicting later calls reject. |
+| `compile(src, {circuits?, texlabels?, scene?, flatten?, outline?})` | → `{ svg, animations, diagnostics, warnings, objects, places?, passthrough?, scene? }` (throws on a pic error with `errorInfo`; `places` = named `Label: position` points in SVG units, `passthrough` = troff `.` lines, each present only when the source has some). `scene: true` adds the device-independent resolved draw list ([docs/scene.md](https://github.com/milkway/rpic-lang/blob/main/docs/scene.md)); `flatten` (inches) delivers its curves as polylines. |
 | `renderSvg(src, {circuits?, texlabels?})` | → SVG string. |
+| `compileGeoJSON(src, {anchor?, scale?, bearing?, frame?, features?, …})` | Geo build only. → `{ geojson, warnings, diagnostics, registration, canvas }`; throws `GeoError` (`info.kind`) or a pic error. |
+| `geoToCanvas(registration, points)` | Geo build only. WGS84 `[lon, lat]` points → canvas `[x, y]` inches. |
 | `animate(root, animations, gsap)` | Build/play a GSAP timeline (`draw`/`fade`/`pop`). Browser only. |
 
 Compile errors keep a readable `message` and expose structured data for editors:

package/index.d.ts

@@ -108,6 +108,54 @@ export interface SceneItem {
   }[];
   /** block items: the child item ids */
   items?: string[];
+  /**
+   * block items: where the block came from — the outermost macro call that
+   * expanded to it, or its opening `[` when written inline
+   */
+  span?: SourceSpan;
+  /** block items made by a macro: that outermost call */
+  call?: { name: string; args: string[] };
+}
+
+/** A source position, relative to its own source unit (like diagnostics). */
+export interface SourceSpan {
+  line: number;
+  col: number;
+  end_col: number;
+  /** absent = the user's input; `"circuits"` = the `-c` library; else the `copy` name */
+  file?: string;
+}
+
+/** A named place (`Label: position`) in the scene. */
+export interface ScenePlace {
+  /** the resolved label, subscripts included (`R[2]`) */
+  label: string;
+  /** scene units, the same frame as the items */
+  at: [number, number];
+  /** enclosing block item ids, outermost first */
+  block?: string[];
+  span?: SourceSpan;
+}
+
+/** A named place in the compile bundle: SVG user units, the `objects` frame. */
+export interface Place {
+  label: string;
+  x: number;
+  y: number;
+  line?: number;
+  col?: number;
+  end_col?: number;
+  file?: string;
+}
+
+/** A troff request line (`.` in column 1) set aside before lexing. */
+export interface Passthrough {
+  /** the line as written, leading `.` included */
+  text: string;
+  line: number;
+  col: number;
+  end_col: number;
+  file?: string;
 }
 
 /**
@@ -127,8 +175,15 @@ export interface Scene {
     origin: [number, number];
   };
   source?: string;
+  /**
+   * the uniform factor the whole-picture rescale (`.PS <w>`, `maxpswid`/`maxpsht`)
+   * applied to the geometry; 1 when none acted. `vars` are pre-rescale.
+   */
+  rescale: number;
   /** final values of every variable (user + pic built-ins) */
   vars: Record<string, number>;
+  /** named places (`Label: position`), evaluation order; empty when none */
+  places: ScenePlace[];
   items: SceneItem[];
 }
 
@@ -143,6 +198,10 @@ export interface Bundle {
   warnings: Diagnostic[];
   /** per-object geometry, index-aligned with the `<g id="sN">` groups */
   objects: ObjectGeometry[];
+  /** named places (`Label: position`) in SVG user units. Present only when the source defines some. */
+  places?: Place[];
+  /** troff request lines set aside before lexing. Present only when the source has some. */
+  passthrough?: Passthrough[];
   /**
    * `true` when the source used `animate scroll`, hinting the host to scrub
    * the timeline on scroll rather than autoplay. Present only when set.
@@ -186,6 +245,13 @@ export interface ReadyOptions {
    * pass the math wasm bytes as `wasmInput`.
    */
   math?: boolean;
+  /**
+   * Load the geo-enabled wasm build (`pkg/rpic_wasm_geo_bg.wasm`), which adds
+   * `compileGeoJSON` / `geoToCanvas` (geopic: drawings as GeoJSON). Fetched
+   * only when requested; cannot be combined with `math`. In Node, pass the
+   * geo wasm bytes as `wasmInput`.
+   */
+  geo?: boolean;
 }
 
 /**
@@ -203,3 +269,167 @@ export function compile(src: string, opts?: CompileOptions): Bundle;
 
 /** Compile and return only the SVG string. */
 export function renderSvg(src: string, opts?: CompileOptions): string;
+
+// ---------------------------------------------------------------------------
+// geopic: pic drawings as GeoJSON (docs/geopic.md). Needs the geo build:
+// `await ready(undefined, { geo: true })`.
+// ---------------------------------------------------------------------------
+
+/** `[west, south, east, north]`, degrees. */
+export type GeoBBox = [number, number, number, number];
+
+/**
+ * A named geographic feature the host knows about. The name must be a pic
+ * label (`/^[A-Z][A-Za-z0-9_]*$/`); anything else is rejected before
+ * compiling. With a `bbox` it is injected as an invisible box, so
+ * `Name.n`/`Name.e`/… follow its extent (compass corners are canvas
+ * directions).
+ */
+export interface GeoFeatureInput {
+  name: string;
+  lon: number;
+  lat: number;
+  bbox?: GeoBBox | null;
+}
+
+/**
+ * `features` in any of its accepted forms: `{ Name: [lon, lat] }`,
+ * `{ Name: [lon, lat, bbox] }`, `{ Name: { lon, lat, bbox? } }`, or an array
+ * of `{ name, lon, lat, bbox? }` objects / `[name, lon, lat, bbox?]` tuples.
+ */
+export type GeoFeatures =
+  | Record<string, [number, number] | [number, number, GeoBBox | null] | { lon: number; lat: number; bbox?: GeoBBox | null }>
+  | Array<GeoFeatureInput | [string, number, number] | [string, number, number, GeoBBox | null]>;
+
+export interface GeoOptions {
+  /** load the native circuit-element library */
+  circuits?: boolean;
+  /** set `texlabels = 1` (the geo build has no math renderer: literal labels + a diagnostic) */
+  texlabels?: boolean;
+  /** projection frame; overrides `geo_frame` */
+  frame?: 'enu' | 'mercator';
+  /** `[lon, lat]` of the pic origin; overrides `geo_lon`/`geo_lat` */
+  anchor?: [number, number];
+  /** metres per authored inch; overrides `geo_scale` (default 100) */
+  scale?: number;
+  /** azimuth of the canvas +y axis, degrees clockwise from north; overrides `geo_bearing` */
+  bearing?: number;
+  /**
+   * Named features: those the source defines (places or labelled objects)
+   * are control points of its geometry; the others are injected as places
+   * (two-pass), so `arrow from Recife to Olinda` works without the source
+   * defining them.
+   */
+  features?: GeoFeatures;
+  /** flattening tolerance for curves, inches (default `1e-3`) */
+  flatten?: number;
+  /** pixels per inch when the source sets `geo_px = 1` */
+  viewScale?: number;
+  /** `class` words marking screen-anchored items (default `['screen']`) */
+  screenClasses?: string[];
+}
+
+/** A non-fatal loss or substitution while georeferencing (never silent). */
+export interface GeoWarning {
+  /**
+   * `unsupported_style`, `ignored`, `registration_residual`,
+   * `ignored_with_control_points`, `control_point_unresolved`,
+   * `control_point_overridden`, `unsupported_kind`, `densification_budget`,
+   * …; engine `scene_unsupported` diagnostics ride here too (with the
+   * `Diagnostic` keys instead of `id`/`span`).
+   */
+  kind: string;
+  message: string;
+  /** the scene item concerned (`s<N>`), when there is one */
+  id?: string;
+  /**
+   * its source span, relative to your own source; `file: 'features'` marks a
+   * position inside the lines `compileGeoJSON` injected for `features`
+   */
+  span?: { line: number; col: number; end_col: number; file?: string };
+}
+
+/** The similarity canvas (inches) → Earth. */
+export interface GeoRegistration {
+  frame: 'enu' | 'mercator';
+  /** geographic position of `origin` */
+  anchor: { lon: number; lat: number };
+  /** the canvas point (inches) that sits at `anchor` */
+  origin: [number, number];
+  /** metres per inch of the emitted geometry */
+  scale_m_per_in: number;
+  /** azimuth of the canvas +y axis, degrees clockwise from north */
+  bearing_deg: number;
+  method: 'anchor' | 'two_points' | 'helmert';
+  /** control points used by the fit (0 for a declared anchor) */
+  control_points: number;
+  /** RMS residual of the fit, metres (fits only) */
+  rms_m?: number;
+}
+
+export interface GeoJSONGeometry {
+  type: 'Point' | 'LineString' | 'Polygon' | 'MultiPoint' | 'MultiLineString' | 'MultiPolygon';
+  coordinates: unknown;
+}
+
+export interface GeoJSONFeature {
+  type: 'Feature';
+  geometry: GeoJSONGeometry | null;
+  /** simplestyle keys (`stroke`, `fill`, …) and `geopic:*` (docs/geopic.md) */
+  properties: Record<string, unknown>;
+}
+
+export interface GeoJSONFeatureCollection {
+  type: 'FeatureCollection';
+  features: GeoJSONFeature[];
+}
+
+export interface GeoResult {
+  /** RFC 7946 FeatureCollection, WGS84 */
+  geojson: GeoJSONFeatureCollection;
+  /** engine warnings, then scene, then geopic ones — never silent */
+  warnings: (GeoWarning | Diagnostic)[];
+  /** lines emitted by pic `print` statements, plus engine notices (as in `Bundle`) */
+  diagnostics: string[];
+  registration: GeoRegistration;
+  /** what a host needs to write canvas positions back as source coordinates */
+  canvas: {
+    /** the whole-picture rescale (`.PS <width>`, `maxpswid`); 1 when none */
+    rescale: number;
+    /** the pic `scale` variable (source units per inch) */
+    scale: number;
+  };
+}
+
+/** A georeferencing error; `info.kind` is machine-readable. */
+export class GeoError extends Error {
+  constructor(message: string, info: { kind: string; message: string; hint?: string });
+  info: {
+    /**
+     * `no_registration`, `invalid_scale`, `invalid_anchor`, `invalid_frame`,
+     * `invalid_scene`, `invalid_flatten`, `view_scale_required`,
+     * `degenerate_control_points`, `invalid_options` (option JSON of the
+     * wrong shape).
+     */
+    kind: string;
+    message: string;
+    hint?: string;
+  };
+}
+
+/**
+ * Georeference pic source as a GeoJSON FeatureCollection (WGS84). Needs the
+ * geo build (`ready(…, { geo: true })`). Throws a `CompileError` on a pic
+ * error, a `GeoError` on a georeferencing error, and a plain `Error` for an
+ * invalid feature name/shape (checked before anything compiles).
+ */
+export function compileGeoJSON(src: string, opts?: GeoOptions): GeoResult;
+
+/**
+ * Canvas positions (inches) of WGS84 `[lon, lat]` points under a
+ * registration (as `compileGeoJSON` returned it). Needs the geo build.
+ */
+export function geoToCanvas(
+  registration: GeoRegistration | string,
+  points: [number, number][]
+): [number, number][];

package/index.js

@@ -3,11 +3,15 @@
 // Browser:  await ready();                         // wasm fetched automatically
 // Node:     await ready(fs.readFileSync(url));      // pass the .wasm bytes/URL
 // Math:     await ready(undefined, { math: true }); // texlabels typeset in-browser
+// Maps:     await ready(undefined, { geo: true });  // compileGeoJSON (drawing → GeoJSON)
 import * as leanModule from './pkg/rpic_wasm.js';
 
+// display names of the three builds, keyed by ready()'s choice
+const BUILDS = { lean: 'lean', math: 'math-enabled', geo: 'geo-enabled' };
+
 let initPromise = null;
-let wasm = null; // the initialized glue module (lean or math)
-let initMath = null;
+let wasm = null; // the initialized glue module (lean, math or geo)
+let initBuild = null; // 'lean' | 'math' | 'geo' while an init is pending/done
 
 /**
  * Initialize the WebAssembly module (idempotent; concurrent calls share one
@@ -16,29 +20,38 @@ let initMath = null;
  *
  * Pass `{ math: true }` to load the math-enabled build instead: it bundles
  * the RaTeX renderer so `texlabels` sources typeset `$…$` labels exactly like
- * the native CLI. The math glue + wasm are only fetched when requested, so
- * the lean fast path stays untouched. The choice is fixed by the first
- * successful (or in-flight) call; later calls asking for the other build
+ * the native CLI. Pass `{ geo: true }` for the geo-enabled build, which adds
+ * `compileGeoJSON`/`geoToCanvas` (geopic: drawings as GeoJSON). Either extra
+ * glue + wasm is only fetched when requested, so the lean fast path stays
+ * untouched; the two cannot be combined. The choice is fixed by the first
+ * successful (or in-flight) call; later calls asking for another build
  * reject. A *failed* init (bad bytes, fetch error) clears the slot so
  * `ready()` can be retried. In Node, pass the bytes of
- * `pkg/rpic_wasm_math_bg.wasm` along with it.
+ * `pkg/rpic_wasm_math_bg.wasm` / `pkg/rpic_wasm_geo_bg.wasm` along with it.
  */
 export function ready(wasmInput, opts = {}) {
-  const wantsMath = !!opts.math;
+  if (opts.math && opts.geo) {
+    return Promise.reject(new Error('rpic: ready() cannot load the math and geo builds together; pick one'));
+  }
+  const wanted = opts.math ? 'math' : opts.geo ? 'geo' : 'lean';
   if (initPromise) {
-    if (initMath !== wantsMath) {
-      const current = initMath ? 'math-enabled' : 'lean';
-      const requested = wantsMath ? 'math-enabled' : 'lean';
+    if (initBuild !== wanted) {
       return Promise.reject(
-        new Error(`rpic: ready() already initialized the ${current} build; cannot switch to ${requested}`)
+        new Error(
+          `rpic: ready() already initialized the ${BUILDS[initBuild]} build; cannot switch to ${BUILDS[wanted]}`
+        )
       );
     }
     return initPromise;
   }
-  initMath = wantsMath;
-  const attempt = (
-    wantsMath ? import('./pkg/rpic_wasm_math.js') : Promise.resolve(leanModule)
-  )
+  initBuild = wanted;
+  const load =
+    wanted === 'math'
+      ? import('./pkg/rpic_wasm_math.js')
+      : wanted === 'geo'
+        ? import('./pkg/rpic_wasm_geo.js')
+        : Promise.resolve(leanModule);
+  const attempt = load
     .then(async (mod) => {
       await mod.default(wasmInput === undefined ? undefined : { module_or_path: wasmInput });
       wasm = mod;
@@ -48,7 +61,7 @@ export function ready(wasmInput, opts = {}) {
       // (only if it is still ours) so the next ready() starts fresh
       if (initPromise === attempt) {
         initPromise = null;
-        initMath = null;
+        initBuild = null;
       }
       throw e;
     });
@@ -88,19 +101,317 @@ export function compile(src, opts = {}) {
         : wasm.compile(src);
   const out = JSON.parse(json);
   if (out.error) {
-    const err = new Error(out.error);
-    err.errorInfo = out.error_info;
-    err.warnings = out.warnings ?? [];
-    throw err;
+    throw compileError(out);
   }
   return out;
 }
 
+/** The Error a pic error becomes: `.errorInfo` (a Diagnostic) + `.warnings`. */
+function compileError(out) {
+  const err = new Error(out.error);
+  err.errorInfo = out.error_info;
+  err.warnings = out.warnings ?? [];
+  return err;
+}
+
 /** Compile and return just the SVG string. */
 export function renderSvg(src, opts) {
   return compile(src, opts).svg;
 }
 
+// ---------------------------------------------------------------------------
+// geopic: pic drawings as GeoJSON (docs/geopic.md). Needs the geo build:
+// `await ready(undefined, { geo: true })`. Mirrors Python's `rpic.geo`.
+// ---------------------------------------------------------------------------
+
+/**
+ * A georeferencing error. `.message` is the readable text; `.info` is the
+ * structured `{ kind, message, hint? }` (`no_registration`, `invalid_anchor`,
+ * `invalid_frame`, `invalid_options`, …).
+ */
+export class GeoError extends Error {
+  constructor(message, info) {
+    super(message);
+    this.name = 'GeoError';
+    this.info = info;
+  }
+}
+
+// pic labels: an uppercase letter, then letters, digits or underscores.
+// Feature names are written into pic source, so anything else is rejected
+// outright — never interpolated.
+const LABEL = /^[A-Z][A-Za-z0-9_]*$/;
+const FORMS =
+  'rpic: features must be a {name: [lon, lat]} / {name: {lon, lat, bbox?}} object, ' +
+  'or an array of {name, lon, lat, bbox?} objects or [name, lon, lat, bbox?] tuples';
+
+function featureLabel(name) {
+  const s = String(name);
+  if (!LABEL.test(s)) {
+    throw new Error(
+      `rpic: feature name ${JSON.stringify(s)} is not a pic label (an uppercase letter followed by letters, digits or underscores)`
+    );
+  }
+  return s;
+}
+
+function featureCoord(v, what) {
+  if (typeof v !== 'number' || !Number.isFinite(v)) {
+    throw new Error(`rpic: feature ${what} must be a finite number, got ${JSON.stringify(v) ?? String(v)}`);
+  }
+  return v;
+}
+
+function featureBbox(name, bbox) {
+  if (bbox === undefined || bbox === null) return null;
+  if (!Array.isArray(bbox) || bbox.length !== 4) {
+    throw new Error(`rpic: feature ${JSON.stringify(name)}: bbox must be [west, south, east, north]`);
+  }
+  return bbox.map((v) => featureCoord(v, `${name} bbox`));
+}
+
+function oneFeature(name, pos) {
+  const n = featureLabel(name);
+  if (Array.isArray(pos)) {
+    if (pos.length !== 2 && pos.length !== 3) throw new Error(FORMS);
+    return { name: n, lon: featureCoord(pos[0], `${n} lon`), lat: featureCoord(pos[1], `${n} lat`), bbox: featureBbox(n, pos[2]) };
+  }
+  if (pos && typeof pos === 'object') {
+    return { name: n, lon: featureCoord(pos.lon, `${n} lon`), lat: featureCoord(pos.lat, `${n} lat`), bbox: featureBbox(n, pos.bbox) };
+  }
+  throw new Error(FORMS);
+}
+
+/** `features` in any accepted form → `[{name, lon, lat, bbox|null}]`. */
+function normalizeFeatures(features) {
+  if (features === undefined || features === null) return [];
+  if (Array.isArray(features)) {
+    const out = features.map((item) => {
+      if (Array.isArray(item)) {
+        if (item.length !== 3 && item.length !== 4) throw new Error(FORMS);
+        if (typeof item[0] !== 'string') throw new Error(`${FORMS} (name is required)`);
+        return oneFeature(item[0], item.slice(1));
+      }
+      if (item && typeof item === 'object') {
+        if (typeof item.name !== 'string') throw new Error(`${FORMS} (name is required)`);
+        return oneFeature(item.name, item);
+      }
+      throw new Error(FORMS);
+    });
+    return unique(out);
+  }
+  if (typeof features === 'object') {
+    return Object.entries(features).map(([name, pos]) => oneFeature(name, pos));
+  }
+  throw new Error(FORMS);
+}
+
+/** Reject a name given twice: which position would win is not obvious. */
+function unique(feats) {
+  const seen = new Set();
+  for (const f of feats) {
+    if (seen.has(f.name)) throw new Error(`rpic: feature ${JSON.stringify(f.name)} is given more than once`);
+    seen.add(f.name);
+  }
+  return feats;
+}
+
+/**
+ * Re-base one position (`line`/`file`) past the `k` prelude lines. A
+ * position *inside* the prelude is not the caller's: it is tagged
+ * `file: 'features'` (`line` stays relative to the prelude).
+ */
+function rebaseLine(d, k) {
+  if (!k || !d || typeof d !== 'object' || d.file != null) return;
+  if (!Number.isInteger(d.line) || d.line < 1) return;
+  if (d.line > k) d.line -= k;
+  else d.file = 'features';
+}
+
+/**
+ * Shift warnings back by the `k` prelude lines the host prepended, so
+ * positions refer to the caller's own source (positions inside an
+ * include/library carry a `file` and are left alone).
+ */
+function rebase(out, k) {
+  if (!k) return out;
+  for (const w of out.warnings ?? []) {
+    if (w.span && typeof w.span === 'object') rebaseLine(w.span, k);
+    else rebaseLine(w, k);
+  }
+  return out;
+}
+
+function geoWasm() {
+  ensure();
+  if (typeof wasm.compile_geo !== 'function') {
+    throw new Error('rpic: compileGeoJSON needs the geo-enabled build: `await ready(undefined, { geo: true })`');
+  }
+  return wasm;
+}
+
+/** One native pass, diagnostics re-based by `k` lines. */
+function geoPass(src, k, geoOpts, opts) {
+  const out = JSON.parse(geoWasm().compile_geo(src, !!opts.circuits, !!opts.texlabels, JSON.stringify(geoOpts)));
+  if (out.error_info) {
+    const err = compileError(out);
+    rebaseLine(err.errorInfo, k);
+    throw err;
+  }
+  if (out.geo_error) throw new GeoError(out.error, out.geo_error);
+  return rebase(out, k);
+}
+
+/** 9 significant digits, like `%.9g` (the pic lexer reads exponents). */
+const num = (x) => String(Number(x.toPrecision(9)));
+
+/**
+ * pic statements defining every feature at its position, in the source's own
+ * units (pic `scale`, before the whole-picture `rescale`). A feature with a
+ * bbox becomes an invisible labelled box spanning the axis-aligned canvas
+ * extent of its four corners; a point feature a plain place. Names were
+ * validated by `featureLabel` — nothing else reaches the source.
+ */
+function prelude(registration, canvas, feats) {
+  const units = (canvas.scale ?? 1) / (canvas.rescale ?? 1); // source units per emitted inch
+  const pts = [];
+  for (const f of feats) {
+    pts.push([f.lon, f.lat]);
+    if (f.bbox) {
+      const [w, s, e, n] = f.bbox;
+      pts.push([w, s], [e, s], [e, n], [w, n]);
+    }
+  }
+  const canvasPts = geoToCanvas(registration, pts);
+  let i = 0;
+  const lines = feats.map((f) => {
+    const [x, y] = canvasPts[i++];
+    const at = `(${num(x * units)}, ${num(y * units)})`;
+    if (!f.bbox) return `${f.name}: ${at}`;
+    const corners = canvasPts.slice(i, i + 4);
+    i += 4;
+    const xs = corners.map((c) => c[0]);
+    const ys = corners.map((c) => c[1]);
+    const wid = (Math.max(...xs) - Math.min(...xs)) * units;
+    const ht = (Math.max(...ys) - Math.min(...ys)) * units;
+    return `${f.name}: box invis wid ${num(wid)} ht ${num(ht)} at ${at}`;
+  });
+  return lines.join('\n') + '\n';
+}
+
+/**
+ * Two passes. Features the source itself defines (as places or labelled
+ * objects) are control points of the source's own geometry; the others are
+ * injected — placed by the registration of a first pass — as places or
+ * invisible boxes, then everything is georeferenced together.
+ */
+function compileWithFeatures(src, feats, base, opts) {
+  const names = new Set(feats.map((f) => f.name));
+  const k = feats.length;
+  const placeholders = feats.map((f) => `${f.name}: (0, 0)\n`).join('');
+  // which names does the source define? their definitions sit after the
+  // placeholder lines (a span is relative to the caller's text + prelude)
+  let scene;
+  try {
+    scene = compile(placeholders + src, { circuits: opts.circuits, texlabels: opts.texlabels, scene: true }).scene;
+  } catch (e) {
+    rebaseLine(e.errorInfo, k);
+    throw e;
+  }
+  const defined = new Set();
+  for (const p of [...(scene.places ?? []), ...(scene.items ?? [])]) {
+    if (names.has(p.label) && (p.span?.line ?? 0) > k) defined.add(p.label);
+  }
+  const own = feats.filter((f) => defined.has(f.name));
+  const inject = feats.filter((f) => !defined.has(f.name));
+  // pass 1: the registration — declared anchor, or the source's control
+  // points, the source-defined features among them
+  const first = geoPass(placeholders + src, k, { ...base, features: own }, opts);
+  if (!inject.length) return first;
+  const pre = prelude(first.registration, first.canvas, inject);
+  const out = geoPass(pre + src, inject.length, { ...base, features: feats }, opts);
+  if (first.registration.method === 'anchor' && first.registration.control_points === 0) {
+    // the injected features were placed *by* the declared values; the second
+    // pass's "declared values ignored" would blame the source
+    out.warnings = out.warnings.filter((w) => w.kind !== 'ignored_with_control_points');
+  }
+  return out;
+}
+
+/**
+ * Numeric options are checked here: `JSON.stringify` would turn NaN/Infinity
+ * into `null`, which the wasm reads as "not given" — a silent fallback.
+ */
+function checkGeoOptions(opts) {
+  const finite = (v) => typeof v === 'number' && Number.isFinite(v);
+  for (const key of ['scale', 'flatten', 'viewScale']) {
+    if (opts[key] !== undefined && !(finite(opts[key]) && opts[key] > 0)) {
+      throw new Error(`rpic: ${key} must be a positive finite number`);
+    }
+  }
+  if (opts.bearing !== undefined && !finite(opts.bearing)) {
+    throw new Error('rpic: bearing must be a finite number (degrees)');
+  }
+  if (
+    opts.anchor !== undefined &&
+    !(Array.isArray(opts.anchor) && opts.anchor.length === 2 && opts.anchor.every(finite))
+  ) {
+    throw new Error('rpic: anchor must be [lon, lat], two finite numbers');
+  }
+}
+
+/**
+ * Georeference pic source: `{ geojson, warnings, diagnostics, registration,
+ * canvas }`.
+ * Needs the geo build (`await ready(undefined, { geo: true })`).
+ *
+ * `frame` (`'enu'` | `'mercator'`), `anchor` `[lon, lat]`, `scale` (metres per
+ * inch), `bearing` (degrees clockwise from north), `viewScale` (px per inch
+ * under `geo_px = 1`) and `screenClasses` override the source's `geo_*`
+ * variables; `flatten` is the curve tolerance (inches, default `1e-3`).
+ *
+ * `features` names points the source may use without defining them
+ * (`arrow from Recife to Olinda`): features the source does define act as
+ * control points of its own geometry; the others are projected by a first
+ * pass's registration and injected as places — invisible labelled boxes when
+ * they have a `bbox`, so `Name.n`/`Name.e` follow its extent — before the
+ * final pass. Diagnostics keep the caller's line numbers.
+ *
+ * Throws an `Error` with `.errorInfo` on a pic error (like `compile`) and a
+ * `GeoError` (`.info = { kind, message, hint }`) on a georeferencing error.
+ */
+export function compileGeoJSON(src, opts = {}) {
+  geoWasm();
+  checkGeoOptions(opts);
+  const feats = normalizeFeatures(opts.features);
+  const base = {
+    frame: opts.frame,
+    anchor: opts.anchor,
+    scale: opts.scale,
+    bearing: opts.bearing,
+    flatten: opts.flatten,
+    view_scale: opts.viewScale,
+    screen_classes: opts.screenClasses,
+  };
+  return feats.length
+    ? compileWithFeatures(src, feats, base, opts)
+    : geoPass(src, 0, { ...base, features: [] }, opts);
+}
+
+/**
+ * Canvas positions (inches) of WGS84 `[lon, lat]` points under a
+ * registration (as `compileGeoJSON` returned it). Needs the geo build.
+ * @param {object | string} registration
+ * @param {[number, number][]} points
+ * @returns {[number, number][]}
+ */
+export function geoToCanvas(registration, points) {
+  const reg = typeof registration === 'string' ? registration : JSON.stringify(registration);
+  const out = JSON.parse(geoWasm().geo_to_canvas(reg, JSON.stringify(points)));
+  if (!Array.isArray(out)) throw new GeoError(out.error, out.geo_error);
+  return out;
+}
+
 // The GSAP player lives in player.js — a zero-import module, so consumers
 // with pre-rendered SVG can `import { animate } from '…/player.js'` and pull
 // in nothing wasm-related. Re-exported here to keep the one-stop API.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strategicprojects/rpic",
-  "version": "0.12.1",
+  "version": "0.14.0",
   "description": "The pic graphics language compiled to SVG with animation manifests, via WebAssembly. Browser + Node.",
   "type": "module",
   "main": "./index.js",
@@ -16,7 +16,8 @@
       "default": "./player.js"
     },
     "./pkg/rpic_wasm_bg.wasm": "./pkg/rpic_wasm_bg.wasm",
-    "./pkg/rpic_wasm_math_bg.wasm": "./pkg/rpic_wasm_math_bg.wasm"
+    "./pkg/rpic_wasm_math_bg.wasm": "./pkg/rpic_wasm_math_bg.wasm",
+    "./pkg/rpic_wasm_geo_bg.wasm": "./pkg/rpic_wasm_geo_bg.wasm"
   },
   "files": [
     "index.js",
@@ -31,16 +32,21 @@
     "pkg/rpic_wasm_math.d.ts",
     "pkg/rpic_wasm_math_bg.wasm",
     "pkg/rpic_wasm_math_bg.wasm.d.ts",
+    "pkg/rpic_wasm_geo.js",
+    "pkg/rpic_wasm_geo.d.ts",
+    "pkg/rpic_wasm_geo_bg.wasm",
+    "pkg/rpic_wasm_geo_bg.wasm.d.ts",
     "README.md"
   ],
   "scripts": {
     "build:wasm:lean": "wasm-pack build ../../crates/wasm --target web --out-dir ../../bindings/js/pkg",
     "build:wasm:math": "wasm-pack build ../../crates/wasm --target web --out-dir ../../bindings/js/pkg --out-name rpic_wasm_math -- --features math",
-    "build:wasm": "npm run build:wasm:lean && npm run build:wasm:math",
+    "build:wasm:geo": "wasm-pack build ../../crates/wasm --target web --out-dir ../../bindings/js/pkg --out-name rpic_wasm_geo -- --features geo",
+    "build:wasm": "npm run build:wasm:lean && npm run build:wasm:math && npm run build:wasm:geo",
     "prepack": "npm run build:wasm",
-    "test": "node test/smoke.mjs && node test/smoke-math.mjs"
+    "test": "node test/smoke.mjs && node test/smoke-math.mjs && node test/smoke-geo.mjs"
   },
-  "keywords": ["pic", "svg", "diagram", "graphics", "wasm", "gsap", "animation", "circuits"],
+  "keywords": ["pic", "svg", "diagram", "graphics", "wasm", "gsap", "animation", "circuits", "geojson", "maps"],
   "author": "André Leite <leite@de.ufpe.br>",
   "license": "BSD-2-Clause",
   "repository": {

package/pkg/rpic_wasm_geo.d.ts

@@ -0,0 +1,99 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * Compile pic source to a JSON `{svg, animations, diagnostics, warnings}`
+ * bundle (or `{error, error_info}`).
+ */
+export function compile(src: string): string;
+
+/**
+ * Like [`compile`], but with the native circuit-element library loaded
+ * (so `resistor`, `and_gate`, … are available). Loaded as an option, not
+ * prepended text: diagnostic positions stay relative to `src`.
+ */
+export function compile_circuits(src: string): string;
+
+/**
+ * Georeference pic source: `{"geojson": FeatureCollection, "warnings":
+ * [...], "diagnostics": [...], "registration": {...}, "canvas": {"rescale",
+ * "scale"}}`, or
+ * `{"error", "error_info"}` on a pic error, or `{"error", "geo_error":
+ * {kind, message, hint}}` on a georeferencing error (bad options included).
+ *
+ * `opts_json` is a JSON object (or empty string) with the optional keys
+ * `frame` (`"enu"` | `"mercator"`), `anchor` (`[lon, lat]`), `scale`
+ * (metres per inch), `bearing` (degrees clockwise from north), `features`
+ * (`[{name, lon, lat, bbox?}]`, control points by label), `flatten`
+ * (inches), `view_scale` (px per inch under `geo_px = 1`) and
+ * `screen_classes`. Each overrides the corresponding `geo_*` variable of
+ * the source. Animations cannot ride into GeoJSON: a source with `animate`
+ * statements adds an `ignored` warning.
+ */
+export function compile_geo(src: string, circuits: boolean, texlabels: boolean, opts_json: string): string;
+
+/**
+ * Like [`compile_with`], but the bundle also carries the device-independent
+ * `scene` draw list (docs/scene.md); `flatten` (inches) delivers curves as
+ * polylines. The plain entry points above stay byte-identical — the scene is
+ * computed only here.
+ */
+export function compile_scene(src: string, circuits: boolean, texlabels: boolean, flatten: number | null | undefined, outline: boolean): string;
+
+/**
+ * Like [`compile`], with options: `circuits` loads the circuit-element
+ * library; `texlabels` sets `texlabels = 1` so `$…$` labels are typeset as
+ * TeX math. Note: the default wasm build ships without the math renderer
+ * (size budget), so with `texlabels` the labels fall back to literal text
+ * and a diagnostic — use the math-enabled build (`--features math`, the
+ * `rpic_wasm_math` npm artifact) to typeset them.
+ */
+export function compile_with(src: string, circuits: boolean, texlabels: boolean): string;
+
+/**
+ * Canvas positions (inches) of WGS84 points under a registration (as
+ * `compile_geo` returned it): `points_json` is `[[lon, lat], …]`; returns
+ * `[[x, y], …]`, or `{"error", "geo_error"}` when either input does not
+ * parse. The host uses it to place features before compiling (two-pass
+ * feature injection, see `bindings/js/index.js`).
+ */
+export function geo_to_canvas(registration_json: string, points_json: string): string;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly compile_geo: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
+    readonly geo_to_canvas: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly compile: (a: number, b: number) => [number, number];
+    readonly compile_circuits: (a: number, b: number) => [number, number];
+    readonly compile_scene: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number];
+    readonly compile_with: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __wbindgen_malloc: (a: number, b: number) => number;
+    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;

package/pkg/rpic_wasm_geo.js

@@ -0,0 +1,356 @@
+/* @ts-self-types="./rpic_wasm_geo.d.ts" */
+
+/**
+ * Compile pic source to a JSON `{svg, animations, diagnostics, warnings}`
+ * bundle (or `{error, error_info}`).
+ * @param {string} src
+ * @returns {string}
+ */
+export function compile(src) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(src, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.compile(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * Like [`compile`], but with the native circuit-element library loaded
+ * (so `resistor`, `and_gate`, … are available). Loaded as an option, not
+ * prepended text: diagnostic positions stay relative to `src`.
+ * @param {string} src
+ * @returns {string}
+ */
+export function compile_circuits(src) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(src, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.compile_circuits(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * Georeference pic source: `{"geojson": FeatureCollection, "warnings":
+ * [...], "diagnostics": [...], "registration": {...}, "canvas": {"rescale",
+ * "scale"}}`, or
+ * `{"error", "error_info"}` on a pic error, or `{"error", "geo_error":
+ * {kind, message, hint}}` on a georeferencing error (bad options included).
+ *
+ * `opts_json` is a JSON object (or empty string) with the optional keys
+ * `frame` (`"enu"` | `"mercator"`), `anchor` (`[lon, lat]`), `scale`
+ * (metres per inch), `bearing` (degrees clockwise from north), `features`
+ * (`[{name, lon, lat, bbox?}]`, control points by label), `flatten`
+ * (inches), `view_scale` (px per inch under `geo_px = 1`) and
+ * `screen_classes`. Each overrides the corresponding `geo_*` variable of
+ * the source. Animations cannot ride into GeoJSON: a source with `animate`
+ * statements adds an `ignored` warning.
+ * @param {string} src
+ * @param {boolean} circuits
+ * @param {boolean} texlabels
+ * @param {string} opts_json
+ * @returns {string}
+ */
+export function compile_geo(src, circuits, texlabels, opts_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(src, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(opts_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.compile_geo(ptr0, len0, circuits, texlabels, ptr1, len1);
+        deferred3_0 = ret[0];
+        deferred3_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * Like [`compile_with`], but the bundle also carries the device-independent
+ * `scene` draw list (docs/scene.md); `flatten` (inches) delivers curves as
+ * polylines. The plain entry points above stay byte-identical — the scene is
+ * computed only here.
+ * @param {string} src
+ * @param {boolean} circuits
+ * @param {boolean} texlabels
+ * @param {number | null | undefined} flatten
+ * @param {boolean} outline
+ * @returns {string}
+ */
+export function compile_scene(src, circuits, texlabels, flatten, outline) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(src, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.compile_scene(ptr0, len0, circuits, texlabels, !isLikeNone(flatten), isLikeNone(flatten) ? 0 : flatten, outline);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * Like [`compile`], with options: `circuits` loads the circuit-element
+ * library; `texlabels` sets `texlabels = 1` so `$…$` labels are typeset as
+ * TeX math. Note: the default wasm build ships without the math renderer
+ * (size budget), so with `texlabels` the labels fall back to literal text
+ * and a diagnostic — use the math-enabled build (`--features math`, the
+ * `rpic_wasm_math` npm artifact) to typeset them.
+ * @param {string} src
+ * @param {boolean} circuits
+ * @param {boolean} texlabels
+ * @returns {string}
+ */
+export function compile_with(src, circuits, texlabels) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(src, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.compile_with(ptr0, len0, circuits, texlabels);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * Canvas positions (inches) of WGS84 points under a registration (as
+ * `compile_geo` returned it): `points_json` is `[[lon, lat], …]`; returns
+ * `[[x, y], …]`, or `{"error", "geo_error"}` when either input does not
+ * parse. The host uses it to place features before compiling (two-pass
+ * feature injection, see `bindings/js/index.js`).
+ * @param {string} registration_json
+ * @param {string} points_json
+ * @returns {string}
+ */
+export function geo_to_canvas(registration_json, points_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(registration_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(points_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.geo_to_canvas(ptr0, len0, ptr1, len1);
+        deferred3_0 = ret[0];
+        deferred3_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbindgen_init_externref_table: function() {
+            const table = wasm.__wbindgen_externrefs;
+            const offset = table.grow(4);
+            table.set(0, undefined);
+            table.set(offset + 0, undefined);
+            table.set(offset + 1, null);
+            table.set(offset + 2, true);
+            table.set(offset + 3, false);
+        },
+    };
+    return {
+        __proto__: null,
+        "./rpic_wasm_geo_bg.js": import0,
+    };
+}
+
+function getStringFromWasm0(ptr, len) {
+    return decodeText(ptr >>> 0, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+let wasmModule, wasmInstance, wasm;
+function __wbg_finalize_init(instance, module) {
+    wasmInstance = instance;
+    wasm = instance.exports;
+    wasmModule = module;
+    cachedUint8ArrayMemory0 = null;
+    wasm.__wbindgen_start();
+    return wasm;
+}
+
+async function __wbg_load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+            } catch (e) {
+                const validResponse = module.ok && expectedResponseType(module.type);
+
+                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else { throw e; }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+        } else {
+            return instance;
+        }
+    }
+
+    function expectedResponseType(type) {
+        switch (type) {
+            case 'basic': case 'cors': case 'default': return true;
+        }
+        return false;
+    }
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module !== undefined) {
+        if (Object.getPrototypeOf(module) === Object.prototype) {
+            ({module} = module)
+        } else {
+            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+        }
+    }
+
+    const imports = __wbg_get_imports();
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+    const instance = new WebAssembly.Instance(module, imports);
+    return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(module_or_path) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module_or_path !== undefined) {
+        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+            ({module_or_path} = module_or_path)
+        } else {
+            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+        }
+    }
+
+    if (module_or_path === undefined) {
+        module_or_path = new URL('rpic_wasm_geo_bg.wasm', import.meta.url);
+    }
+    const imports = __wbg_get_imports();
+
+    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+        module_or_path = fetch(module_or_path);
+    }
+
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+export { initSync, __wbg_init as default };

package/pkg/rpic_wasm_geo_bg.wasm.d.ts

@@ -0,0 +1,14 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const compile_geo: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
+export const geo_to_canvas: (a: number, b: number, c: number, d: number) => [number, number];
+export const compile: (a: number, b: number) => [number, number];
+export const compile_circuits: (a: number, b: number) => [number, number];
+export const compile_scene: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number];
+export const compile_with: (a: number, b: number, c: number, d: number) => [number, number];
+export const __wbindgen_externrefs: WebAssembly.Table;
+export const __wbindgen_malloc: (a: number, b: number) => number;
+export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_free: (a: number, b: number, c: number) => void;
+export const __wbindgen_start: () => void;