@adatechnology/game-urban-three 0.0.0-stage → 0.2.0

package/dist/index.js

@@ -0,0 +1,953 @@
+// src/draw.ts
+import { shapeGeometries as shapeGeometries2 } from "@adatechnology/game-shapes-three";
+
+// src/rounded-box.ts
+import { shapeGeometries } from "@adatechnology/game-shapes-three";
+function createRoundedBox(THREE, width, height, depth, radius) {
+  const T = shapeGeometries(THREE);
+  if (radius === 0) return new T.BoxGeometry(width, height, depth);
+  const geometry = new T.BoxGeometry(2, 2, 2, 4, 4, 4);
+  const position = geometry.attributes.position;
+  const normal = geometry.attributes.normal;
+  const half = [width / 2, height / 2, depth / 2];
+  const p = [0, 0, 0];
+  const q = [0, 0, 0];
+  const map = (value, halfSize) => {
+    const a = Math.abs(value);
+    return Math.sign(value) * (a <= 0.5 ? a * 2 * (halfSize - radius) : halfSize - radius + (a - 0.5) * 2 * radius);
+  };
+  for (let index = 0; index < position.count; index++) {
+    const source = [position.getX(index), position.getY(index), position.getZ(index)];
+    let length = 0;
+    for (let axis = 0; axis < 3; axis++) {
+      p[axis] = map(source[axis], half[axis]);
+      const clamped = Math.max(-(half[axis] - radius), Math.min(half[axis] - radius, p[axis]));
+      q[axis] = p[axis] - clamped;
+      p[axis] = clamped;
+      length += q[axis] ** 2;
+    }
+    length = Math.sqrt(length);
+    if (length < 1e-6) {
+      q[0] = normal.getX(index);
+      q[1] = normal.getY(index);
+      q[2] = normal.getZ(index);
+    } else for (let axis = 0; axis < 3; axis++) q[axis] = q[axis] / length;
+    position.setXYZ(index, p[0] + q[0] * radius, p[1] + q[1] * radius, p[2] + q[2] * radius);
+    normal.setXYZ(index, q[0], q[1], q[2]);
+  }
+  return geometry;
+}
+function createPrism(THREE, width, height, depth) {
+  const shape = new THREE.Shape();
+  shape.moveTo(-width / 2, 0);
+  shape.lineTo(width / 2, 0);
+  shape.lineTo(0, height);
+  shape.lineTo(-width / 2, 0);
+  const geometry = new (shapeGeometries(THREE)).ExtrudeGeometry(shape, { depth, bevelEnabled: false });
+  geometry.translate(0, 0, -depth / 2);
+  return geometry;
+}
+
+// src/text.ts
+var FIT = 0.92;
+function createTextTexture(THREE, document, lines, o) {
+  const canvas = document.createElement("canvas");
+  canvas.width = o.width;
+  canvas.height = o.height;
+  const g = canvas.getContext("2d");
+  g.fillStyle = o.background;
+  g.fillRect(0, 0, o.width, o.height);
+  g.fillStyle = o.foreground;
+  g.font = o.font;
+  g.textAlign = "center";
+  g.textBaseline = "middle";
+  const base = g.font;
+  lines.forEach((text, index) => {
+    g.font = base;
+    const measured = g.measureText(text).width;
+    if (measured > o.width * FIT) g.font = base.replace(/(\d+(?:\.\d+)?)px/, (_match, size) => (Number(size) * o.width * FIT / measured).toFixed(1) + "px");
+    g.fillText(text, o.width / 2, o.height / 2 + (index - (lines.length - 1) / 2) * (o.height / lines.length));
+  });
+  const texture = new THREE.CanvasTexture(canvas);
+  texture.anisotropy = 4;
+  return texture;
+}
+
+// src/draw.ts
+var DEFAULT_ROUGHNESS = 0.9;
+var DEFAULT_METALNESS = 0;
+var ITEM_ROUNDNESS = 0.12;
+var LIT_WINDOW = 16757854;
+var DARK_WINDOW = { color: 856599, roughness: 0.3, metalness: 0.5 };
+var SIGN_FONT = '700 56px "Arial Narrow", Arial, sans-serif';
+var SIGN_CANVAS = { width: 512, height: 128 };
+function createUrbanThree(THREE, options = {}) {
+  const T = shapeGeometries2(THREE);
+  const geometries = /* @__PURE__ */ new Map();
+  const materials = /* @__PURE__ */ new Map();
+  const disposables = [];
+  const standard = (color, style, flat = false) => {
+    const roughness = style?.roughness ?? DEFAULT_ROUGHNESS;
+    const metalness = style?.metalness ?? DEFAULT_METALNESS;
+    const key = `s|${color}|${roughness}|${metalness}|${flat ? 1 : 0}`;
+    let material = materials.get(key);
+    if (!material) {
+      material = new THREE.MeshStandardMaterial({ color, roughness, metalness, flatShading: flat });
+      materials.set(key, material);
+    }
+    return material;
+  };
+  const glowing = (color) => {
+    const key = `b|${color}`;
+    let material = materials.get(key);
+    if (!material) {
+      material = new THREE.MeshBasicMaterial({ color });
+      materials.set(key, material);
+    }
+    return material;
+  };
+  const roundedBox = (width, height, depth, radius) => {
+    const key = [width, height, depth, radius].map((value) => value.toFixed(3)).join("|");
+    let geometry = geometries.get(key);
+    if (!geometry) {
+      geometry = createRoundedBox(THREE, width, height, depth, radius);
+      geometries.set(key, geometry);
+    }
+    return geometry;
+  };
+  const shadows = (mesh, style, cast, receive) => {
+    mesh.castShadow = style?.castShadow ?? cast;
+    mesh.receiveShadow = style?.receiveShadow ?? receive;
+  };
+  const texture = (lines, width, height, background, foreground, font) => {
+    if (!options.document) throw new Error("createUrbanThree needs a document (option) to draw signs and labels");
+    const map = createTextTexture(THREE, options.document, lines, { width, height, background, foreground, font });
+    disposables.push(map);
+    return map;
+  };
+  const textPlane = (part, map) => {
+    const mesh = new THREE.Mesh(new T.PlaneGeometry(part.width, part.height), new THREE.MeshBasicMaterial({ map, transparent: true }));
+    mesh.userData.own = true;
+    mesh.position.set(part.x, part.y, part.z);
+    if (part.ry) mesh.rotation.y = part.ry;
+    disposables.push(mesh.geometry, mesh.material);
+    return mesh;
+  };
+  const drawPart = (part, animators, lights) => {
+    switch (part.shape) {
+      case "group": {
+        const group = new THREE.Group();
+        group.position.set(part.x, part.y, part.z);
+        if (part.ry) group.rotation.y = part.ry;
+        return [group];
+      }
+      case "box": {
+        const mesh = new THREE.Mesh(roundedBox(part.width, part.height, part.depth, part.radius), part.emissive ? glowing(part.color) : standard(part.color, part.style));
+        mesh.position.set(part.x, part.y, part.z);
+        if (part.ry) mesh.rotation.y = part.ry;
+        if (part.rz) mesh.rotation.z = part.rz;
+        shadows(mesh, part.style, true, true);
+        return [mesh];
+      }
+      case "prism": {
+        const geometry = createPrism(THREE, part.width, part.height, part.depth);
+        disposables.push(geometry);
+        const mesh = new THREE.Mesh(geometry, standard(part.color, part.style, true));
+        mesh.position.set(part.x, part.y, part.z);
+        if (part.ry) mesh.rotation.y = part.ry;
+        shadows(mesh, part.style, true, true);
+        return [mesh];
+      }
+      case "cylinder": {
+        const geometry = new T.CylinderGeometry(part.radiusTop, part.radiusBottom, part.height, part.segments);
+        disposables.push(geometry);
+        const mesh = new THREE.Mesh(geometry, standard(part.color, part.style));
+        mesh.position.set(part.x, part.y, part.z);
+        shadows(mesh, part.style, true, true);
+        return [mesh];
+      }
+      case "cone": {
+        const geometry = new T.ConeGeometry(part.radius, part.height, part.segments);
+        disposables.push(geometry);
+        const mesh = new THREE.Mesh(geometry, standard(part.color, part.style, true));
+        mesh.position.set(part.x, part.y, part.z);
+        shadows(mesh, part.style, true, true);
+        return [mesh];
+      }
+      case "crown": {
+        const geometry = new THREE.DodecahedronGeometry(part.radius, 0);
+        disposables.push(geometry);
+        const mesh = new THREE.Mesh(geometry, standard(part.color, part.style));
+        mesh.position.set(part.x, part.y, part.z);
+        shadows(mesh, part.style, true, false);
+        return [mesh];
+      }
+      case "terrain": {
+        const { grid } = part;
+        const geometry = new T.PlaneGeometry(grid.size, grid.size, grid.segments, grid.segments);
+        geometry.rotateX(-Math.PI / 2);
+        const position = geometry.attributes.position;
+        const colors = new Float32Array(position.count * 3);
+        const color = new THREE.Color();
+        for (let index = 0; index < position.count; index++) {
+          position.setXYZ(index, grid.x[index], grid.heights[index], grid.z[index]);
+          color.setHex(grid.colors[index]);
+          colors[index * 3] = color.r;
+          colors[index * 3 + 1] = color.g;
+          colors[index * 3 + 2] = color.b;
+        }
+        geometry.setAttribute("color", new THREE.BufferAttribute(colors, 3));
+        geometry.computeVertexNormals();
+        disposables.push(geometry);
+        const material = new THREE.MeshStandardMaterial({ vertexColors: true, flatShading: true, roughness: 1 });
+        disposables.push(material);
+        const mesh = new THREE.Mesh(geometry, material);
+        mesh.userData.own = true;
+        shadows(mesh, part.style, true, true);
+        return [mesh];
+      }
+      case "vault": {
+        const geometry = new T.CylinderGeometry(part.radius, part.radius, part.length, part.segments, 1, false, 0, part.arc);
+        disposables.push(geometry);
+        const mesh = new THREE.Mesh(geometry, standard(part.color, part.style));
+        mesh.rotation.set(part.rotation.x, part.rotation.y, part.rotation.z);
+        mesh.position.set(part.x, part.y, part.z);
+        mesh.scale.set(part.scale.x, part.scale.y, part.scale.z);
+        shadows(mesh, part.style, true, false);
+        return [mesh];
+      }
+      case "plane": {
+        const geometry = new T.PlaneGeometry(part.width, part.depth).rotateX(-Math.PI / 2);
+        disposables.push(geometry);
+        const mesh = new THREE.Mesh(geometry, standard(part.color, part.style));
+        mesh.position.set(part.x, part.y, part.z);
+        shadows(mesh, part.style, false, true);
+        return [mesh];
+      }
+      case "line": {
+        const geometry = new THREE.BufferGeometry().setFromPoints(part.points.map(([x, y, z]) => new THREE.Vector3(x, y, z)));
+        const mesh = new THREE.Line(geometry, new THREE.LineBasicMaterial({ color: part.color }));
+        mesh.userData.own = true;
+        disposables.push(geometry, mesh.material);
+        return [mesh];
+      }
+      case "sign":
+        return [textPlane(part, texture([part.text], SIGN_CANVAS.width, SIGN_CANVAS.height, part.background, part.foreground, SIGN_FONT))];
+      case "label":
+        return [textPlane(part, texture(part.lines, part.canvas.width, part.canvas.height, part.background, part.foreground, part.font))];
+      case "placement": {
+        const holder = new THREE.Group();
+        holder.position.set(part.x, part.y, part.z);
+        if (part.ry) holder.rotation.y = part.ry;
+        if (part.scale !== 1) holder.scale.setScalar(part.scale);
+        const object = options.resolvers?.[part.kind]?.(part);
+        if (object) holder.add(object);
+        holder.userData.placement = { kind: part.kind, id: part.id };
+        return [holder];
+      }
+      case "light": {
+        if (part.kind === "point") {
+          const light2 = new THREE.PointLight(part.color, part.intensity, part.distance, part.decay);
+          light2.position.set(part.x, part.y, part.z);
+          lights.push(light2);
+          if (part.flicker) {
+            animators.push((t) => {
+              light2.intensity = part.intensity * (Math.sin(t * 23 + part.x) > 0.3 || Math.sin(t * 3.1) > 0.85 ? 0.15 : 1);
+            });
+          }
+          return [light2];
+        }
+        const light = new THREE.SpotLight(part.color, part.intensity, part.distance, part.angle, part.penumbra, part.decay);
+        light.position.set(part.x, part.y, part.z);
+        const target = new THREE.Object3D();
+        target.position.set(part.target.x, part.target.y, part.target.z);
+        light.target = target;
+        lights.push(light);
+        const { sweep } = part;
+        if (sweep) {
+          animators.push((t) => {
+            target.position.set(part.x + Math.sin(t * sweep.speed + part.x) * sweep.radius, 0, part.z + Math.cos(t * sweep.speed + part.x) * sweep.radius);
+          });
+        }
+        return [light, target];
+      }
+    }
+  };
+  const instancedItems = (list) => {
+    const mesh = new THREE.InstancedMesh(roundedBox(1, 1, 1, ITEM_ROUNDNESS), standard(16777215), list.length);
+    const matrix = new THREE.Matrix4();
+    const quaternion = new THREE.Quaternion();
+    const euler = new THREE.Euler();
+    const position = new THREE.Vector3();
+    const scale = new THREE.Vector3();
+    const color = new THREE.Color();
+    list.forEach((entry, index) => {
+      euler.set(entry.rx, entry.ry, entry.rz);
+      quaternion.setFromEuler(euler);
+      matrix.compose(position.set(entry.x, entry.y + entry.height / 2, entry.z), quaternion, scale.set(entry.width, entry.height, entry.depth));
+      mesh.setMatrixAt(index, matrix);
+      mesh.setColorAt(index, color.set(entry.color));
+    });
+    mesh.castShadow = true;
+    mesh.receiveShadow = true;
+    return mesh;
+  };
+  const instancedWindows = (list, material) => {
+    const geometry = new T.PlaneGeometry(1, 1);
+    disposables.push(geometry);
+    const mesh = new THREE.InstancedMesh(geometry, material, list.length);
+    const matrix = new THREE.Matrix4();
+    const quaternion = new THREE.Quaternion();
+    const axis = new THREE.Vector3(0, 1, 0);
+    const scale = new THREE.Vector3();
+    list.forEach((entry, index) => {
+      quaternion.setFromAxisAngle(axis, entry.ry);
+      matrix.compose(new THREE.Vector3(entry.x, entry.y, entry.z), quaternion, scale.set(entry.width, entry.height, 1));
+      mesh.setMatrixAt(index, matrix);
+    });
+    return mesh;
+  };
+  function draw(scene, drawOptions = {}) {
+    const root = drawOptions.root ?? new THREE.Group();
+    const animators = [];
+    const lights = [];
+    const objects = [];
+    for (const part of scene.parts) {
+      const made = drawPart(part, animators, lights);
+      objects.push(made);
+      const parent = part.parent < 0 ? root : objects[part.parent][0];
+      parent.add(...made);
+    }
+    if (scene.items.length) root.add(instancedItems(scene.items));
+    if (scene.windows.lit.length) root.add(instancedWindows(scene.windows.lit, glowing(LIT_WINDOW)));
+    if (scene.windows.dark.length) root.add(instancedWindows(scene.windows.dark, standard(DARK_WINDOW.color, DARK_WINDOW)));
+    return {
+      root,
+      lights,
+      animate: (t) => animators.forEach((step) => step(t)),
+      dispose: () => {
+        root.parent?.remove(root);
+        for (const item of disposables.splice(0)) item.dispose?.();
+        for (const geometry of geometries.values()) geometry.dispose();
+        for (const material of materials.values()) material.dispose();
+        geometries.clear();
+        materials.clear();
+      }
+    };
+  }
+  return { THREE, draw };
+}
+
+// src/resolvers.ts
+import { generate } from "@adatechnology/game-vegetation";
+import { createPlantObject, createVegetationMaterials } from "@adatechnology/game-vegetation/three";
+import { toSpec } from "@adatechnology/game-vegetation-species";
+var cssColor = (value) => `#${value.toString(16).padStart(6, "0")}`;
+function createVehicleResolver(vehicles, options = {}) {
+  const quality = options.quality ?? "lite";
+  const built = /* @__PURE__ */ new Map();
+  const resolve = (part) => {
+    const key = `${part.id}|${part.color ?? ""}|${part.seed}`;
+    if (!built.has(key)) {
+      try {
+        built.set(key, vehicles.build(part.id, { quality, ...part.color === void 0 ? { seed: part.seed } : { color: cssColor(part.color) } }));
+      } catch {
+        built.set(key, null);
+      }
+    }
+    return built.get(key)?.group.clone() ?? null;
+  };
+  resolve.dispose = () => {
+    for (const entry of built.values()) entry?.dispose();
+    built.clear();
+  };
+  return resolve;
+}
+function createPlantResolver(THREE, options = {}) {
+  const materials = options.materials ?? createVegetationMaterials(THREE);
+  const made = /* @__PURE__ */ new Map();
+  const resolve = (part) => {
+    const key = `${part.id}|${part.seed}`;
+    if (!made.has(key)) {
+      try {
+        const mesh = generate(toSpec(part.id), { seed: part.seed, lod: options.lod ?? 1, condition: options.condition ?? "healthy", season: options.season ?? "spring", species: part.id });
+        made.set(key, createPlantObject(THREE, mesh, materials));
+      } catch {
+        made.set(key, null);
+      }
+    }
+    return made.get(key)?.clone() ?? null;
+  };
+  resolve.dispose = () => {
+    for (const object of made.values()) {
+      object?.traverse((o) => o.geometry?.dispose?.());
+    }
+    made.clear();
+  };
+  return resolve;
+}
+
+// src/test-area/module.ts
+import { createPlantProvider as createPlantProvider2, createUrban as createUrban2, createVehicleProvider as createVehicleProvider2, SAMPLE_CELLS } from "@adatechnology/game-urban";
+import { shapeGeometries as shapeGeometries3 } from "@adatechnology/game-shapes-three";
+
+// src/test-area/scenarios.ts
+import { createPlantProvider, createUrban, createVehicleProvider, PARKED_VEHICLE_IDS } from "@adatechnology/game-urban";
+
+// src/test-area/text.ts
+var ptBR = {
+  group: "Cidade",
+  name: "\xC1rea urbana",
+  items: {
+    pole_led_double: "Poste LED de bra\xE7o duplo",
+    pole_concrete_arm: "Poste de concreto com bra\xE7o",
+    pole_cast_iron: "Lampi\xE3o de ferro fundido",
+    pole_wood_crossarm: "Poste de madeira com cruzeta",
+    pole_flood_tower: "Torre de refletores",
+    street_grid: "Grade de ruas com quarteir\xE3o",
+    terrain_patch: "Trecho de terreno",
+    downtown: "Bairro: centro",
+    suburb: "Bairro: sub\xFArbio",
+    working_class: "Bairro: popular",
+    historic_street: "Bairro: rua hist\xF3rica",
+    industrial_port: "Bairro: industrial e porto",
+    railway_village: "Bairro: vila ferrovi\xE1ria",
+    mountain_resort: "Bairro: serra",
+    stilt_village: "Bairro: palafitas",
+    military: "Bairro: militar",
+    rural: "Bairro: rural"
+  },
+  controls: { pattern: "Bairro da bancada", seed: "Semente", lamps: "Lampi\xF5es", budget: "Luzes reais da cena", providers: "Ve\xEDculos e plantas" },
+  hints: {
+    pattern: "Padr\xE3o que as a\xE7\xF5es desenham na frente do jogador",
+    seed: "A mesma semente desenha a mesma rua",
+    lamps: "Quantos lampi\xF5es ficam acesos; o resto queima",
+    budget: "Cada lampi\xE3o aceso gasta uma; passando disso fica s\xF3 a lente brilhando",
+    providers: "Pede ao game-vehicles-fleet e ao game-vegetation-species os carros e as \xE1rvores"
+  },
+  options: {
+    lamps: { pattern: "Os do padr\xE3o", all: "Todos acesos", half: "Metade", none: "Nenhum" },
+    providers: { none: "Nenhum (padr\xE3o)", plants: "Plantas das esp\xE9cies", vehicles: "Ve\xEDculos da frota", both: "Os dois" }
+  },
+  actions: { compose: "Desenhar o bairro", clear: "Tirar o bairro" },
+  layers: { light_radius: "Alcance das luzes", bounds: "Caixas das amostras" },
+  metrics: { samples: "Amostras na sala", draw_calls: "Chamadas de desenho", triangles: "Tri\xE2ngulos", real_lights: "Luzes reais", instances: "Inst\xE2ncias", bench_objects: "Objetos da bancada", light_budget_left: "Or\xE7amento de luzes que sobra" },
+  log: { composed: "Bairro {0} desenhado com a semente {1}: {2} objetos, {3} luzes reais", cleared: "Bairro tirado", no_vehicles: "A sala n\xE3o recebeu um construtor de ve\xEDculos: os carros ficam de fora" },
+  scenarios: {
+    urban_pole_heights: "Os cinco postes t\xEAm a altura da tabela",
+    urban_light_budget: "O or\xE7amento de luzes: as primeiras acesas ganham luz real e o contador passa de zero",
+    urban_road_dashes: "A rua tem uma faixa a cada 5 m",
+    urban_block_heights: "Os pr\xE9dios altos s\xE3o mais raros",
+    urban_neighbourhood_seed: "A mesma semente desenha o mesmo bairro",
+    urban_lamps_burnt: "Um bairro com a fra\xE7\xE3o zero de lampi\xF5es acesos n\xE3o tem nenhum aceso",
+    urban_terrain: "O terreno tem a altura do v\xE9rtice, o leito do rio e o n\xEDvel do lago",
+    urban_providers: "Os provedores pedem ve\xEDculos da frota e esp\xE9cies da regi\xE3o onde o bairro estaciona e planta"
+  },
+  checks: {
+    pole_top: "o poste {0} chega a {1} m",
+    budget_real: "{0} l\xE2mpadas acesas, {1} luzes reais (o or\xE7amento \xE9 {2})",
+    budget_left: "o contador chegou a {0}",
+    dashes: "uma rua de 60 m tem {0} faixas, a primeira em x = {1}",
+    heights_in_range: "os pr\xE9dios ficam entre {0} e {1} m",
+    heights_median: "a mediana dos pr\xE9dios \xE9 {0} m, abaixo do meio {1} m",
+    same_seed: "a mesma semente repete as partes: {0}",
+    other_seed: "outra semente muda o bairro: {0}",
+    lamps_none: "com a fra\xE7\xE3o 0 nenhum dos {0} postes est\xE1 aceso",
+    lamps_all: "o centro mant\xE9m os {0} postes acesos",
+    vertex_height: "a altura do v\xE9rtice central \xE9 {0} m e a da malha {1} m",
+    river_bed: "o leito do rio est\xE1 {0} m abaixo do ch\xE3o ao lado",
+    lake_level: "o centro do lago est\xE1 a {0} m",
+    vehicles_placed: "{0} ve\xEDculos pedidos, {1} vagas de ve\xEDculo na cena",
+    vehicle_ids: "os ve\xEDculos s\xE3o da frota: {0}",
+    plants_placed: "{0} plantas pedidas, {1} vagas de planta na cena"
+  }
+};
+var en = {
+  group: "City",
+  name: "Urban area",
+  items: {
+    pole_led_double: "Double-arm LED pole",
+    pole_concrete_arm: "Concrete pole with an arm",
+    pole_cast_iron: "Cast-iron lantern",
+    pole_wood_crossarm: "Wooden pole with a crossarm",
+    pole_flood_tower: "Floodlight tower",
+    street_grid: "Street grid with a block",
+    terrain_patch: "Terrain patch",
+    downtown: "Neighbourhood: downtown",
+    suburb: "Neighbourhood: suburb",
+    working_class: "Neighbourhood: working class",
+    historic_street: "Neighbourhood: historic street",
+    industrial_port: "Neighbourhood: industrial and port",
+    railway_village: "Neighbourhood: railway village",
+    mountain_resort: "Neighbourhood: mountain resort",
+    stilt_village: "Neighbourhood: stilt village",
+    military: "Neighbourhood: military",
+    rural: "Neighbourhood: rural"
+  },
+  controls: { pattern: "Bench neighbourhood", seed: "Seed", lamps: "Street lamps", budget: "Real lights of the scene", providers: "Vehicles and plants" },
+  hints: {
+    pattern: "The pattern the actions draw in front of the player",
+    seed: "The same seed draws the same street",
+    lamps: "How many lamps are on; the rest are burnt out",
+    budget: "Every lamp that is on spends one; past that it keeps only its glowing lens",
+    providers: "Asks game-vehicles-fleet and game-vegetation-species for the cars and trees"
+  },
+  options: {
+    lamps: { pattern: "The pattern's own", all: "All on", half: "Half", none: "None" },
+    providers: { none: "None (default)", plants: "Plants of the species pack", vehicles: "Vehicles of the fleet", both: "Both" }
+  },
+  actions: { compose: "Draw the neighbourhood", clear: "Take the neighbourhood away" },
+  layers: { light_radius: "Light reach", bounds: "Sample boxes" },
+  metrics: { samples: "Samples in the room", draw_calls: "Draw calls", triangles: "Triangles", real_lights: "Real lights", instances: "Instances", bench_objects: "Bench objects", light_budget_left: "Light budget left" },
+  log: { composed: "Neighbourhood {0} drawn with seed {1}: {2} objects, {3} real lights", cleared: "Neighbourhood taken away", no_vehicles: "The room got no vehicle builder: the cars are left out" },
+  scenarios: {
+    urban_pole_heights: "The five poles stand at the height of the table",
+    urban_light_budget: "The light budget: the first lamps get real lights and the counter goes below zero",
+    urban_road_dashes: "A road has a dash every 5 m",
+    urban_block_heights: "Tall buildings are rarer",
+    urban_neighbourhood_seed: "The same seed draws the same neighbourhood",
+    urban_lamps_burnt: "A neighbourhood with no lamps lit has none on",
+    urban_terrain: "The terrain has the vertex height, the river bed and the lake level",
+    urban_providers: "The providers ask for fleet vehicles and species of the region where the neighbourhood parks and plants"
+  },
+  checks: {
+    pole_top: "pole {0} reaches {1} m",
+    budget_real: "{0} lamps on, {1} real lights (the budget is {2})",
+    budget_left: "the counter reached {0}",
+    dashes: "a 60 m road has {0} dashes, the first at x = {1}",
+    heights_in_range: "the buildings stand between {0} and {1} m",
+    heights_median: "the median building is {0} m, under the middle {1} m",
+    same_seed: "the same seed repeats the parts: {0}",
+    other_seed: "another seed changes the neighbourhood: {0}",
+    lamps_none: "with the share 0 none of the {0} poles is on",
+    lamps_all: "downtown keeps its {0} poles on",
+    vertex_height: "the height of the central vertex is {0} m and the mesh has {1} m",
+    river_bed: "the river bed is {0} m below the land beside it",
+    lake_level: "the centre of the lake is at {0} m",
+    vehicles_placed: "{0} vehicles asked, {1} vehicle spots in the scene",
+    vehicle_ids: "the vehicles are of the fleet: {0}",
+    plants_placed: "{0} plants asked, {1} plant spots in the scene"
+  }
+};
+var TEXT = { "pt-BR": ptBR, en };
+var fill = (template, ...values) => template.replace(/\{(\d+)\}/g, (_match, index) => String(values[Number(index)] ?? ""));
+
+// src/test-area/scenarios.ts
+var POLE_TOPS = { led_double: 9, concrete_arm: 8, cast_iron: 4.8, wood_crossarm: 7, flood_tower: 12.55 };
+var topOf = (parts) => Math.max(...parts.map((part) => "height" in part && "y" in part ? part.y + part.height / 2 : 0));
+var placements = (parts, kind) => parts.filter((part) => part.shape === "placement" && part.kind === kind);
+var round = (value, digits = 3) => Math.round(value * 10 ** digits) / 10 ** digits;
+var createScenarios = (deps) => {
+  const { text } = deps;
+  const say = (id, ...values) => fill(text.checks[id], ...values);
+  const scenario = (id, run) => ({ id, name: text.scenarios[id] ?? id, run });
+  const kit = () => createUrban(deps.urban);
+  return [
+    scenario("urban_pole_heights", ({ expect }) => {
+      const urban = kit();
+      for (const id of urban.poles.ids()) {
+        const expected = POLE_TOPS[id];
+        if (expected === void 0) continue;
+        const b = urban.builder();
+        urban.poles.get(id).build(b, { x: 0, z: 0 });
+        const top = topOf(b.parts);
+        expect(Math.abs(top - expected) < 1e-6, say("pole_top", id, round(top)), { pole: id, top });
+      }
+    }),
+    scenario("urban_light_budget", ({ expect }) => {
+      const urban = kit();
+      const budget = 4;
+      const b = urban.builder({ budget });
+      for (let index = 0; index < 8; index++) urban.poles.get("led_double").build(b, { x: index * 8, z: 0 });
+      const real = b.parts.filter((part) => part.shape === "light").length;
+      expect(real === budget, say("budget_real", 8, real, budget), { real, budget });
+      expect(b.lights.left < 0, say("budget_left", b.lights.left), { left: b.lights.left });
+    }),
+    scenario("urban_road_dashes", ({ expect }) => {
+      const urban = kit();
+      const b = urban.builder();
+      urban.streets.road(b, 0, 0, 7, 60, "x");
+      expect(b.items.length === 12 && b.items[0]?.x === -28 && b.items[1]?.x === -23, say("dashes", b.items.length, b.items[0]?.x), { dashes: b.items.length });
+    }),
+    scenario("urban_block_heights", ({ expect }) => {
+      const urban = kit();
+      const b = urban.builder({ seed: 3 });
+      const placed = urban.block.fill(b, { cx: 0, cz: 0, size: 200, minHeight: 10, maxHeight: 50, k: 20, gap: 0.01 });
+      const heights = placed.map((building) => building.height).sort((a, c) => a - c);
+      const median = heights[Math.floor(heights.length / 2)];
+      expect(heights.length > 0 && heights[0] >= 10 && heights[heights.length - 1] <= 50, say("heights_in_range", 10, 50), { count: heights.length });
+      expect(median < 30, say("heights_median", round(median, 1), 30), { median });
+    }),
+    scenario("urban_neighbourhood_seed", ({ expect }) => {
+      const urban = kit();
+      const draw = (seed) => {
+        const b = urban.builder({ seed });
+        urban.neighbourhoods.get(urban.neighbourhoods.ids()[1]).compose(b, { x: 0, z: 0 });
+        return JSON.stringify(b.scene());
+      };
+      expect(draw(7) === draw(7), say("same_seed", 7));
+      expect(draw(7) !== draw(8), say("other_seed", 8));
+    }),
+    scenario("urban_lamps_burnt", ({ expect }) => {
+      const dark = createUrban({ ...deps.urban, patch: { ...deps.urban?.patch, neighbourhoods: { ...deps.urban?.patch?.neighbourhoods, suburb: { lit: 0 } } } });
+      const suburb = dark.neighbourhoods.get("suburb").compose(dark.builder(), { x: 0, z: 0 });
+      expect(suburb.poles.length > 0 && !suburb.poles.some((pole) => pole.on), say("lamps_none", suburb.poles.length), { poles: suburb.poles.length });
+      const lit = kit();
+      const downtown = lit.neighbourhoods.get("downtown").compose(lit.builder(), { x: 0, z: 0 });
+      expect(downtown.poles.length > 0 && downtown.poles.every((pole) => pole.on), say("lamps_all", downtown.poles.length), { poles: downtown.poles.length });
+    }),
+    scenario("urban_terrain", ({ expect }) => {
+      const urban = kit();
+      const terrain = urban.terrain(deps.terrain);
+      const grid = terrain.grid();
+      const mid = grid.segments / 2 * (grid.segments + 1) + grid.segments / 2;
+      const world = terrain.fromWorld(grid.x[mid], grid.z[mid]);
+      const height = terrain.heightAt(world[0], world[1]);
+      expect(Math.abs(height - grid.heights[mid]) < 1e-3, say("vertex_height", round(height), round(grid.heights[mid])), { height });
+      for (const river of deps.terrain.rivers) {
+        if (!("fixed" in river.bed)) continue;
+        const point = river.points[Math.floor(river.points.length / 2)];
+        const bed = terrain.heightAt(point[0], point[1]);
+        expect(Math.abs(bed - river.bed.fixed) < 1e-6, say("river_bed", round(river.bed.fixed < 0 ? -river.bed.fixed : river.bed.fixed)), { river: river.id, bed });
+      }
+      for (const lake of deps.terrain.lakes) {
+        const level = terrain.heightAt(lake.center[0], lake.center[1]);
+        expect(Math.abs(level - lake.level) < 1e-6, say("lake_level", round(level)), { lake: lake.id, level });
+      }
+    }),
+    scenario("urban_providers", ({ expect }) => {
+      const urban = kit();
+      const cars = urban.builder();
+      const downtown = urban.neighbourhoods.get("downtown").compose(cars, { x: 0, z: 0 }, { providers: { vehicle: createVehicleProvider() } });
+      const spots = placements(cars.parts, "vehicle");
+      expect(spots.length === downtown.vehicles.length && spots.length > 0, say("vehicles_placed", downtown.vehicles.length, spots.length));
+      expect(spots.every((spot) => PARKED_VEHICLE_IDS.includes(spot.id)), say("vehicle_ids", [...new Set(spots.map((spot) => spot.id))].join(", ")));
+      const trees = urban.builder();
+      const mountain = urban.neighbourhoods.get("mountain_resort").compose(trees, { x: 0, z: 0 }, { providers: { plant: createPlantProvider() } });
+      const planted = placements(trees.parts, "plant");
+      expect(planted.length === mountain.plants.length && planted.length > 0, say("plants_placed", mountain.plants.length, planted.length));
+    })
+  ];
+};
+
+// src/test-area/module.ts
+var URBAN_AREA_ID = "urban";
+var DEFAULT_TEST_TERRAIN = {
+  world: { size: 96, scale: 1, origin: -48, segments: 48 },
+  base: {
+    level: 1.2,
+    waves: [
+      { kind: "product", x: ["sin", 0.09], y: ["cos", 0.07], amplitude: 1.1 },
+      { kind: "diagonal", kx: 0.05, ky: 0.04, amplitude: 0.5 }
+    ]
+  },
+  layers: [],
+  flatten: [],
+  rivers: [{ id: "river", points: [[-48, -30], [-20, -24], [10, -30], [48, -22]], width: [3, 9], bed: { fixed: -1.2 } }],
+  lakes: [{ id: "lake", center: [24, 24], radius: [12, 12], level: -0.9, edge: [0.55, 1], reach: 1.4 }],
+  forest: { zones: [{ mask: [{ axis: "x", from: -48, to: -20, fullUntil: -40 }] }] },
+  colors: [
+    { kind: "below", height: 0.1, color: 7043674 },
+    { kind: "forest", above: 0.5, color: 4086325 }
+  ],
+  fields: { colors: [8031317, 9083486, 7308368], cell: [8, 8] },
+  water: { level: -0.35, color: 2835538, roughness: 0.3, metalness: 0.25 }
+};
+var FLOOR_Y = 0;
+var POLE_ROW_Z = -26;
+var POLE_GAP = 6;
+var SHEET_SHIFT_Z = -200;
+var VIEW_FAR = 600;
+var GRID = { block: 36, count: 2, width: 10 };
+var LAMP_SHARES = { pattern: void 0, all: 1, half: 0.5, none: 0 };
+function createUrbanTestModule(options = {}) {
+  const locale = (options.locale ?? "pt-BR").toLowerCase().startsWith("en") ? "en" : "pt-BR";
+  const text = TEXT[locale];
+  const terrain = options.terrain ?? DEFAULT_TEST_TERRAIN;
+  const seed = options.seed ?? 7;
+  const benchOrigin = options.benchOrigin ?? [0, -60];
+  const settings = { pattern: "downtown", seed, lamps: "pattern", budget: 16, providers: "none" };
+  let host = null;
+  let three = null;
+  let clock = 0;
+  let helpersShown = "";
+  let bench = null;
+  const placed = /* @__PURE__ */ new Map();
+  let helpers = [];
+  const resolvers = {};
+  const baseKit = createUrban2(options.urban);
+  const poleIds = baseKit.poles.ids();
+  const patternIds = baseKit.neighbourhoods.ids();
+  const itemIds = [...poleIds.map((id) => `pole_${id}`), "street_grid", "terrain_patch", ...patternIds];
+  const kitWith = (overrides = {}) => {
+    const share = LAMP_SHARES[overrides.lamps ?? "pattern"];
+    const urban = options.urban ?? {};
+    const patch = share === void 0 ? urban.patch : { ...urban.patch, neighbourhoods: { ...urban.patch?.neighbourhoods, ...Object.fromEntries(patternIds.map((id) => [id, { ...urban.patch?.neighbourhoods?.[id] ?? {}, lit: share }])) } };
+    return createUrban2({ ...urban, ...patch ? { patch } : {}, lights: { budget: overrides.budget ?? urban.lights?.budget } });
+  };
+  const resolversFor = (THREE) => {
+    if (!resolvers.plant) resolvers.plant = createPlantResolver(THREE, { lod: 1 });
+    if (!resolvers.vehicle && options.vehicles) resolvers.vehicle = createVehicleResolver(options.vehicles(THREE), { quality: "lite" });
+    return resolvers;
+  };
+  const providersOf = (choice) => {
+    const providers = {};
+    if (choice === "plants" || choice === "both") providers.plant = createPlantProvider2();
+    if ((choice === "vehicles" || choice === "both") && options.vehicles) providers.vehicle = createVehicleProvider2();
+    return providers;
+  };
+  const draw = (THREE, build, kit, buildSeed) => {
+    const b = kit.builder({ seed: buildSeed });
+    build(b, kit);
+    const document = options.document ?? globalThis.document;
+    const drawn = createUrbanThree(THREE, { ...document ? { document } : {}, resolvers: resolversFor(THREE) }).draw(b.scene());
+    return { root: drawn.root, drawn };
+  };
+  const sample = (THREE, key) => {
+    const kit = kitWith();
+    if (key.startsWith("pole_")) return draw(THREE, (b, k) => k.poles.get(key.slice(5)).build(b, { x: 0, z: 0 }), kit, seed);
+    if (key === "street_grid") {
+      return draw(THREE, (b, k) => {
+        k.streets.grid(b, GRID);
+        const inner = GRID.block - GRID.width;
+        k.block.fill(b, { cx: GRID.block / 2, cz: GRID.block / 2, size: inner - 4, minHeight: 10, maxHeight: 40, k: 3 });
+      }, kit, seed);
+    }
+    if (key === "terrain_patch") return draw(THREE, (b, k) => k.drawTerrain(b, k.terrain(terrain)), kit, seed);
+    return draw(THREE, (b, k) => {
+      k.neighbourhoods.get(key).compose(b, { x: 0, z: 0 }, { locale });
+    }, kit, seed);
+  };
+  const item = (id) => ({
+    id,
+    name: text.items[id] ?? id,
+    movable: false,
+    build: (THREE) => {
+      three = THREE;
+      const made = sample(THREE, id);
+      made.root.userData.urbanItem = id;
+      placed.set(made.root.uuid, made);
+      return made.root;
+    },
+    spec: (root) => {
+      const THREE_ = three;
+      const box = new THREE_.Box3().setFromObject(root);
+      const size = box.getSize(new THREE_.Vector3());
+      const centre = box.getCenter(new THREE_.Vector3());
+      return { name: id, tags: ["structure"], parts: [{ id: "ground", material: "concrete", shape: { kind: "box", size: [Math.max(size.x, 0.1), Math.max(size.y, 0.1), Math.max(size.z, 0.1)] }, position: [centre.x, centre.y, centre.z], anchored: true }] };
+    }
+  });
+  const clearBench = () => {
+    if (!bench) return;
+    bench.drawn.dispose();
+    bench = null;
+  };
+  const countObjects = (root) => {
+    let n = 0;
+    root.traverse(() => n++);
+    return n;
+  };
+  const composeBench = () => {
+    if (!host || !three) return;
+    clearBench();
+    const kit = kitWith({ lamps: settings.lamps, budget: settings.budget });
+    if ((settings.providers === "vehicles" || settings.providers === "both") && !options.vehicles) host.log(text.log.no_vehicles);
+    const b = kit.builder({ seed: settings.seed });
+    const made = kit.neighbourhoods.get(settings.pattern).compose(b, { x: 0, z: 0 }, { locale, providers: providersOf(settings.providers) });
+    const document = options.document ?? globalThis.document;
+    const drawn = createUrbanThree(three, { ...document ? { document } : {}, resolvers: resolversFor(three) }).draw(b.scene());
+    drawn.root.position.set(benchOrigin[0], FLOOR_Y, benchOrigin[1]);
+    host.scene.add(drawn.root);
+    bench = { root: drawn.root, drawn, plan: made };
+    lightsLeft = b.lights.left;
+    host.log(fill(text.log.composed, settings.pattern, settings.seed, countObjects(drawn.root), drawn.lights.length), { pattern: settings.pattern, seed: settings.seed });
+    helpersShown = "";
+  };
+  let lightsLeft = settings.budget;
+  const onChange = (change) => {
+    if (change.kind === "layer") return refreshLayers();
+    if (change.kind === "action") {
+      if (change.id === "compose") composeBench();
+      else if (change.id === "clear") {
+        clearBench();
+        host?.log(text.log.cleared);
+      }
+      return;
+    }
+    switch (change.id) {
+      case "pattern":
+        settings.pattern = String(change.value);
+        if (bench) composeBench();
+        break;
+      case "seed":
+        settings.seed = Number(change.value);
+        if (bench) composeBench();
+        break;
+      case "lamps":
+        settings.lamps = String(change.value);
+        if (bench) composeBench();
+        break;
+      case "budget":
+        settings.budget = Number(change.value);
+        if (bench) composeBench();
+        break;
+      case "providers":
+        settings.providers = String(change.value);
+        if (bench) composeBench();
+        break;
+      default:
+        break;
+    }
+  };
+  const roots = () => [...[...placed.values()].filter((entry) => entry.root.parent), ...bench ? [bench] : []];
+  const clearHelpers = () => {
+    for (const helper of helpers) helper.parent?.remove(helper);
+    helpers = [];
+    helpersShown = "";
+  };
+  const boxKey = () => `${host?.bench?.layer("light_radius")}|${host?.bench?.layer("bounds")}|${roots().length}|${bench ? bench.root.uuid : ""}`;
+  const refreshLayers = () => {
+    if (!host?.bench || !three) return;
+    clearHelpers();
+    const mark = (parent, helper) => {
+      helper.userData.helper = true;
+      parent.add(helper);
+      helpers.push(helper);
+    };
+    for (const entry of roots()) {
+      if (!entry.root.parent) continue;
+      entry.root.updateMatrixWorld(true);
+      if (host.bench.layer("bounds")) {
+        const box = new three.Box3().setFromObject(entry.root);
+        const inverse = new three.Matrix4().copy(entry.root.matrixWorld).invert();
+        box.applyMatrix4(inverse);
+        mark(entry.root, new three.Box3Helper(box, 6737151));
+      }
+      if (host.bench.layer("light_radius")) {
+        for (const light of entry.drawn.lights) {
+          if (!light.isPointLight && !light.isSpotLight) continue;
+          const reach = new three.Mesh(new (shapeGeometries3(three)).SphereGeometry(Math.min(light.distance || 10, 60), 14, 8), new three.MeshBasicMaterial({ color: light.color ?? 16764006, wireframe: true, transparent: true, opacity: 0.25 }));
+          reach.position.copy(light.position);
+          mark(light.parent ?? entry.root, reach);
+        }
+      }
+    }
+    helpersShown = boxKey();
+  };
+  const frame = (dt) => {
+    clock += dt;
+    for (const entry of roots()) entry.drawn.animate(clock);
+    for (const [id, entry] of placed) if (!entry.root.parent) placed.delete(id);
+    if (host?.bench && boxKey() !== helpersShown && (host.bench.layer("light_radius") || host.bench.layer("bounds") || helpersShown !== "")) refreshLayers();
+  };
+  const count = () => {
+    let drawCalls = 0;
+    let triangles = 0;
+    let lights = 0;
+    let instances = 0;
+    for (const entry of roots()) {
+      entry.root.traverse((o) => {
+        if (o.isLight) lights += 1;
+        if (!o.isMesh || o.userData.helper) return;
+        for (let p = o; p; p = p.parent) if (p.visible === false) return;
+        drawCalls += 1;
+        if (o.isInstancedMesh) instances += o.count;
+        const g = o.geometry;
+        const perInstance = (g.index ? g.index.count : g.attributes.position.count) / 3;
+        triangles += perInstance * (o.isInstancedMesh ? o.count : 1);
+      });
+    }
+    return { drawCalls, triangles: Math.round(triangles), lights, instances };
+  };
+  const area = () => {
+    const placements2 = [];
+    poleIds.forEach((id, index) => placements2.push({ item: `pole_${id}`, position: [(index - (poleIds.length - 1) / 2) * POLE_GAP, 0, POLE_ROW_Z], rotationY: 0 }));
+    placements2.push({ item: "street_grid", position: [-230, 0, -200], rotationY: 0 });
+    placements2.push({ item: "terrain_patch", position: [270, 0, -150], rotationY: 0 });
+    for (const id of patternIds) {
+      const cell = SAMPLE_CELLS[id];
+      if (cell) placements2.push({ item: id, position: [cell.x, 0, cell.z + SHEET_SHIFT_Z], rotationY: 0 });
+    }
+    const extra = patternIds.filter((id) => !SAMPLE_CELLS[id]);
+    extra.forEach((id, index) => placements2.push({ item: id, position: [-80 + index * 80, 0, SHEET_SHIFT_Z - 112], rotationY: 0 }));
+    return { placements: placements2, view: { eye: [20, 190, -20], target: [20, 0, -190] } };
+  };
+  return {
+    id: URBAN_AREA_ID,
+    name: text.name,
+    group: text.group,
+    get placed() {
+      return placed;
+    },
+    itemIds,
+    tick: (t) => {
+      for (const entry of roots()) entry.drawn.animate(t);
+    },
+    items: () => itemIds.map(item),
+    scenarios: () => createScenarios({ text: TEXT[locale], urban: options.urban, terrain }),
+    area,
+    controls: () => [
+      { kind: "choice", id: "pattern", name: text.controls.pattern, hint: text.hints.pattern, options: patternIds.map((id) => ({ id, name: text.items[id] ?? id })), default: patternIds.includes("downtown") ? "downtown" : patternIds[0] },
+      { kind: "number", id: "seed", name: text.controls.seed, hint: text.hints.seed, min: 0, max: 99999, step: 1, default: seed },
+      { kind: "choice", id: "lamps", name: text.controls.lamps, hint: text.hints.lamps, options: Object.keys(LAMP_SHARES).map((id) => ({ id, name: text.options.lamps[id] })), default: "pattern" },
+      { kind: "number", id: "budget", name: text.controls.budget, hint: text.hints.budget, min: 0, max: 64, step: 1, default: 16 },
+      { kind: "choice", id: "providers", name: text.controls.providers, hint: text.hints.providers, options: ["none", "plants", "vehicles", "both"].map((id) => ({ id, name: text.options.providers[id] })), default: "none" },
+      { kind: "action", id: "compose", name: text.actions.compose },
+      { kind: "action", id: "clear", name: text.actions.clear }
+    ],
+    layers: () => ["light_radius", "bounds"].map((id) => ({ id, name: text.layers[id], default: false })),
+    metrics: () => [
+      { id: "samples", name: text.metrics.samples, read: () => [...placed.values()].filter((entry) => entry.root.parent).length },
+      { id: "draw_calls", name: text.metrics.draw_calls, read: () => count().drawCalls },
+      { id: "triangles", name: text.metrics.triangles, read: () => count().triangles },
+      { id: "real_lights", name: text.metrics.real_lights, read: () => count().lights },
+      { id: "instances", name: text.metrics.instances, read: () => count().instances },
+      { id: "bench_objects", name: text.metrics.bench_objects, read: () => bench ? countObjects(bench.root) : 0 },
+      { id: "light_budget_left", name: text.metrics.light_budget_left, read: () => bench ? lightsLeft : settings.budget }
+    ],
+    attach(lent) {
+      host = lent;
+      three = lent.THREE;
+      const camera = lent.camera;
+      const farBefore = camera?.far;
+      if (camera && camera.far < VIEW_FAR) {
+        camera.far = VIEW_FAR;
+        camera.updateProjectionMatrix();
+      }
+      const stopChange = lent.bench?.onChange(onChange);
+      const stopFrame = lent.onFrame(frame);
+      return () => {
+        stopChange?.();
+        stopFrame();
+        clearHelpers();
+        clearBench();
+        if (camera && farBefore !== void 0) {
+          camera.far = farBefore;
+          camera.updateProjectionMatrix();
+        }
+        resolvers.plant?.dispose?.();
+        resolvers.vehicle?.dispose?.();
+        host = null;
+      };
+    }
+  };
+}
+function loadUrbanTestModule(room, options = {}) {
+  return room.loadModule(createUrbanTestModule(options));
+}
+export {
+  DEFAULT_TEST_TERRAIN,
+  POLE_TOPS,
+  TEXT,
+  URBAN_AREA_ID,
+  createPlantResolver,
+  createPrism,
+  createRoundedBox,
+  createScenarios,
+  createTextTexture,
+  createUrbanTestModule,
+  createUrbanThree,
+  createVehicleResolver,
+  loadUrbanTestModule
+};
+//# sourceMappingURL=index.js.map