@sayue_ltr/fleq 1.50.1 → 2.0.0

package/dist/engine/template/field-accessor.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFieldValue = getFieldValue;
+/**
+ * PresentationEvent からドットパスで値を取得する。
+ *
+ * 表示専用ポリシー (dmdata.jp 再配信ポリシー対応) のため、配列インデックス参照
+ * (`[N]`) は parser 側で禁止済み。本関数では二重防御として、念のため `raw`
+ * フィールドへのアクセスも拒否する。
+ *
+ * segments 例:
+ * - ["title"]          → event.title
+ * - ["earthquake", "magnitude"] → event.earthquake.magnitude
+ */
+function getFieldValue(event, segments) {
+    // 二重防御: parser を経由せず直接呼ばれた場合にも raw への参照を拒否
+    if (segments[0] === "raw")
+        return undefined;
+    let current = event;
+    for (const seg of segments) {
+        if (current == null)
+            return undefined;
+        if (typeof current === "object") {
+            current = current[seg];
+        }
+        else {
+            return undefined;
+        }
+    }
+    return current;
+}

package/dist/engine/template/filters.js

@@ -0,0 +1,100 @@
+"use strict";
+// ── Template filter functions ──
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyFilter = applyFilter;
+/**
+ * フィルタ内部で値を文字列化する共通関数。
+ *
+ * 表示専用ポリシー対応: 配列は改行区切りで文字列化する。
+ * `String([...])` が ","  連結するため、`|upper` や `|replace` といった
+ * 文字列系フィルタ経由で配列を 1 行機械可読出力に整形できてしまうのを防ぐ。
+ */
+function toString(value) {
+    if (value == null)
+        return "";
+    if (Array.isArray(value))
+        return value.join("\n");
+    return String(value);
+}
+function filterDefault(value, args) {
+    if (value == null || value === "") {
+        return args[0] ?? "";
+    }
+    return value;
+}
+function filterTruncate(value, args) {
+    const str = toString(value);
+    const limit = typeof args[0] === "number" ? args[0] : Number(args[0]);
+    if (!Number.isFinite(limit) || str.length <= limit)
+        return str;
+    return str.slice(0, limit);
+}
+function filterPad(value, args) {
+    const str = toString(value);
+    const width = typeof args[0] === "number" ? args[0] : Number(args[0]);
+    if (!Number.isFinite(width))
+        return str;
+    return str.padEnd(width);
+}
+function filterDate(value, args) {
+    const format = args[0] != null ? String(args[0]) : "HH:mm";
+    const date = value instanceof Date ? value : new Date(String(value));
+    if (isNaN(date.getTime()))
+        return toString(value);
+    const HH = String(date.getHours()).padStart(2, "0");
+    const mm = String(date.getMinutes()).padStart(2, "0");
+    const ss = String(date.getSeconds()).padStart(2, "0");
+    const MM = String(date.getMonth() + 1).padStart(2, "0");
+    const DD = String(date.getDate()).padStart(2, "0");
+    switch (format) {
+        case "HH:mm":
+            return `${HH}:${mm}`;
+        case "HH:mm:ss":
+            return `${HH}:${mm}:${ss}`;
+        case "MM/DD HH:mm":
+            return `${MM}/${DD} ${HH}:${mm}`;
+        default:
+            return `${HH}:${mm}`;
+    }
+}
+function filterReplace(value, args) {
+    const str = toString(value);
+    const search = args[0] != null ? String(args[0]) : "";
+    const replacement = args[1] != null ? String(args[1]) : "";
+    // 表示専用ポリシー対応: search/replacement に改行文字を含めると、
+    // 配列の改行 join を 1 行化する経路（\n → "," 等の置換）を作れてしまうため禁止。
+    if (/[\r\n]/.test(search) || /[\r\n]/.test(replacement)) {
+        throw new Error("テンプレート実行エラー: replace フィルタの引数に改行文字 (\\n / \\r) を含めることはできません。表示専用制限です。");
+    }
+    return str.split(search).join(replacement);
+}
+function filterUpper(value) {
+    return toString(value).toUpperCase();
+}
+function filterLower(value) {
+    return toString(value).toLowerCase();
+}
+/**
+ * テンプレートフィルタを適用する。
+ * 未知のフィルタ名の場合は値をそのまま返す。
+ */
+function applyFilter(name, value, args) {
+    switch (name) {
+        case "default":
+            return filterDefault(value, args);
+        case "truncate":
+            return filterTruncate(value, args);
+        case "pad":
+            return filterPad(value, args);
+        case "date":
+            return filterDate(value, args);
+        case "replace":
+            return filterReplace(value, args);
+        case "upper":
+            return filterUpper(value);
+        case "lower":
+            return filterLower(value);
+        default:
+            return value;
+    }
+}

package/dist/engine/template/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileTemplate = void 0;
+var compile_template_1 = require("./compile-template");
+Object.defineProperty(exports, "compileTemplate", { enumerable: true, get: function () { return compile_template_1.compileTemplate; } });

package/dist/engine/template/parser.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTemplate = parseTemplate;
+const tokenizer_1 = require("./tokenizer");
+const MAX_DEPTH = 32;
+function parseTemplate(source) {
+    const tokens = (0, tokenizer_1.tokenizeTemplate)(source);
+    return new TemplateParser(tokens).parse();
+}
+class TemplateParser {
+    tokens;
+    pos = 0;
+    depth = 0;
+    constructor(tokens) {
+        this.tokens = tokens;
+    }
+    parse() {
+        return this.parseNodes();
+    }
+    parseNodes() {
+        const nodes = [];
+        while (this.pos < this.tokens.length) {
+            const token = this.tokens[this.pos];
+            if (token.kind === "eof" || token.kind === "else" || token.kind === "endif")
+                break;
+            if (token.kind === "text" && this.peek(-1)?.kind !== "open" && this.peek(-1)?.kind !== "if_open") {
+                // 外側テキスト
+                nodes.push({ kind: "text", value: token.value });
+                this.pos++;
+                continue;
+            }
+            if (token.kind === "if_open") {
+                nodes.push(this.parseIfBlock());
+                continue;
+            }
+            if (token.kind === "open") {
+                nodes.push(this.parseInterpolation());
+                continue;
+            }
+            // 未消費トークンはテキストとして扱う
+            nodes.push({ kind: "text", value: token.value });
+            this.pos++;
+        }
+        return nodes;
+    }
+    parseInterpolation() {
+        this.expect("open"); // {{
+        const exprToken = this.tokens[this.pos];
+        this.pos++;
+        const expr = this.parseExpr(exprToken.value);
+        const filters = [];
+        while (this.pos < this.tokens.length && this.tokens[this.pos].kind === "pipe") {
+            this.pos++; // |
+            const nameToken = this.tokens[this.pos];
+            this.pos++;
+            const args = [];
+            // 複数引数対応: colon が続く限り引数を読む
+            while (this.pos < this.tokens.length && this.tokens[this.pos].kind === "colon") {
+                this.pos++; // :
+                const argToken = this.tokens[this.pos];
+                this.pos++;
+                args.push(this.parseExpr(argToken.value));
+            }
+            filters.push({ name: nameToken.value, args });
+        }
+        this.expect("close"); // }}
+        return { kind: "interpolation", expr, filters };
+    }
+    parseIfBlock() {
+        this.expect("if_open"); // {{#if
+        const condToken = this.tokens[this.pos];
+        this.pos++;
+        const test = this.parsePredicate(condToken.value);
+        this.expect("close"); // }}
+        this.depth++;
+        if (this.depth > MAX_DEPTH) {
+            throw new Error(`テンプレート構文エラー: #if のネストが深すぎる (最大 ${MAX_DEPTH} 段)`);
+        }
+        const body = this.parseNodes();
+        let elseBody;
+        if (this.pos < this.tokens.length && this.tokens[this.pos].kind === "else") {
+            this.pos++; // {{else}}
+            elseBody = this.parseNodes();
+        }
+        if (this.pos < this.tokens.length && this.tokens[this.pos].kind === "endif") {
+            this.pos++; // {{/if}}
+        }
+        else {
+            this.depth--;
+            throw new Error('テンプレート構文エラー: "endif" が必要ですが見つかりません。{{/if}} で閉じてください');
+        }
+        this.depth--;
+        return { kind: "if", test, body, elseBody };
+    }
+    parseExpr(raw) {
+        const trimmed = raw.trim();
+        // 文字列リテラル
+        if ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+            (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+            return { kind: "literal", value: unescapeString(trimmed.slice(1, -1)) };
+        }
+        // 数値
+        if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
+            return { kind: "literal", value: Number(trimmed) };
+        }
+        // boolean / null
+        if (trimmed === "true")
+            return { kind: "literal", value: true };
+        if (trimmed === "false")
+            return { kind: "literal", value: false };
+        if (trimmed === "null")
+            return { kind: "literal", value: null };
+        // パス: dot + bracket 記法を (string | number)[] に分割
+        return { kind: "path", segments: parsePathSegments(trimmed) };
+    }
+    parsePredicate(raw) {
+        const trimmed = raw.trim();
+        // 簡易比較: "field op value" 形式
+        const cmpMatch = trimmed.match(/^(\S+)\s+(=|!=|>|>=|<|<=)\s+(.+)$/);
+        if (cmpMatch) {
+            const opMap = {
+                "=": "eq", "!=": "ne", ">": "gt", ">=": "ge", "<": "lt", "<=": "le",
+            };
+            return {
+                kind: "compare",
+                op: opMap[cmpMatch[2]],
+                left: this.parseExpr(cmpMatch[1]),
+                right: this.parseExpr(cmpMatch[3]),
+            };
+        }
+        // truthy
+        return { kind: "truthy", expr: this.parseExpr(trimmed) };
+    }
+    expect(kind) {
+        if (this.pos < this.tokens.length && this.tokens[this.pos].kind === kind) {
+            this.pos++;
+            return;
+        }
+        const actual = this.pos < this.tokens.length ? this.tokens[this.pos].kind : "eof";
+        throw new Error(`テンプレート構文エラー: "${kind}" が必要ですが "${actual}" が見つかりました`);
+    }
+    peek(offset) {
+        return this.tokens[this.pos + offset];
+    }
+}
+/**
+ * ドットパスを segments 配列に分割する。
+ * 例: "foo.bar.baz" → ["foo", "bar", "baz"]
+ *
+ * 表示専用ポリシー (dmdata.jp 再配信ポリシー対応) のため、以下を禁止する:
+ * - ブラケット記法 `[N]` (配列インデックス参照)
+ * - 先頭セグメントが `raw` のパス (生 XML データへの直接参照)
+ */
+function parsePathSegments(path) {
+    const segments = [];
+    let i = 0;
+    while (i < path.length) {
+        if (path[i] === ".") {
+            i++; // ドット区切りをスキップ
+            continue;
+        }
+        if (path[i] === "[") {
+            throw new Error(`テンプレート構文エラー: 配列インデックス参照 [N] は無効です (path: "${path}")。表示専用制限により、要素を1行に並べる機械可読出力を防いでいます。`);
+        }
+        // 識別子: 次の . または [ まで
+        const start = i;
+        while (i < path.length && path[i] !== "." && path[i] !== "[")
+            i++;
+        segments.push(path.slice(start, i));
+    }
+    if (segments[0] === "raw") {
+        throw new Error(`テンプレート構文エラー: raw フィールド参照は無効です (path: "${path}")。表示専用制限により、生 XML データへの直接アクセスを禁止しています。`);
+    }
+    return segments;
+}
+/** 文字列リテラル内のエスケープシーケンスを復元する */
+function unescapeString(s) {
+    return s.replace(/\\(["'\\nt])/g, (_, ch) => {
+        switch (ch) {
+            case "n": return "\n";
+            case "t": return "\t";
+            default: return ch; // \\, \", \'
+        }
+    });
+}

package/dist/engine/template/tokenizer.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tokenizeTemplate = tokenizeTemplate;
+function tokenizeTemplate(source) {
+    const tokens = [];
+    let i = 0;
+    while (i < source.length) {
+        // {{#if ...}}
+        if (source.startsWith("{{#if", i)) {
+            tokens.push({ kind: "if_open", value: "{{#if", pos: i });
+            i += 5;
+            // 空白スキップ
+            while (i < source.length && source[i] === " ")
+                i++;
+            // 条件式を "}}" まで読む
+            const start = i;
+            while (i < source.length && !source.startsWith("}}", i))
+                i++;
+            tokens.push({ kind: "text", value: source.slice(start, i), pos: start });
+            if (source.startsWith("}}", i)) {
+                tokens.push({ kind: "close", value: "}}", pos: i });
+                i += 2;
+            }
+            continue;
+        }
+        // {{else}}
+        if (source.startsWith("{{else}}", i)) {
+            tokens.push({ kind: "else", value: "{{else}}", pos: i });
+            i += 8;
+            continue;
+        }
+        // {{/if}}
+        if (source.startsWith("{{/if}}", i)) {
+            tokens.push({ kind: "endif", value: "{{/if}}", pos: i });
+            i += 7;
+            continue;
+        }
+        // {{ interpolation }}
+        if (source.startsWith("{{", i)) {
+            tokens.push({ kind: "open", value: "{{", pos: i });
+            i += 2;
+            // interpolation 内容を解析
+            while (i < source.length && !source.startsWith("}}", i)) {
+                if (source[i] === "|") {
+                    tokens.push({ kind: "pipe", value: "|", pos: i });
+                    i++;
+                }
+                else if (source[i] === ":") {
+                    tokens.push({ kind: "colon", value: ":", pos: i });
+                    i++;
+                }
+                else if (source[i] === " ") {
+                    i++;
+                }
+                else if (source[i] === '"' || source[i] === "'") {
+                    // 文字列リテラル
+                    const quote = source[i];
+                    const start = i;
+                    i++;
+                    while (i < source.length && source[i] !== quote) {
+                        if (source[i] === "\\" && i + 1 < source.length)
+                            i++;
+                        i++;
+                    }
+                    if (i < source.length)
+                        i++; // 閉じ引用符
+                    tokens.push({ kind: "text", value: source.slice(start, i), pos: start });
+                }
+                else {
+                    // 識別子/数値
+                    const start = i;
+                    while (i < source.length &&
+                        !source.startsWith("}}", i) &&
+                        source[i] !== "|" &&
+                        source[i] !== ":" &&
+                        source[i] !== " ") {
+                        i++;
+                    }
+                    tokens.push({ kind: "text", value: source.slice(start, i), pos: start });
+                }
+            }
+            if (source.startsWith("}}", i)) {
+                tokens.push({ kind: "close", value: "}}", pos: i });
+                i += 2;
+            }
+            continue;
+        }
+        // テキスト
+        const start = i;
+        while (i < source.length && !source.startsWith("{{", i))
+            i++;
+        tokens.push({ kind: "text", value: source.slice(start, i), pos: start });
+    }
+    tokens.push({ kind: "eof", value: "", pos: source.length });
+    return tokens;
+}

package/dist/engine/template/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types.js

@@ -23,7 +23,7 @@ exports.DEFAULT_CONFIG = {
         volcano: true,
     },
     sound: true,
-    eewLog: true,
+    eewLog: false,
     eewLogFields: {
         hypocenter: true,
         originTime: true,
@@ -39,6 +39,8 @@ exports.DEFAULT_CONFIG = {
         maxIntChangeReason: true,
     },
     maxObservations: null,
+    nightMode: false,
+    summaryInterval: null,
     backup: false,
     truncation: {
         seismicTextLines: 15,
@@ -50,7 +52,6 @@ exports.DEFAULT_CONFIG = {
         volcanoAshfallDetailLines: 16,
         volcanoAshfallRegularLines: 10,
         volcanoPreventionLines: 8,
-        volcanoMunicipalities: 6,
         ashfallAreasQuick: 5,
         ashfallAreasOther: 3,
         ashfallPeriodsQuick: 1,

package/dist/ui/display-adapter.js

@@ -0,0 +1,60 @@
+"use strict";
+/**
+ * engine 層の DisplayCallbacks を実装する UI アダプター。
+ * 全ての display 関数をここに集約し、engine → ui の逆方向依存を断つ。
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDisplayAdapter = createDisplayAdapter;
+const formatter_1 = require("./formatter");
+const summary_1 = require("./summary");
+const eew_formatter_1 = require("./eew-formatter");
+const earthquake_formatter_1 = require("./earthquake-formatter");
+const volcano_formatter_1 = require("./volcano-formatter");
+/** DisplayCallbacks の実装を生成する */
+function createDisplayAdapter() {
+    return {
+        displayOutcome(outcome) {
+            switch (outcome.domain) {
+                case "eew":
+                    (0, eew_formatter_1.displayEewInfo)(outcome.parsed, {
+                        activeCount: outcome.eewResult.activeCount,
+                        diff: outcome.eewResult.diff,
+                        colorIndex: outcome.eewResult.colorIndex,
+                    });
+                    break;
+                case "earthquake":
+                    (0, earthquake_formatter_1.displayEarthquakeInfo)(outcome.parsed);
+                    break;
+                case "seismicText":
+                    (0, earthquake_formatter_1.displaySeismicTextInfo)(outcome.parsed);
+                    break;
+                case "lgObservation":
+                    (0, earthquake_formatter_1.displayLgObservationInfo)(outcome.parsed);
+                    break;
+                case "tsunami":
+                    (0, earthquake_formatter_1.displayTsunamiInfo)(outcome.parsed);
+                    break;
+                case "nankaiTrough":
+                    (0, earthquake_formatter_1.displayNankaiTroughInfo)(outcome.parsed);
+                    break;
+                case "raw":
+                    (0, formatter_1.displayRawHeader)(outcome.msg);
+                    break;
+                // volcano: VolcanoRouteHandler 経由で displayVolcano/displayVolcanoBatch を直接呼ぶ
+            }
+        },
+        displayRawHeader(msg) {
+            (0, formatter_1.displayRawHeader)(msg);
+        },
+        displayVolcano(info, presentation) {
+            (0, volcano_formatter_1.displayVolcanoInfo)(info, presentation);
+        },
+        displayVolcanoBatch(batch, presentation) {
+            (0, volcano_formatter_1.displayVolcanoAshfallBatch)(batch, presentation);
+        },
+        getDisplayMode() {
+            return (0, formatter_1.getDisplayMode)();
+        },
+        renderSummaryLine: summary_1.renderSummaryLine,
+    };
+}

package/dist/ui/earthquake-formatter.js

@@ -381,6 +381,11 @@ function displayEarthquakeInfo(info) {
             buf.push(wl);
         }
     }
+    // EventID (同一地震の紐付け用、通常モードのみ表示)
+    if (info.eventId) {
+        buf.push((0, formatter_1.frameDivider)(level, width));
+        buf.push((0, formatter_1.frameLine)(level, chalk_1.default.gray(`EventID: ${info.eventId}`), width));
+    }
     // フッター
     (0, formatter_1.renderFooter)(level, info.type, info.reportDateTime, info.publishingOffice, width, buf);
     buf.push((0, formatter_1.frameBottom)(level, width));
@@ -825,7 +830,7 @@ function displayLgObservationInfo(info) {
             buf.push((0, formatter_1.frameLine)(level, chalk_1.default.white("位置: ") + chalk_1.default.white(`${eq.latitude} ${eq.longitude}`), width));
         }
     }
-    // 地域リスト (LgInt 降順)
+    // 地域リスト (LgInt 降順 → 階級別グループ化)
     if (info.areas.length > 0) {
         buf.push((0, formatter_1.frameDivider)(level, width));
         const sorted = [...info.areas].sort((a, b) => (0, formatter_1.lgIntToNumeric)(b.maxLgInt) - (0, formatter_1.lgIntToNumeric)(a.maxLgInt));
@@ -833,13 +838,25 @@ function displayLgObservationInfo(info) {
         const maxObs = (0, formatter_1.getMaxObservations)();
         const displayAreas = maxObs != null ? sorted.slice(0, maxObs) : sorted;
         const hiddenCount = sorted.length - displayAreas.length;
+        // 長周期階級別にグループ化
+        const byLgInt = new Map();
         for (const area of displayAreas) {
-            const lc = (0, formatter_1.lgIntensityColor)(area.maxLgInt);
+            const key = area.maxLgInt;
+            if (!byLgInt.has(key))
+                byLgInt.set(key, []);
             const ic = (0, formatter_1.intensityColor)(area.maxInt);
-            buf.push((0, formatter_1.frameLine)(level, lc(`長周期${area.maxLgInt}: `) +
-                chalk_1.default.white(area.name) +
-                ic(` (震度${area.maxInt})`), width));
+            byLgInt.get(key).push({
+                primary: chalk_1.default.white(area.name),
+                badges: [ic(` (震度${area.maxInt})`)],
+            });
         }
+        // LgInt 降順でソート
+        const sortedEntries = [...byLgInt.entries()].sort((a, b) => (0, formatter_1.lgIntToNumeric)(b[0]) - (0, formatter_1.lgIntToNumeric)(a[0]));
+        const groups = sortedEntries.map(([lgInt, items]) => ({
+            prefix: (0, formatter_1.lgIntensityColor)(lgInt)(`長周期${lgInt}: `),
+            items,
+        }));
+        (0, formatter_1.renderGroupedItemList)({ level, width, groups, buf });
         if (hiddenCount > 0) {
             buf.push((0, formatter_1.frameLine)(level, chalk_1.default.gray(`... 他 ${hiddenCount} 地点`), width));
         }

package/dist/ui/eew-formatter.js

@@ -282,23 +282,38 @@ function displayEewInfo(info, context) {
         const allAreas = info.forecastIntensity.areas;
         const displayAreas = maxObs != null ? allAreas.slice(0, maxObs) : allAreas;
         const hiddenCount = allAreas.length - displayAreas.length;
+        // 震度別にグループ化
+        const byIntensity = new Map();
         for (const area of displayAreas) {
-            const color = (0, formatter_1.intensityColor)(area.intensity);
-            let areaText = chalk_1.default.white(area.name);
+            const key = area.intensity;
+            if (!byIntensity.has(key))
+                byIntensity.set(key, []);
+            const badges = [];
             if (area.isPlum) {
-                areaText += theme.getRoleChalk("plumLabel")(" [PLUM]");
-            }
-            if (area.hasArrived) {
-                areaText += theme.getRoleChalk("arrivedLabel")(" [到達]");
+                badges.push(theme.getRoleChalk("plumLabel")(" [PLUM]"));
             }
+            // [到達] は下部の専用セクションに集約するため、ここでは付与しない
             if (area.lgIntensity && (0, formatter_1.lgIntToNumeric)(area.lgIntensity) >= 1) {
                 const lc = (0, formatter_1.lgIntensityColor)(area.lgIntensity);
-                areaText += lc(` [長周期${area.lgIntensity}]`);
-            }
-            for (const wl of (0, formatter_1.wrapFrameLines)(level, color(`震度${area.intensity}: `) + areaText, width)) {
-                buf.push(wl);
+                badges.push(lc(` [長周期${area.lgIntensity}]`));
             }
+            byIntensity.get(key).push({
+                primary: chalk_1.default.white(area.name),
+                badges: badges.length > 0 ? badges : undefined,
+            });
         }
+        // 震度降順でソート
+        const order = ["7", "6+", "6強", "6-", "6弱", "5+", "5強", "5-", "5弱", "4", "3", "2", "1"];
+        const sortedEntries = [...byIntensity.entries()].sort((a, b) => {
+            const ai = order.indexOf(a[0]);
+            const bi = order.indexOf(b[0]);
+            return (ai === -1 ? 99 : ai) - (bi === -1 ? 99 : bi);
+        });
+        const groups = sortedEntries.map(([int, items]) => ({
+            prefix: (0, formatter_1.intensityColor)(int)(`震度${int}: `),
+            items,
+        }));
+        (0, formatter_1.renderGroupedItemList)({ level, width, groups, buf });
         if (hiddenCount > 0) {
             buf.push((0, formatter_1.frameLine)(level, chalk_1.default.gray(`... 他 ${hiddenCount} 地点`), width));
         }