@geolibre/core 3.6.1 → 3.7.0

package/dist/geodesic.mjs

@@ -0,0 +1,155 @@
+import { f as getActiveEllipsoid } from "./ellipsoids-DlTLddDu.mjs";
+import geographiclib from "geographiclib-geodesic";
+// src/geodesic.ts
+/**
+* Distances and areas on the active body's ellipsoid, for the Field Calculator
+* and the processing tools.
+*
+* The geodesic math is Charles Karney's GeographicLib (`geographiclib-geodesic`,
+* MIT, no dependencies), the same algorithms PROJ's `geod` and pyproj use, with
+* errors of a few nanometres. This is the only module that imports it, so
+* replacing the package (for example with a vendored copy) touches this file
+* alone.
+*
+* Each helper takes an optional ellipsoid and defaults to the active one
+* (`ellipsoids.ts`), so the Moon and Mars are measured on their own figure
+* rather than on Earth scaled by a radius ratio. Positions are GeoJSON
+* `[lon, lat]` degrees; any Z is ignored.
+*
+* Workers import it as `@geolibre/core/geodesic` rather than through
+* `worker-safe`, so the workers that need no measurements don't bundle
+* GeographicLib.
+*/
+const solvers = /* @__PURE__ */ new WeakMap();
+function solverFor(ellipsoid) {
+	let solver = solvers.get(ellipsoid);
+	if (!solver) {
+		const f = ellipsoid.inverseFlattening ? 1 / ellipsoid.inverseFlattening : 0;
+		solver = new geographiclib.Geodesic.Geodesic(ellipsoid.semiMajorAxisMeters, f);
+		solvers.set(ellipsoid, solver);
+	}
+	return solver;
+}
+/** Geodesic (shortest-path) distance in metres between two positions. */
+function geodesicDistance(from, to, ellipsoid = getActiveEllipsoid()) {
+	return solverFor(ellipsoid).Inverse(from[1], from[0], to[1], to[0], geographiclib.Geodesic.DISTANCE).s12;
+}
+const DEG_TO_RAD = Math.PI / 180;
+/**
+* Central angle in radians between two positions, taking their geodetic
+* latitude and longitude as coordinates on a sphere. Much cheaper than
+* {@link geodesicDistance}; with {@link geodesicRadiusBounds} it bounds a
+* geodesic distance without computing it, which lets the O(n²) loops skip most
+* pairs.
+*/
+function centralAngle(from, to) {
+	const lat1 = from[1] * DEG_TO_RAD;
+	const lat2 = to[1] * DEG_TO_RAD;
+	const dLon = (to[0] - from[0]) * DEG_TO_RAD;
+	const h = Math.sin((lat2 - lat1) / 2) ** 2 + Math.cos(lat1) * Math.cos(lat2) * Math.sin(dLon / 2) ** 2;
+	if (h <= .5) return 2 * Math.asin(Math.sqrt(h));
+	const sinLat1 = Math.sin(lat1);
+	const cosLat1 = Math.cos(lat1);
+	const sinLat2 = Math.sin(lat2);
+	const cosLat2 = Math.cos(lat2);
+	const cosDLon = Math.cos(dLon);
+	const x = cosLat2 * Math.sin(dLon);
+	const y = cosLat1 * sinLat2 - sinLat1 * cosLat2 * cosDLon;
+	const z = sinLat1 * sinLat2 + cosLat1 * cosLat2 * cosDLon;
+	return Math.atan2(Math.hypot(x, y), z);
+}
+/**
+* Radii in metres such that, for any two positions,
+* `min * centralAngle(p, q) <= geodesicDistance(p, q) <= max * centralAngle(p, q)`.
+*
+* Why it holds: send each point of the ellipsoid to the point of the unit
+* sphere with the same latitude and longitude. The line element is
+* ds² = M² dφ² + N² cos²φ dλ² on the ellipsoid and dφ² + cos²φ dλ² on the
+* sphere, and both radii of curvature M and N lie between b²/a (M at the
+* equator) and a²/b (both at the poles). Every curve on one surface is
+* therefore between b²/a and a²/b times as long as its image on the other, and
+* so are the shortest paths. On Earth that is 6,335,439 m to 6,399,594 m, within
+* 0.6 % of the mean radius; on a sphere both radii equal its radius. On a
+* prolate figure (b > a, a negative inverse flattening) the two swap, hence the
+* min and max. The 1e-9 margin covers rounding in the central angle and in
+* GeographicLib.
+*/
+function geodesicRadiusBounds(ellipsoid = getActiveEllipsoid()) {
+	const a = ellipsoid.semiMajorAxisMeters;
+	const b = ellipsoid.inverseFlattening ? a * (1 - 1 / ellipsoid.inverseFlattening) : a;
+	const meridianAtEquator = b * b / a;
+	const atPole = a * a / b;
+	return {
+		min: Math.min(meridianAtEquator, atPole) * (1 - 1e-9),
+		max: Math.max(meridianAtEquator, atPole) * (1 + 1e-9)
+	};
+}
+/**
+* Whether two positions are at most `meters` apart along the geodesic. The
+* answer is the same as comparing {@link geodesicDistance}, which is only
+* computed when the {@link geodesicRadiusBounds} cannot decide. A loop can pass
+* the bounds once, and the central angle when it already has it, so this stays
+* the one place the rule is written.
+*/
+function withinGeodesicDistance(from, to, meters, ellipsoid = getActiveEllipsoid(), bounds = geodesicRadiusBounds(ellipsoid), angle = centralAngle(from, to)) {
+	if (angle * bounds.max <= meters) return true;
+	if (angle * bounds.min > meters) return false;
+	return geodesicDistance(from, to, ellipsoid) <= meters;
+}
+/** Summed geodesic length in metres along a run of positions. */
+function geodesicLength(positions, ellipsoid = getActiveEllipsoid()) {
+	let total = 0;
+	for (let i = 1; i < positions.length; i += 1) total += geodesicDistance(positions[i - 1], positions[i], ellipsoid);
+	return total;
+}
+/**
+* Area in square metres enclosed by one ring, whatever its winding order. The
+* ring may be open or closed. Edges are geodesics, so a ring that crosses the
+* antimeridian or encircles a pole is measured correctly.
+*/
+function geodesicRingArea(ring, ellipsoid = getActiveEllipsoid()) {
+	if (ring.length < 3) return 0;
+	const polygon = solverFor(ellipsoid).Polygon(false);
+	for (const position of ring) polygon.AddPoint(position[1], position[0]);
+	return Math.abs(polygon.Compute(false, true).area ?? 0);
+}
+/**
+* Area in square metres of the box bounded by the meridians `west` and `east`
+* and the parallels `south` and `north` (degrees). `east - west` may span up
+* to 360°; a box with `east < west` crosses the antimeridian and spans
+* `east - west + 360`. Latitudes are clamped to ±90°.
+*
+* Its edges along parallels are not geodesics, so this is the closed form for
+* a zone of the ellipsoid, b² Δλ [F(φ₂) − F(φ₁)] with
+* F(φ) = sin φ / (2 (1 − e² sin² φ)) + atanh(e sin φ) / (2e), which reduces to
+* R² Δλ (sin φ₂ − sin φ₁) on a sphere and uses atan for a prolate figure
+* (e² < 0). It holds up to the whole body, unlike a ring of geodesics, which
+* would go the short way round a box wider than 180°.
+*/
+function latLonBoxArea(west, south, east, north, ellipsoid = getActiveEllipsoid()) {
+	const a = ellipsoid.semiMajorAxisMeters;
+	const f = ellipsoid.inverseFlattening ? 1 / ellipsoid.inverseFlattening : 0;
+	const b = a * (1 - f);
+	const e2 = f * (2 - f);
+	const e = Math.sqrt(Math.abs(e2));
+	const zone = (lat) => {
+		const s = Math.sin(Math.max(-90, Math.min(90, lat)) * DEG_TO_RAD);
+		if (e === 0) return s;
+		const tail = e2 > 0 ? Math.atanh(e * s) : Math.atan(e * s);
+		return s / (2 * (1 - e2 * s * s)) + tail / (2 * e);
+	};
+	const span = east < west ? ((east - west) % 360 + 360) % 360 : east - west;
+	const dLon = Math.min(360, span) * DEG_TO_RAD;
+	return b * b * dLon * Math.abs(zone(north) - zone(south));
+}
+/**
+* Whether a position is a usable lon/lat: both finite and |lat| <= 90°.
+* GeographicLib returns NaN for latitudes beyond the poles.
+*/
+function isLonLat(position) {
+	const [lon, lat] = position;
+	return Number.isFinite(lon) && Number.isFinite(lat) && Math.abs(lat) <= 90;
+}
+export { centralAngle, geodesicDistance, geodesicLength, geodesicRadiusBounds, geodesicRingArea, isLonLat, latLonBoxArea, withinGeodesicDistance };
+
+//# sourceMappingURL=geodesic.mjs.map

package/dist/geodesic.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"geodesic.mjs","names":[],"sources":["../src/geodesic.ts"],"sourcesContent":["/**\n * Distances and areas on the active body's ellipsoid, for the Field Calculator\n * and the processing tools.\n *\n * The geodesic math is Charles Karney's GeographicLib (`geographiclib-geodesic`,\n * MIT, no dependencies), the same algorithms PROJ's `geod` and pyproj use, with\n * errors of a few nanometres. This is the only module that imports it, so\n * replacing the package (for example with a vendored copy) touches this file\n * alone.\n *\n * Each helper takes an optional ellipsoid and defaults to the active one\n * (`ellipsoids.ts`), so the Moon and Mars are measured on their own figure\n * rather than on Earth scaled by a radius ratio. Positions are GeoJSON\n * `[lon, lat]` degrees; any Z is ignored.\n *\n * Workers import it as `@geolibre/core/geodesic` rather than through\n * `worker-safe`, so the workers that need no measurements don't bundle\n * GeographicLib.\n */\nimport geographiclib from \"geographiclib-geodesic\";\nimport type { Position } from \"geojson\";\nimport { getActiveEllipsoid, type Ellipsoid } from \"./ellipsoids\";\n\ntype GeodesicSolver = InstanceType<typeof geographiclib.Geodesic.Geodesic>;\n\n// One solver per ellipsoid: construction precomputes series coefficients that\n// every later call reuses.\nconst solvers = new WeakMap<Ellipsoid, GeodesicSolver>();\n\nfunction solverFor(ellipsoid: Ellipsoid): GeodesicSolver {\n  let solver = solvers.get(ellipsoid);\n  if (!solver) {\n    // `inverseFlattening: 0` marks a sphere, which GeographicLib takes as f = 0.\n    const f = ellipsoid.inverseFlattening ? 1 / ellipsoid.inverseFlattening : 0;\n    solver = new geographiclib.Geodesic.Geodesic(ellipsoid.semiMajorAxisMeters, f);\n    solvers.set(ellipsoid, solver);\n  }\n  return solver;\n}\n\n/** Geodesic (shortest-path) distance in metres between two positions. */\nexport function geodesicDistance(\n  from: Position,\n  to: Position,\n  ellipsoid: Ellipsoid = getActiveEllipsoid(),\n): number {\n  return solverFor(ellipsoid).Inverse(\n    from[1],\n    from[0],\n    to[1],\n    to[0],\n    geographiclib.Geodesic.DISTANCE,\n  ).s12!;\n}\n\nconst DEG_TO_RAD = Math.PI / 180;\n\n/**\n * Central angle in radians between two positions, taking their geodetic\n * latitude and longitude as coordinates on a sphere. Much cheaper than\n * {@link geodesicDistance}; with {@link geodesicRadiusBounds} it bounds a\n * geodesic distance without computing it, which lets the O(n²) loops skip most\n * pairs.\n */\nexport function centralAngle(from: Position, to: Position): number {\n  const lat1 = from[1] * DEG_TO_RAD;\n  const lat2 = to[1] * DEG_TO_RAD;\n  const dLon = (to[0] - from[0]) * DEG_TO_RAD;\n  const h =\n    Math.sin((lat2 - lat1) / 2) ** 2 + Math.cos(lat1) * Math.cos(lat2) * Math.sin(dLon / 2) ** 2;\n  // The haversine is well conditioned up to 90° (h <= 0.5), the common case\n  // in the neighbour searches. Beyond, asin loses precision towards the\n  // antipode, so the atan2 form takes over.\n  if (h <= 0.5) return 2 * Math.asin(Math.sqrt(h));\n  const sinLat1 = Math.sin(lat1);\n  const cosLat1 = Math.cos(lat1);\n  const sinLat2 = Math.sin(lat2);\n  const cosLat2 = Math.cos(lat2);\n  const cosDLon = Math.cos(dLon);\n  const x = cosLat2 * Math.sin(dLon);\n  const y = cosLat1 * sinLat2 - sinLat1 * cosLat2 * cosDLon;\n  const z = sinLat1 * sinLat2 + cosLat1 * cosLat2 * cosDLon;\n  return Math.atan2(Math.hypot(x, y), z);\n}\n\n/**\n * Radii in metres such that, for any two positions,\n * `min * centralAngle(p, q) <= geodesicDistance(p, q) <= max * centralAngle(p, q)`.\n *\n * Why it holds: send each point of the ellipsoid to the point of the unit\n * sphere with the same latitude and longitude. The line element is\n * ds² = M² dφ² + N² cos²φ dλ² on the ellipsoid and dφ² + cos²φ dλ² on the\n * sphere, and both radii of curvature M and N lie between b²/a (M at the\n * equator) and a²/b (both at the poles). Every curve on one surface is\n * therefore between b²/a and a²/b times as long as its image on the other, and\n * so are the shortest paths. On Earth that is 6,335,439 m to 6,399,594 m, within\n * 0.6 % of the mean radius; on a sphere both radii equal its radius. On a\n * prolate figure (b > a, a negative inverse flattening) the two swap, hence the\n * min and max. The 1e-9 margin covers rounding in the central angle and in\n * GeographicLib.\n */\nexport function geodesicRadiusBounds(ellipsoid: Ellipsoid = getActiveEllipsoid()): {\n  min: number;\n  max: number;\n} {\n  const a = ellipsoid.semiMajorAxisMeters;\n  const b = ellipsoid.inverseFlattening ? a * (1 - 1 / ellipsoid.inverseFlattening) : a;\n  const meridianAtEquator = (b * b) / a;\n  const atPole = (a * a) / b;\n  return {\n    min: Math.min(meridianAtEquator, atPole) * (1 - 1e-9),\n    max: Math.max(meridianAtEquator, atPole) * (1 + 1e-9),\n  };\n}\n\n/**\n * Whether two positions are at most `meters` apart along the geodesic. The\n * answer is the same as comparing {@link geodesicDistance}, which is only\n * computed when the {@link geodesicRadiusBounds} cannot decide. A loop can pass\n * the bounds once, and the central angle when it already has it, so this stays\n * the one place the rule is written.\n */\nexport function withinGeodesicDistance(\n  from: Position,\n  to: Position,\n  meters: number,\n  ellipsoid: Ellipsoid = getActiveEllipsoid(),\n  bounds: { min: number; max: number } = geodesicRadiusBounds(ellipsoid),\n  angle: number = centralAngle(from, to),\n): boolean {\n  if (angle * bounds.max <= meters) return true;\n  if (angle * bounds.min > meters) return false;\n  return geodesicDistance(from, to, ellipsoid) <= meters;\n}\n\n/** Summed geodesic length in metres along a run of positions. */\nexport function geodesicLength(\n  positions: readonly Position[],\n  ellipsoid: Ellipsoid = getActiveEllipsoid(),\n): number {\n  let total = 0;\n  for (let i = 1; i < positions.length; i += 1) {\n    total += geodesicDistance(positions[i - 1], positions[i], ellipsoid);\n  }\n  return total;\n}\n\n/**\n * Area in square metres enclosed by one ring, whatever its winding order. The\n * ring may be open or closed. Edges are geodesics, so a ring that crosses the\n * antimeridian or encircles a pole is measured correctly.\n */\nexport function geodesicRingArea(\n  ring: readonly Position[],\n  ellipsoid: Ellipsoid = getActiveEllipsoid(),\n): number {\n  if (ring.length < 3) return 0;\n  const polygon = solverFor(ellipsoid).Polygon(false);\n  for (const position of ring) polygon.AddPoint(position[1], position[0]);\n  // `sign = true` reports a signed area, counter-clockwise positive, in\n  // (-half, +half] of the body. Its absolute value is the area the ring\n  // encloses for either winding, including a ring around a pole; a ring that\n  // bounds more than half the body is measured as the smaller side.\n  return Math.abs(polygon.Compute(false, true).area ?? 0);\n}\n\n/**\n * Area in square metres of the box bounded by the meridians `west` and `east`\n * and the parallels `south` and `north` (degrees). `east - west` may span up\n * to 360°; a box with `east < west` crosses the antimeridian and spans\n * `east - west + 360`. Latitudes are clamped to ±90°.\n *\n * Its edges along parallels are not geodesics, so this is the closed form for\n * a zone of the ellipsoid, b² Δλ [F(φ₂) − F(φ₁)] with\n * F(φ) = sin φ / (2 (1 − e² sin² φ)) + atanh(e sin φ) / (2e), which reduces to\n * R² Δλ (sin φ₂ − sin φ₁) on a sphere and uses atan for a prolate figure\n * (e² < 0). It holds up to the whole body, unlike a ring of geodesics, which\n * would go the short way round a box wider than 180°.\n */\nexport function latLonBoxArea(\n  west: number,\n  south: number,\n  east: number,\n  north: number,\n  ellipsoid: Ellipsoid = getActiveEllipsoid(),\n): number {\n  const a = ellipsoid.semiMajorAxisMeters;\n  const f = ellipsoid.inverseFlattening ? 1 / ellipsoid.inverseFlattening : 0;\n  const b = a * (1 - f);\n  const e2 = f * (2 - f);\n  const e = Math.sqrt(Math.abs(e2));\n  const zone = (lat: number): number => {\n    const s = Math.sin(Math.max(-90, Math.min(90, lat)) * DEG_TO_RAD);\n    if (e === 0) return s;\n    const tail = e2 > 0 ? Math.atanh(e * s) : Math.atan(e * s);\n    return s / (2 * (1 - e2 * s * s)) + tail / (2 * e);\n  };\n  // A negative span crosses the antimeridian; wrapping it into [0°, 360°)\n  // also keeps unwrapped longitudes such as 200 to -200 from giving a\n  // negative area.\n  const span = east < west ? (((east - west) % 360) + 360) % 360 : east - west;\n  const dLon = Math.min(360, span) * DEG_TO_RAD;\n  return b * b * dLon * Math.abs(zone(north) - zone(south));\n}\n\n/**\n * Whether a position is a usable lon/lat: both finite and |lat| <= 90°.\n * GeographicLib returns NaN for latitudes beyond the poles.\n */\nexport function isLonLat(position: Position): boolean {\n  const [lon, lat] = position;\n  return Number.isFinite(lon) && Number.isFinite(lat) && Math.abs(lat) <= 90;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AA2BA,MAAM,0BAAU,IAAI,QAAmC;AAEvD,SAAS,UAAU,WAAsC;CACvD,IAAI,SAAS,QAAQ,IAAI,SAAS;CAClC,IAAI,CAAC,QAAQ;EAEX,MAAM,IAAI,UAAU,oBAAoB,IAAI,UAAU,oBAAoB;EAC1E,SAAS,IAAI,cAAc,SAAS,SAAS,UAAU,qBAAqB,CAAC;EAC7E,QAAQ,IAAI,WAAW,MAAM;CAC/B;CACA,OAAO;AACT;;AAGA,SAAgB,iBACd,MACA,IACA,YAAuB,mBAAmB,GAClC;CACR,OAAO,UAAU,SAAS,CAAC,CAAC,QAC1B,KAAK,IACL,KAAK,IACL,GAAG,IACH,GAAG,IACH,cAAc,SAAS,QACzB,CAAC,CAAC;AACJ;AAEA,MAAM,aAAa,KAAK,KAAK;;;;;;;;AAS7B,SAAgB,aAAa,MAAgB,IAAsB;CACjE,MAAM,OAAO,KAAK,KAAK;CACvB,MAAM,OAAO,GAAG,KAAK;CACrB,MAAM,QAAQ,GAAG,KAAK,KAAK,MAAM;CACjC,MAAM,IACJ,KAAK,KAAK,OAAO,QAAQ,CAAC,KAAK,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,IAAI,OAAO,CAAC,KAAK;CAI7F,IAAI,KAAK,IAAK,OAAO,IAAI,KAAK,KAAK,KAAK,KAAK,CAAC,CAAC;CAC/C,MAAM,UAAU,KAAK,IAAI,IAAI;CAC7B,MAAM,UAAU,KAAK,IAAI,IAAI;CAC7B,MAAM,UAAU,KAAK,IAAI,IAAI;CAC7B,MAAM,UAAU,KAAK,IAAI,IAAI;CAC7B,MAAM,UAAU,KAAK,IAAI,IAAI;CAC7B,MAAM,IAAI,UAAU,KAAK,IAAI,IAAI;CACjC,MAAM,IAAI,UAAU,UAAU,UAAU,UAAU;CAClD,MAAM,IAAI,UAAU,UAAU,UAAU,UAAU;CAClD,OAAO,KAAK,MAAM,KAAK,MAAM,GAAG,CAAC,GAAG,CAAC;AACvC;;;;;;;;;;;;;;;;;AAkBA,SAAgB,qBAAqB,YAAuB,mBAAmB,GAG7E;CACA,MAAM,IAAI,UAAU;CACpB,MAAM,IAAI,UAAU,oBAAoB,KAAK,IAAI,IAAI,UAAU,qBAAqB;CACpF,MAAM,oBAAqB,IAAI,IAAK;CACpC,MAAM,SAAU,IAAI,IAAK;CACzB,OAAO;EACL,KAAK,KAAK,IAAI,mBAAmB,MAAM,KAAK,IAAI;EAChD,KAAK,KAAK,IAAI,mBAAmB,MAAM,KAAK,IAAI;CAClD;AACF;;;;;;;;AASA,SAAgB,uBACd,MACA,IACA,QACA,YAAuB,mBAAmB,GAC1C,SAAuC,qBAAqB,SAAS,GACrE,QAAgB,aAAa,MAAM,EAAE,GAC5B;CACT,IAAI,QAAQ,OAAO,OAAO,QAAQ,OAAO;CACzC,IAAI,QAAQ,OAAO,MAAM,QAAQ,OAAO;CACxC,OAAO,iBAAiB,MAAM,IAAI,SAAS,KAAK;AAClD;;AAGA,SAAgB,eACd,WACA,YAAuB,mBAAmB,GAClC;CACR,IAAI,QAAQ;CACZ,KAAK,IAAI,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK,GACzC,SAAS,iBAAiB,UAAU,IAAI,IAAI,UAAU,IAAI,SAAS;CAErE,OAAO;AACT;;;;;;AAOA,SAAgB,iBACd,MACA,YAAuB,mBAAmB,GAClC;CACR,IAAI,KAAK,SAAS,GAAG,OAAO;CAC5B,MAAM,UAAU,UAAU,SAAS,CAAC,CAAC,QAAQ,KAAK;CAClD,KAAK,MAAM,YAAY,MAAM,QAAQ,SAAS,SAAS,IAAI,SAAS,EAAE;CAKtE,OAAO,KAAK,IAAI,QAAQ,QAAQ,OAAO,IAAI,CAAC,CAAC,QAAQ,CAAC;AACxD;;;;;;;;;;;;;;AAeA,SAAgB,cACd,MACA,OACA,MACA,OACA,YAAuB,mBAAmB,GAClC;CACR,MAAM,IAAI,UAAU;CACpB,MAAM,IAAI,UAAU,oBAAoB,IAAI,UAAU,oBAAoB;CAC1E,MAAM,IAAI,KAAK,IAAI;CACnB,MAAM,KAAK,KAAK,IAAI;CACpB,MAAM,IAAI,KAAK,KAAK,KAAK,IAAI,EAAE,CAAC;CAChC,MAAM,QAAQ,QAAwB;EACpC,MAAM,IAAI,KAAK,IAAI,KAAK,IAAI,KAAK,KAAK,IAAI,IAAI,GAAG,CAAC,IAAI,UAAU;EAChE,IAAI,MAAM,GAAG,OAAO;EACpB,MAAM,OAAO,KAAK,IAAI,KAAK,MAAM,IAAI,CAAC,IAAI,KAAK,KAAK,IAAI,CAAC;EACzD,OAAO,KAAK,KAAK,IAAI,KAAK,IAAI,MAAM,QAAQ,IAAI;CAClD;CAIA,MAAM,OAAO,OAAO,SAAU,OAAO,QAAQ,MAAO,OAAO,MAAM,OAAO;CACxE,MAAM,OAAO,KAAK,IAAI,KAAK,IAAI,IAAI;CACnC,OAAO,IAAI,IAAI,OAAO,KAAK,IAAI,KAAK,KAAK,IAAI,KAAK,KAAK,CAAC;AAC1D;;;;;AAMA,SAAgB,SAAS,UAA6B;CACpD,MAAM,CAAC,KAAK,OAAO;CACnB,OAAO,OAAO,SAAS,GAAG,KAAK,OAAO,SAAS,GAAG,KAAK,KAAK,IAAI,GAAG,KAAK;AAC1E"}