@danceiny/gotry 0.0.1-rc.9 → 0.2.0-rc.27

package/ts/dsh-runtime/vendor/dsh-map-tools/lib/clients/osrm.js

@@ -0,0 +1,58 @@
+/** OSRM public server client — free route fallback (no API key). */
+import { formatLngLat } from '../types.js';
+const PUBLIC_OSRM = 'https://router.project-osrm.org';
+export class OsrmClient {
+    opts;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    /**
+     * Plan a route. `profile` maps to OSRM profiles: driving | walking | cycling.
+     * OSRM has no transit profile — callers must not request transit here.
+     */
+    async route(origin, destination, profile, signal) {
+        const url = new URL(`${this.opts.baseUrl ?? PUBLIC_OSRM}/route/v1/${profile}/${formatLngLat(origin)};${formatLngLat(destination)}`);
+        url.searchParams.set('overview', 'full');
+        url.searchParams.set('geometries', 'geojson');
+        url.searchParams.set('steps', 'true');
+        let res;
+        try {
+            res = await fetch(url, { signal, headers: { Accept: 'application/json' } });
+        }
+        catch (err) {
+            const reason = err instanceof Error ? err.message : String(err);
+            throw new Error(`无法访问 OSRM 免费路线服务（${reason}）。部分网络环境下该服务不可达，建议在插件配置中设置高德 amapKey（https://console.amap.com/dev/key/app）以获得稳定的路线规划。`);
+        }
+        if (!res.ok)
+            throw new Error(`OSRM HTTP ${res.status}: ${res.statusText}`);
+        const body = (await res.json());
+        if (body.code !== 'Ok' || !body.routes?.length) {
+            throw new Error(`OSRM error: ${body.code ?? 'unknown'} (no route between the given points)`);
+        }
+        const route = body.routes[0];
+        const steps = [];
+        for (const leg of route.legs ?? []) {
+            for (const s of leg.steps ?? []) {
+                const modifier = s.maneuver?.modifier ? ` (${s.maneuver.modifier})` : '';
+                steps.push({
+                    instruction: `${s.maneuver?.instruction ?? 'continue'} ${s.name ?? ''}${modifier}`.trim(),
+                    distanceM: s.distance ?? 0,
+                    durationS: s.duration ?? 0,
+                });
+            }
+        }
+        const points = typeof route.geometry === 'string'
+            ? []
+            : (route.geometry.coordinates ?? []).map(([lng, lat]) => [lng, lat]);
+        return {
+            provider: 'osrm',
+            distanceM: route.distance ?? 0,
+            durationS: route.duration ?? 0,
+            polyline: JSON.stringify(route.geometry),
+            points,
+            // OSRM 的 `overview=full` 就是完整路线几何，直接复用。
+            geometry: points,
+            steps,
+        };
+    }
+}

package/ts/dsh-runtime/vendor/dsh-map-tools/lib/clients/photon.js

@@ -0,0 +1,55 @@
+const PUBLIC_PHOTON = 'https://photon.komoot.io';
+export class PhotonClient {
+    opts;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    async get(path, params, signal) {
+        const url = new URL(`${this.opts.baseUrl ?? PUBLIC_PHOTON}${path}`);
+        for (const [k, v] of Object.entries(params))
+            url.searchParams.set(k, v);
+        let res;
+        try {
+            res = await fetch(url, { signal, headers: { Accept: 'application/json' } });
+        }
+        catch (err) {
+            const reason = err instanceof Error ? err.message : String(err);
+            throw new Error(`无法访问 Photon 免费地理编码服务（${reason}）。部分网络环境下该服务不可达，建议在插件配置中设置高德 amapKey（https://console.amap.com/dev/key/app）以获得稳定的地理编码。`);
+        }
+        if (!res.ok)
+            throw new Error(`Photon HTTP ${res.status}: ${res.statusText}`);
+        return res.json();
+    }
+    /** Forward geocode. */
+    async geocode(query, signal) {
+        const body = (await this.get('/api/', { q: query, limit: '1', lang: this.opts.lang ?? 'zh' }, signal));
+        const first = body.features?.[0];
+        if (!first?.geometry?.coordinates) {
+            throw new Error(`免费地理编码未找到该地址：${query}。请尝试提供 "lng,lat" 坐标，或配置高德 amapKey 获得更全的地址库。`);
+        }
+        const [lng, lat] = first.geometry.coordinates;
+        const props = first.properties ?? {};
+        return {
+            provider: 'photon',
+            formatted: props.name ?? query,
+            location: [lng, lat],
+            city: props.city,
+            district: props.state,
+        };
+    }
+    /** Reverse geocode. */
+    async reverseGeocode(location, signal) {
+        const body = (await this.get('/reverse', { lon: String(location[0]), lat: String(location[1]) }, signal));
+        const first = body.features?.[0];
+        if (!first)
+            throw new Error('Photon reverse geocode returned no result');
+        const props = first.properties ?? {};
+        return {
+            provider: 'photon',
+            formatted: [props.name, props.city, props.state].filter(Boolean).join('，') || `${location[0]},${location[1]}`,
+            location,
+            city: props.city,
+            district: props.state,
+        };
+    }
+}

package/ts/dsh-runtime/vendor/dsh-map-tools/lib/config-file.js

@@ -0,0 +1,87 @@
+/**
+ * dsh-map-tools persisted config file (~/.dsh-map-tools/config.json).
+ *
+ * Follows the modlens pattern: the plugin's API keys and provider choice live
+ * in its own file (shared across profiles, never in the DSH settings
+ * document), and the settings card reads/writes it through a loopback route.
+ */
+import { mkdirSync, readFileSync, writeFileSync, lstatSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+/** The file the plugin's settings card reads and writes. Overridable for tests. */
+export function configPath() {
+    const override = process.env.DSH_MAP_TOOLS_CONFIG;
+    return override !== undefined && override !== ''
+        ? override
+        : join(homedir(), '.dsh-map-tools', 'config.json');
+}
+/**
+ * Read the shared config, or a thrown error. Only a missing file reads as
+ * empty: an existing-but-unparsable file is somebody's configuration, and a
+ * card that treated it as empty would overwrite it on the next save.
+ */
+export function readConfig() {
+    let raw;
+    try {
+        raw = readFileSync(configPath(), 'utf8');
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT')
+            return {};
+        throw new Error(`cannot read ${configPath()}: ${error?.message ?? error}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new Error(`cannot parse ${configPath()}: ${error?.message ?? error}`);
+    }
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error(`${configPath()} must hold a JSON object`);
+    }
+    return parsed;
+}
+/** Deprecated config keys, purged on every save (Baidu provider dropped in 0.3.0). */
+const DEPRECATED_KEYS = ['baiduAk'];
+/** Persist a patch onto the config file, then return the new whole. */
+export function applyConfig(patch) {
+    const current = readConfig();
+    for (const key of ['provider', 'amapKey', 'timeoutMs', 'maxQps']) {
+        if (patch[key] !== undefined) {
+            if (key === 'amapKey' && patch.amapKey === '')
+                delete current.amapKey;
+            else
+                current[key] = patch[key];
+        }
+    }
+    // Purge deprecated fields (e.g. baiduAk from the pre-0.3.0 Baidu provider)
+    // so dead keys don't linger in the config file.
+    for (const key of DEPRECATED_KEYS) {
+        if (key in current)
+            delete current[key];
+    }
+    mkdirSync(dirname(configPath()), { recursive: true });
+    writeFileSync(configPath(), `${JSON.stringify(current, null, 2)}\n`, { mode: 0o600 });
+    return current;
+}
+/** Whether the config file exists (the card can offer "open config file"). */
+export function configFileExists() {
+    try {
+        lstatSync(configPath());
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Non-secret summary served to the settings card (keys are never echoed). */
+export function configSummary() {
+    const c = readConfig();
+    return {
+        provider: c.provider,
+        timeoutMs: c.timeoutMs,
+        maxQps: c.maxQps,
+        hasAmapKey: typeof c.amapKey === 'string' && c.amapKey !== '',
+    };
+}

package/ts/dsh-runtime/vendor/dsh-map-tools/lib/config-route.js

@@ -0,0 +1,131 @@
+/**
+ * Loopback settings-card route for dsh-map-tools.
+ *
+ * GET  /dsh-map-tools/config            → non-secret summary (has-amap-key, …)
+ * GET  /dsh-map-tools/config?open=true  → open the config file in the editor
+ * POST /dsh-map-tools/config            → apply a provider/key/timeout patch
+ *
+ * Same-origin loopback only (mirrors dsh's own /api fence and the modlens
+ * pattern); the two halves of the card read/write a real file.
+ */
+import { spawn } from 'node:child_process';
+import { configSummary, applyConfig, configPath, configFileExists } from './config-file.js';
+/** localhost, ::1, or anything in 127/8 — matching dsh's own /api fence. */
+function isLoopbackHost(hostname) {
+    return hostname === 'localhost' || hostname === '::1' || hostname === '127.0.0.1' || /^127\.\d+\.\d+\.\d+$/.test(hostname);
+}
+/** Refuse cross-origin and non-loopback requests (the route answers same-origin loopback only). */
+export function isTrustedRequest(req) {
+    const host = req.headers?.host;
+    if (typeof host !== 'string' || host === '')
+        return false;
+    let hostUrl;
+    try {
+        hostUrl = new URL(`http://${host}`);
+    }
+    catch {
+        return false;
+    }
+    if (!isLoopbackHost(hostUrl.hostname))
+        return false;
+    if (req.headers?.['sec-fetch-site'] === 'cross-site')
+        return false;
+    const origin = req.headers?.origin;
+    if (origin === undefined)
+        return true;
+    try {
+        return new URL(origin).host === hostUrl.host;
+    }
+    catch {
+        return false;
+    }
+}
+/** Open the config file in the OS default editor. */
+function openConfigFile() {
+    const file = configPath();
+    const [command, args] = process.platform === 'win32'
+        ? ['cmd', ['/c', 'start', '', file]]
+        : process.platform === 'darwin'
+            ? ['open', [file]]
+            : ['xdg-open', [file]];
+    const child = spawn(command, args, { detached: true, stdio: 'ignore' });
+    child.unref();
+}
+/**
+ * Register the settings-card route under the web server, when one exists.
+ *
+ * @param ctx - plugin context.
+ * @param reload - rebuild the tools after the card saves (the file write alone
+ *   never reaches the registered tool instances; without this the new provider
+ *   or key only takes effect on the next plugin reload).
+ */
+export function installConfigRoute(ctx, reload = () => { }) {
+    const fn = ctx.inject;
+    fn(['webServer'], (scope) => {
+        // register() 的返回值是**唯一的**撤销手段（webserver 的 exact 表里同路径
+        // 重复注册会抛 "duplicate route"，它不是 effect 自动托管的）。所以必须把它
+        // 挂到 effect 上：否则卸载后旧处理器留在表里，而重载时新注册撞重复报错——
+        // 那个错误落在 inject 子作用域内被静默吞掉，路由就永远停在上一个版本
+        // （现象：热替换后工具是新的、回环路由还是旧的）。
+        scope.effect(() => scope.webServer.register({
+            kind: 'exact',
+            path: '/dsh-map-tools/config',
+            handler: async (req, res) => {
+                const send = (status, body) => {
+                    res.writeHead(status, { 'content-type': 'application/json' });
+                    res.end(JSON.stringify(body));
+                };
+                if (!isTrustedRequest(req)) {
+                    send(403, { error: 'request refused: this route answers same-origin loopback only' });
+                    return;
+                }
+                if (req.method === 'GET') {
+                    try {
+                        const summary = configSummary();
+                        const wantsOpen = new URL(req.url ?? '/', 'http://localhost').searchParams.has('open');
+                        if (wantsOpen && !configFileExists()) {
+                            applyConfig({});
+                        }
+                        if (wantsOpen)
+                            openConfigFile();
+                        send(200, { ...summary, configPath: configPath() });
+                    }
+                    catch (error) {
+                        send(409, { error: String(error?.message ?? error) });
+                    }
+                    return;
+                }
+                if (req.method !== 'POST') {
+                    res.writeHead(405).end();
+                    return;
+                }
+                try {
+                    const chunks = [];
+                    let total = 0;
+                    for await (const chunk of req) {
+                        total += chunk.length;
+                        if (total > 64 * 1024) {
+                            send(413, { error: 'config payload too large' });
+                            req.destroy();
+                            return;
+                        }
+                        chunks.push(chunk);
+                    }
+                    const patch = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+                    applyConfig({
+                        provider: patch.provider,
+                        amapKey: patch.amapKey,
+                        timeoutMs: typeof patch.timeoutMs === 'number' ? patch.timeoutMs : undefined,
+                    });
+                    send(200, configSummary());
+                    // Rebuild the tool instances so the saved provider/key/timeout is
+                    // live immediately (the card tells the user "工具已重建").
+                    reload();
+                }
+                catch (error) {
+                    send(400, { error: String(error?.message ?? error) });
+                }
+            },
+        }));
+    });
+}

package/ts/dsh-runtime/vendor/dsh-map-tools/lib/config.js

@@ -0,0 +1,16 @@
+/** Plugin configuration schema. */
+import Schema from '@deepseek-ai/schemastery';
+/** Amap apply URL (shown as a clickable link in the settings card). */
+export const AMAP_APPLY_URL = 'https://console.amap.com/dev/key/app';
+export const Config = Schema.object({
+    provider: Schema.union(['amap', 'osm'])
+        .default('amap')
+        .description('数据源：amap=高德地图（推荐，国内数据最全）；osm=免费 OSM 兜底（无需 key，能力有限）'),
+    amapKey: Schema.string()
+        .role('secret')
+        .description(`高德 Web 服务 key。申请：${AMAP_APPLY_URL}（创建应用后选择"Web 服务"类型）`),
+    timeoutMs: Schema.number().default(15000).description('单次请求超时（毫秒）'),
+    maxQps: Schema.number().default(2).description('高德 API 每秒最大请求数（QPS 上限，默认 2 低于高德常见上限 3，防触发 10021 配额错误）'),
+    defaultMode: Schema.union(['driving', 'transit', 'walking', 'bicycling']).default('driving').description('默认路线模式'),
+    language: Schema.union(['zh', 'en']).default('zh').description('返回语言'),
+});

package/ts/dsh-runtime/vendor/dsh-map-tools/lib/geo.js

@@ -0,0 +1,232 @@
+/**
+ * 路线几何的纯函数工具：解码、抽稀、取整。
+ *
+ * 这些函数是 UI 卡片的输入准备层——它们决定"会话日志里到底存了多少个点"。
+ * 全是纯函数（无 I/O、无时钟、无随机），便于单元测试。
+ */
+/** 会话日志里一条路线最多保留的几何点数（卡片是示意图，不需要原始精度）。 */
+export const MAX_GEOMETRY_POINTS = 200;
+/** 几何坐标保留的小数位：5 位约 1 米，足够画示意图，又能显著压缩体积。 */
+const COORD_DECIMALS = 5;
+/** 浮点取整到固定小数位（去掉 -0）。 */
+function round(value, decimals) {
+    const f = 10 ** decimals;
+    const r = Math.round(value * f) / f;
+    return Object.is(r, -0) ? 0 : r;
+}
+/** 一个坐标是否是可用的经纬度。 */
+function isValidLngLat(point) {
+    return (point !== undefined
+        && Number.isFinite(point[0])
+        && Number.isFinite(point[1])
+        && point[0] >= -180
+        && point[0] <= 180
+        && point[1] >= -90
+        && point[1] <= 90);
+}
+/**
+ * 解码高德的紧凑折线串 `"lng,lat;lng,lat;…"`。
+ * 非法片段被跳过（上游数据不可信，宁可少画一点也不抛错）。
+ * @param text - 高德 `polyline` 字段原文。
+ * @returns 解析出的坐标序列（可能为空）。
+ */
+export function decodeAmapPolyline(text) {
+    if (typeof text !== 'string' || text === '')
+        return [];
+    const points = [];
+    for (const chunk of text.split(';')) {
+        const parts = chunk.split(',');
+        if (parts.length !== 2)
+            continue;
+        const lng = Number(parts[0]);
+        const lat = Number(parts[1]);
+        const point = [lng, lat];
+        if (isValidLngLat(point))
+            points.push(point);
+    }
+    return points;
+}
+/** 去掉相邻重复点（按取整后的坐标比较），并丢弃非法点。 */
+export function dedupeGeometry(points) {
+    const out = [];
+    let lastKey = '';
+    for (const point of points) {
+        if (!isValidLngLat(point))
+            continue;
+        const key = `${round(point[0], COORD_DECIMALS)},${round(point[1], COORD_DECIMALS)}`;
+        if (key === lastKey)
+            continue;
+        lastKey = key;
+        out.push([round(point[0], COORD_DECIMALS), round(point[1], COORD_DECIMALS)]);
+    }
+    return out;
+}
+/** 把坐标投到"等距近似"平面（x 按纬度做 cos 收缩），用于距离比较。 */
+function flatten(point, scaleX) {
+    return [point[0] * scaleX, point[1]];
+}
+/** 点到线段的垂距（平面近似）。 */
+function perpendicularDistance(point, a, b) {
+    const dx = b[0] - a[0];
+    const dy = b[1] - a[1];
+    if (dx === 0 && dy === 0)
+        return Math.hypot(point[0] - a[0], point[1] - a[1]);
+    const t = ((point[0] - a[0]) * dx + (point[1] - a[1]) * dy) / (dx * dx + dy * dy);
+    const clamped = t < 0 ? 0 : t > 1 ? 1 : t;
+    return Math.hypot(point[0] - (a[0] + clamped * dx), point[1] - (a[1] + clamped * dy));
+}
+/**
+ * Douglas–Peucker 抽稀（迭代实现，避免长路线的递归深度）。
+ * @param flat - 等距近似平面上的点序列。
+ * @param tolerance - 垂距阈值（与 `flat` 同单位）。
+ * @returns 保留点的下标，升序，必含首尾。
+ */
+function douglasPeucker(flat, tolerance) {
+    const n = flat.length;
+    if (n <= 2)
+        return n === 2 ? [0, 1] : [0];
+    const keep = new Array(n).fill(false);
+    keep[0] = true;
+    keep[n - 1] = true;
+    const stack = [[0, n - 1]];
+    while (stack.length > 0) {
+        const range = stack.pop();
+        if (range === undefined)
+            break;
+        const [first, last] = range;
+        if (last <= first + 1)
+            continue;
+        let maxDistance = -1;
+        let maxIndex = -1;
+        for (let i = first + 1; i < last; i += 1) {
+            const distance = perpendicularDistance(flat[i], flat[first], flat[last]);
+            if (distance > maxDistance) {
+                maxDistance = distance;
+                maxIndex = i;
+            }
+        }
+        if (maxIndex >= 0 && maxDistance > tolerance) {
+            keep[maxIndex] = true;
+            stack.push([first, maxIndex], [maxIndex, last]);
+        }
+    }
+    const indices = [];
+    for (let i = 0; i < n; i += 1)
+        if (keep[i])
+            indices.push(i);
+    return indices;
+}
+/** 等间隔抽稀到不超过 `maxPoints` 个点（抽稀兜底，保留首尾）。 */
+function decimate(indices, maxPoints) {
+    if (indices.length <= maxPoints)
+        return [...indices];
+    const out = [];
+    const step = (indices.length - 1) / (maxPoints - 1);
+    for (let i = 0; i < maxPoints; i += 1) {
+        const index = indices[Math.round(i * step)];
+        if (index !== undefined && out[out.length - 1] !== index)
+            out.push(index);
+    }
+    const last = indices[indices.length - 1];
+    if (last !== undefined && out[out.length - 1] !== last)
+        out.push(last);
+    return out;
+}
+/**
+ * 抽稀一条路线几何，使其点数不超过 `maxPoints`。
+ *
+ * 阈值从包围盒对角线推导（自适应：长途粗、短途细——40 公里路线约 40 米，
+ * 200 米步行路线约 0.2 米），逐步放宽直到达标；若 Douglas–Peucker 仍不达标
+ * （例如密集的锯齿路径），再做等间隔兜底。首尾点始终保留，坐标统一取整到
+ * 5 位小数。
+ *
+ * 注意：即使点数没超上限也会跑一遍抽稀——直线上的冗余点同样要丢掉，
+ * 因为产物要写进会话日志。
+ *
+ * @param points - 原始几何点（可为空、可含重复/非法点）。
+ * @param maxPoints - 点数上限，默认 {@link MAX_GEOMETRY_POINTS}。
+ * @returns 抽稀并取整后的几何（点数 ≤ `maxPoints`）。
+ */
+export function simplifyGeometry(points, maxPoints = MAX_GEOMETRY_POINTS) {
+    const limit = Math.max(2, Math.floor(maxPoints));
+    const clean = dedupeGeometry(points);
+    if (clean.length <= 2)
+        return clean;
+    const lat0 = clean.reduce((sum, point) => sum + point[1], 0) / clean.length;
+    const scaleX = Math.max(0.01, Math.cos((lat0 * Math.PI) / 180));
+    const flat = clean.map((point) => flatten(point, scaleX));
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    for (const [x, y] of flat) {
+        if (x < minX)
+            minX = x;
+        if (x > maxX)
+            maxX = x;
+        if (y < minY)
+            minY = y;
+        if (y > maxY)
+            maxY = y;
+    }
+    const diagonal = Math.hypot(maxX - minX, maxY - minY);
+    // 初始阈值：对角线千分之一；随后逐次放宽，最多 12 轮（≈4000 倍）。
+    let tolerance = Math.max(diagonal / 1000, 1e-7);
+    let indices = douglasPeucker(flat, tolerance);
+    for (let i = 0; i < 12 && indices.length > limit; i += 1) {
+        tolerance *= 2;
+        indices = douglasPeucker(flat, tolerance);
+    }
+    if (indices.length > limit)
+        indices = decimate(indices, limit);
+    return indices.map((index) => clean[index]).filter(isValidLngLat);
+}
+/**
+ * 把几何压成高德风格的紧凑串 `"lng,lat;lng,lat"`（日志体积的一档压缩）。
+ * @param points - 已取整的几何点。
+ * @returns 紧凑串；空序列返回空串。
+ */
+export function encodeGeometry(points) {
+    return points.map((point) => `${point[0]},${point[1]}`).join(';');
+}
+/**
+ * 把高德的长地址裁成可读的短地名。
+ *
+ * 高德反查返回的 `formatted_address` 是"省市区街道 + 具体位置"连写（如
+ * "北京市丰台区右安门街道北京南站"）。把已知的省/市/区/街道前缀依次剥掉、
+ * 再去掉尾部括号补充，剩下的就是用户认得的那个名字。
+ * 剥完为空则原样返回（宁可长，也不要空）。
+ *
+ * @param formatted - 高德 `formatted_address`。
+ * @param strip - 要剥掉的前缀（省 / 市 / 区 / 街道）。
+ * @returns 短地名。
+ */
+export function shortPlaceName(formatted, strip) {
+    const original = (formatted ?? '').trim();
+    const prefixes = strip.filter((part) => typeof part === 'string' && part !== '');
+    let text = original;
+    // 反复剥直到没得剥：这样与传入顺序无关（"朝阳区" 在 "北京市" 之后也能剥掉），
+    // 且前缀重复出现时也能剥干净。每个前缀都非空，所以一定会终止。
+    for (let changed = true; changed;) {
+        changed = false;
+        for (const part of prefixes) {
+            if (text.startsWith(part)) {
+                text = text.slice(part.length);
+                changed = true;
+            }
+        }
+    }
+    // 去掉尾部的括号补充（"…国际机场(2号通道)" → "…国际机场"）。
+    text = text.replace(/[(（][^)）]*[)）]\s*$/, '').trim();
+    return text === '' ? original : text;
+}
+/**
+ * 抽稀到最多 `maxPoints` 个点，再编成紧凑串（用于塞进 URL query）。
+ * 静态地图不需要 200 个点，太长会把 URL 撑爆。
+ * @param points - 路线几何。
+ * @param maxPoints - 点数上限。
+ * @returns `"lng,lat;…"`。
+ */
+export function compactLine(points, maxPoints = 128) {
+    return encodeGeometry(simplifyGeometry(points, maxPoints));
+}