uomtiles 0.1.0

package/.output/server/node_modules/zod/v4/locales/yo.js

@@ -0,0 +1,107 @@
+import * as util from "../core/util.js";
+const error = () => {
+    const Sizable = {
+        string: { unit: "àmi", verb: "ní" },
+        file: { unit: "bytes", verb: "ní" },
+        array: { unit: "nkan", verb: "ní" },
+        set: { unit: "nkan", verb: "ní" },
+    };
+    function getSizing(origin) {
+        return Sizable[origin] ?? null;
+    }
+    const FormatDictionary = {
+        regex: "ẹ̀rọ ìbáwọlé",
+        email: "àdírẹ́sì ìmẹ́lì",
+        url: "URL",
+        emoji: "emoji",
+        uuid: "UUID",
+        uuidv4: "UUIDv4",
+        uuidv6: "UUIDv6",
+        nanoid: "nanoid",
+        guid: "GUID",
+        cuid: "cuid",
+        cuid2: "cuid2",
+        ulid: "ULID",
+        xid: "XID",
+        ksuid: "KSUID",
+        datetime: "àkókò ISO",
+        date: "ọjọ́ ISO",
+        time: "àkókò ISO",
+        duration: "àkókò tó pé ISO",
+        ipv4: "àdírẹ́sì IPv4",
+        ipv6: "àdírẹ́sì IPv6",
+        cidrv4: "àgbègbè IPv4",
+        cidrv6: "àgbègbè IPv6",
+        base64: "ọ̀rọ̀ tí a kọ́ ní base64",
+        base64url: "ọ̀rọ̀ base64url",
+        json_string: "ọ̀rọ̀ JSON",
+        e164: "nọ́mbà E.164",
+        jwt: "JWT",
+        template_literal: "ẹ̀rọ ìbáwọlé",
+    };
+    const TypeDictionary = {
+        nan: "NaN",
+        number: "nọ́mbà",
+        array: "akopọ",
+    };
+    return (issue) => {
+        switch (issue.code) {
+            case "invalid_type": {
+                const expected = TypeDictionary[issue.expected] ?? issue.expected;
+                const receivedType = util.parsedType(issue.input);
+                const received = TypeDictionary[receivedType] ?? receivedType;
+                if (/^[A-Z]/.test(issue.expected)) {
+                    return `Ìbáwọlé aṣìṣe: a ní láti fi instanceof ${issue.expected}, àmọ̀ a rí ${received}`;
+                }
+                return `Ìbáwọlé aṣìṣe: a ní láti fi ${expected}, àmọ̀ a rí ${received}`;
+            }
+            case "invalid_value":
+                if (issue.values.length === 1)
+                    return `Ìbáwọlé aṣìṣe: a ní láti fi ${util.stringifyPrimitive(issue.values[0])}`;
+                return `Àṣàyàn aṣìṣe: yan ọ̀kan lára ${util.joinValues(issue.values, "|")}`;
+            case "too_big": {
+                const adj = issue.inclusive ? "<=" : "<";
+                const sizing = getSizing(issue.origin);
+                if (sizing)
+                    return `Tó pọ̀ jù: a ní láti jẹ́ pé ${issue.origin ?? "iye"} ${sizing.verb} ${adj}${issue.maximum} ${sizing.unit}`;
+                return `Tó pọ̀ jù: a ní láti jẹ́ ${adj}${issue.maximum}`;
+            }
+            case "too_small": {
+                const adj = issue.inclusive ? ">=" : ">";
+                const sizing = getSizing(issue.origin);
+                if (sizing)
+                    return `Kéré ju: a ní láti jẹ́ pé ${issue.origin} ${sizing.verb} ${adj}${issue.minimum} ${sizing.unit}`;
+                return `Kéré ju: a ní láti jẹ́ ${adj}${issue.minimum}`;
+            }
+            case "invalid_format": {
+                const _issue = issue;
+                if (_issue.format === "starts_with")
+                    return `Ọ̀rọ̀ aṣìṣe: gbọ́dọ̀ bẹ̀rẹ̀ pẹ̀lú "${_issue.prefix}"`;
+                if (_issue.format === "ends_with")
+                    return `Ọ̀rọ̀ aṣìṣe: gbọ́dọ̀ parí pẹ̀lú "${_issue.suffix}"`;
+                if (_issue.format === "includes")
+                    return `Ọ̀rọ̀ aṣìṣe: gbọ́dọ̀ ní "${_issue.includes}"`;
+                if (_issue.format === "regex")
+                    return `Ọ̀rọ̀ aṣìṣe: gbọ́dọ̀ bá àpẹẹrẹ mu ${_issue.pattern}`;
+                return `Aṣìṣe: ${FormatDictionary[_issue.format] ?? issue.format}`;
+            }
+            case "not_multiple_of":
+                return `Nọ́mbà aṣìṣe: gbọ́dọ̀ jẹ́ èyà pípín ti ${issue.divisor}`;
+            case "unrecognized_keys":
+                return `Bọtìnì àìmọ̀: ${util.joinValues(issue.keys, ", ")}`;
+            case "invalid_key":
+                return `Bọtìnì aṣìṣe nínú ${issue.origin}`;
+            case "invalid_union":
+                return "Ìbáwọlé aṣìṣe";
+            case "invalid_element":
+                return `Iye aṣìṣe nínú ${issue.origin}`;
+            default:
+                return "Ìbáwọlé aṣìṣe";
+        }
+    };
+};
+export default function () {
+    return {
+        localeError: error(),
+    };
+}

package/.output/server/node_modules/zod/v4/locales/zh-CN.js

@@ -0,0 +1,109 @@
+import * as util from "../core/util.js";
+const error = () => {
+    const Sizable = {
+        string: { unit: "字符", verb: "包含" },
+        file: { unit: "字节", verb: "包含" },
+        array: { unit: "项", verb: "包含" },
+        set: { unit: "项", verb: "包含" },
+    };
+    function getSizing(origin) {
+        return Sizable[origin] ?? null;
+    }
+    const FormatDictionary = {
+        regex: "输入",
+        email: "电子邮件",
+        url: "URL",
+        emoji: "表情符号",
+        uuid: "UUID",
+        uuidv4: "UUIDv4",
+        uuidv6: "UUIDv6",
+        nanoid: "nanoid",
+        guid: "GUID",
+        cuid: "cuid",
+        cuid2: "cuid2",
+        ulid: "ULID",
+        xid: "XID",
+        ksuid: "KSUID",
+        datetime: "ISO日期时间",
+        date: "ISO日期",
+        time: "ISO时间",
+        duration: "ISO时长",
+        ipv4: "IPv4地址",
+        ipv6: "IPv6地址",
+        cidrv4: "IPv4网段",
+        cidrv6: "IPv6网段",
+        base64: "base64编码字符串",
+        base64url: "base64url编码字符串",
+        json_string: "JSON字符串",
+        e164: "E.164号码",
+        jwt: "JWT",
+        template_literal: "输入",
+    };
+    const TypeDictionary = {
+        nan: "NaN",
+        number: "数字",
+        array: "数组",
+        null: "空值(null)",
+    };
+    return (issue) => {
+        switch (issue.code) {
+            case "invalid_type": {
+                const expected = TypeDictionary[issue.expected] ?? issue.expected;
+                const receivedType = util.parsedType(issue.input);
+                const received = TypeDictionary[receivedType] ?? receivedType;
+                if (/^[A-Z]/.test(issue.expected)) {
+                    return `无效输入：期望 instanceof ${issue.expected}，实际接收 ${received}`;
+                }
+                return `无效输入：期望 ${expected}，实际接收 ${received}`;
+            }
+            case "invalid_value":
+                if (issue.values.length === 1)
+                    return `无效输入：期望 ${util.stringifyPrimitive(issue.values[0])}`;
+                return `无效选项：期望以下之一 ${util.joinValues(issue.values, "|")}`;
+            case "too_big": {
+                const adj = issue.inclusive ? "<=" : "<";
+                const sizing = getSizing(issue.origin);
+                if (sizing)
+                    return `数值过大：期望 ${issue.origin ?? "值"} ${adj}${issue.maximum.toString()} ${sizing.unit ?? "个元素"}`;
+                return `数值过大：期望 ${issue.origin ?? "值"} ${adj}${issue.maximum.toString()}`;
+            }
+            case "too_small": {
+                const adj = issue.inclusive ? ">=" : ">";
+                const sizing = getSizing(issue.origin);
+                if (sizing) {
+                    return `数值过小：期望 ${issue.origin} ${adj}${issue.minimum.toString()} ${sizing.unit}`;
+                }
+                return `数值过小：期望 ${issue.origin} ${adj}${issue.minimum.toString()}`;
+            }
+            case "invalid_format": {
+                const _issue = issue;
+                if (_issue.format === "starts_with")
+                    return `无效字符串：必须以 "${_issue.prefix}" 开头`;
+                if (_issue.format === "ends_with")
+                    return `无效字符串：必须以 "${_issue.suffix}" 结尾`;
+                if (_issue.format === "includes")
+                    return `无效字符串：必须包含 "${_issue.includes}"`;
+                if (_issue.format === "regex")
+                    return `无效字符串：必须满足正则表达式 ${_issue.pattern}`;
+                return `无效${FormatDictionary[_issue.format] ?? issue.format}`;
+            }
+            case "not_multiple_of":
+                return `无效数字：必须是 ${issue.divisor} 的倍数`;
+            case "unrecognized_keys":
+                return `出现未知的键(key): ${util.joinValues(issue.keys, ", ")}`;
+            case "invalid_key":
+                return `${issue.origin} 中的键(key)无效`;
+            case "invalid_union":
+                return "无效输入";
+            case "invalid_element":
+                return `${issue.origin} 中包含无效值(value)`;
+            default:
+                return `无效输入`;
+        }
+    };
+};
+export default function () {
+    return {
+        localeError: error(),
+    };
+}

package/.output/server/node_modules/zod/v4/locales/zh-TW.js

@@ -0,0 +1,107 @@
+import * as util from "../core/util.js";
+const error = () => {
+    const Sizable = {
+        string: { unit: "字元", verb: "擁有" },
+        file: { unit: "位元組", verb: "擁有" },
+        array: { unit: "項目", verb: "擁有" },
+        set: { unit: "項目", verb: "擁有" },
+    };
+    function getSizing(origin) {
+        return Sizable[origin] ?? null;
+    }
+    const FormatDictionary = {
+        regex: "輸入",
+        email: "郵件地址",
+        url: "URL",
+        emoji: "emoji",
+        uuid: "UUID",
+        uuidv4: "UUIDv4",
+        uuidv6: "UUIDv6",
+        nanoid: "nanoid",
+        guid: "GUID",
+        cuid: "cuid",
+        cuid2: "cuid2",
+        ulid: "ULID",
+        xid: "XID",
+        ksuid: "KSUID",
+        datetime: "ISO 日期時間",
+        date: "ISO 日期",
+        time: "ISO 時間",
+        duration: "ISO 期間",
+        ipv4: "IPv4 位址",
+        ipv6: "IPv6 位址",
+        cidrv4: "IPv4 範圍",
+        cidrv6: "IPv6 範圍",
+        base64: "base64 編碼字串",
+        base64url: "base64url 編碼字串",
+        json_string: "JSON 字串",
+        e164: "E.164 數值",
+        jwt: "JWT",
+        template_literal: "輸入",
+    };
+    const TypeDictionary = {
+        nan: "NaN",
+    };
+    return (issue) => {
+        switch (issue.code) {
+            case "invalid_type": {
+                const expected = TypeDictionary[issue.expected] ?? issue.expected;
+                const receivedType = util.parsedType(issue.input);
+                const received = TypeDictionary[receivedType] ?? receivedType;
+                if (/^[A-Z]/.test(issue.expected)) {
+                    return `無效的輸入值：預期為 instanceof ${issue.expected}，但收到 ${received}`;
+                }
+                return `無效的輸入值：預期為 ${expected}，但收到 ${received}`;
+            }
+            case "invalid_value":
+                if (issue.values.length === 1)
+                    return `無效的輸入值：預期為 ${util.stringifyPrimitive(issue.values[0])}`;
+                return `無效的選項：預期為以下其中之一 ${util.joinValues(issue.values, "|")}`;
+            case "too_big": {
+                const adj = issue.inclusive ? "<=" : "<";
+                const sizing = getSizing(issue.origin);
+                if (sizing)
+                    return `數值過大：預期 ${issue.origin ?? "值"} 應為 ${adj}${issue.maximum.toString()} ${sizing.unit ?? "個元素"}`;
+                return `數值過大：預期 ${issue.origin ?? "值"} 應為 ${adj}${issue.maximum.toString()}`;
+            }
+            case "too_small": {
+                const adj = issue.inclusive ? ">=" : ">";
+                const sizing = getSizing(issue.origin);
+                if (sizing) {
+                    return `數值過小：預期 ${issue.origin} 應為 ${adj}${issue.minimum.toString()} ${sizing.unit}`;
+                }
+                return `數值過小：預期 ${issue.origin} 應為 ${adj}${issue.minimum.toString()}`;
+            }
+            case "invalid_format": {
+                const _issue = issue;
+                if (_issue.format === "starts_with") {
+                    return `無效的字串：必須以 "${_issue.prefix}" 開頭`;
+                }
+                if (_issue.format === "ends_with")
+                    return `無效的字串：必須以 "${_issue.suffix}" 結尾`;
+                if (_issue.format === "includes")
+                    return `無效的字串：必須包含 "${_issue.includes}"`;
+                if (_issue.format === "regex")
+                    return `無效的字串：必須符合格式 ${_issue.pattern}`;
+                return `無效的 ${FormatDictionary[_issue.format] ?? issue.format}`;
+            }
+            case "not_multiple_of":
+                return `無效的數字：必須為 ${issue.divisor} 的倍數`;
+            case "unrecognized_keys":
+                return `無法識別的鍵值${issue.keys.length > 1 ? "們" : ""}：${util.joinValues(issue.keys, "、")}`;
+            case "invalid_key":
+                return `${issue.origin} 中有無效的鍵值`;
+            case "invalid_union":
+                return "無效的輸入值";
+            case "invalid_element":
+                return `${issue.origin} 中有無效的值`;
+            default:
+                return `無效的輸入值`;
+        }
+    };
+};
+export default function () {
+    return {
+        localeError: error(),
+    };
+}

package/.output/server/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "uomtiles-prod",
+  "version": "0.1.0",
+  "type": "module",
+  "private": true,
+  "dependencies": {
+    "@babel/parser": "7.29.8",
+    "@iconify/utils": "3.1.4",
+    "@vue/compiler-core": "3.5.41",
+    "@vue/compiler-dom": "3.5.41",
+    "@vue/compiler-ssr": "3.5.41",
+    "@vue/reactivity": "3.5.41",
+    "@vue/runtime-core": "3.5.41",
+    "@vue/runtime-dom": "3.5.41",
+    "@vue/server-renderer": "3.5.41",
+    "@vue/shared": "3.5.41",
+    "consola": "3.4.2",
+    "devalue": "5.9.0",
+    "entities": "7.0.1",
+    "estree-walker": "2.0.2",
+    "fflate": "0.8.3",
+    "fnv1a-64": "0.1.2",
+    "hookable": "6.1.1",
+    "nostics": "1.2.0",
+    "object-identity": "0.2.3",
+    "p-limit": "6.2.0",
+    "pmtiles": "4.5.0",
+    "source-map-js": "1.2.1",
+    "tailwindcss": "4.3.3",
+    "ufo": "1.6.4",
+    "unhead": "3.3.2",
+    "vue": "3.5.41",
+    "vue-bundle-renderer": "2.3.2",
+    "yocto-queue": "1.2.2",
+    "zod": "4.4.3"
+  }
+}

package/LICENSE

@@ -0,0 +1,3 @@
+Copyright (c) 2026. All rights reserved.
+
+This package is not licensed for redistribution or modification unless a separate written license is provided.

package/README.md

@@ -0,0 +1,125 @@
+<p align="center">
+  <img src="public/favicon.svg" width="72" height="72" alt="UOM适飞地图">
+</p>
+
+# UOM适飞地图
+
+本地运行的 UOM 适飞空域预览、下载、对比和发布工具。每次地图下载保存为可断点续传的 `.uomtiles` SQLite 工作文件，并可导出标准 MBTiles 或 PMTiles。
+
+## 快速开始
+
+需要 Node.js 22.13 或更高版本（使用内建 `node:sqlite`）。
+
+```bash
+npx uomtiles
+```
+
+命令会启动本地 Web 工作台并打开浏览器。首次使用时通过手机号登录 UOM；凭据只写入本机 `~/.uomtiles/auth.json`，权限为 `0600`，不会写入任务文件或导出文件。
+
+工作台包含五个功能：
+
+- 在线地图预览：代理 UOM 官方实时地图，不把 token 发送给浏览器。
+- 地图下载任务：创建、导入和管理 `.uomtiles` 任务；完成任务可查看和导出，未完成任务可断点续传。
+- 地图版本对比：分别选择或拖入 `.uomtiles`、`.mbtiles`、`.pmtiles`，在浏览器 Worker 中执行逐瓦片 alpha 像素 diff，并同步移动、滑块或叠加审阅。
+- 地图高级功能：选择本地地图文件后，可按当前位置和最小面积寻找多个最近的适飞区域。
+- 地图服务管理：从任务文件启用本地 WMS/WMTS 服务，并配置颜色与透明度。
+
+浏览器负责登录、文件选择和并行像素计算。所选文件以流式方式导入本机工作区，不会整文件读入浏览器或 Node 内存；SQLite 事务、写入 lease、抓取、动态瓦片和导出由本地 Node 核心实现，CLI 与 Nuxt 服务端复用同一套代码。
+
+## CLI
+
+```bash
+# 验证固定账户文件，并实际请求 UOM SSO
+npx uomtiles whoami
+
+# 创建以当前昵称和时间命名的工作文件并前台显示进度
+npx uomtiles fetch
+
+# 创建或从 checkpoint 继续指定任务
+npx uomtiles fetch china-2026-08-21.uomtiles
+
+# 转入后台下载
+npx uomtiles fetch -d china-2026-08-21.uomtiles
+
+# 查看文件摘要
+npx uomtiles inspect china-2026-08-21.uomtiles
+
+# 生成干净的标准发布文件
+npx uomtiles export china-2026-08-21.uomtiles china.mbtiles
+npx uomtiles export china-2026-08-21.uomtiles china.pmtiles
+
+# 可重复性检查；不一致时退出码为 2
+npx uomtiles diff first.uomtiles second.uomtiles repeatability.json
+
+# 将旧任务数据库复制迁移为工作文件；源文件不修改
+npx uomtiles migrate legacy.mbtiles task.uomtiles
+```
+
+PMTiles 导出调用 Protomaps `pmtiles convert`。可用 `UOMTILES_PMTILES_COMMAND` 指定命令路径。
+
+发布包不依赖 `sharp`、`better-sqlite3` 或 `sqlite3` 等原生 addon。SQLite、PNG inflate/deflate 和文件操作分别使用 Node 内建的 `node:sqlite`、`node:zlib` 与 `node:fs`；PMTiles 读取使用纯 JavaScript `pmtiles` 包。PMTiles 转换器是可选的外部 CLI，只有执行 PMTiles 导出时才需要。
+
+## 文件格式
+
+`.uomtiles` 是 UOMTiles schema v1 SQLite 工作数据库，包含：
+
+- z9 root 事务 checkpoint、状态、重试和 heartbeat；
+- 从官方 z12 位图恢复的全局 `2^18` 等经纬网格矩形；
+- 仅 z12 物化 PNG 源瓦片；
+- 发布者昵称、抓取起止时间、source z12、grid level 18 和工具版本；
+- 审阅记录与后续局部修复扩展表。
+
+每个 `.uomtiles` 内的 `uomtiles_leases` 表保存 writer lease。抓取、导出等写操作只锁定自己的任务文件，因此不同任务可以并行；同一任务仍然只能有一个 writer。抢占使用 `BEGIN IMMEDIATE`，运行时每 10 秒续租，默认 30 秒过期，因此进程崩溃后无需删除独立 lockfile，也不会永久阻塞续传。工作台通过扫描这些 lease 感知 CLI 后台进程，并按 lease 中的 PID 停止对应任务。
+
+`.uomtiles` 预览时从 canonical geometry 动态生成 z0-z18：z0-z8 使用四子瓦片 OR 缩小，z9-z18 直接按全局经纬网格光栅化，输出只有透明或不透明像素，不做图像插值。MBTiles/PMTiles 导出会实际写入 z0-z14，因此常用外部查看器在已发布层级内不会把 z12 模糊插值放大。导出文件只保留标准 `metadata` / `tiles` 表，并使用扩展 metadata 记录发布者昵称与抓取时间；手机号、session token、地图 token 不会嵌入。
+
+## 项目结构
+
+```text
+app/                 Nuxt 4 客户端应用、页面、布局和浏览器 composables
+server/              Nitro API 路由与仅服务端的任务、认证、地图代理逻辑
+shared/              浏览器与服务端共享的纯 TypeScript DTO
+src/                 CLI 与服务端共同复用的抓取、SQLite、PNG 和导出核心
+  core/              .uomtiles schema、SQLite lease、路径与 PNG codec
+*.test.ts            单模块测试伴随源码放置；Nuxt runtime 测试使用 *.nuxt.test.ts
+research/            历史逆向、旧管线和像素实验，不进入发布包
+data/                本地认证、运行状态、缓存和任务文件，始终忽略提交
+```
+
+Nuxt 使用 v4 默认 `app/` source directory；`server/` 与 `shared/` 保持根级目录。CLI 源码使用 Node 原生 TypeScript type stripping 直接开发运行，发布前由 `tsconfig.cli.json` 编译到被忽略的 `dist/`。Nuxt/Nitro 生产输出写入被忽略的 `.output/`。
+
+## 抓取模型
+
+生产抓取固定使用已验证的 z12 官方数据，不接受用户修改层级参数：
+
+1. 按中国范围的 6030 个 z9 root 请求 z12 supertile。
+2. 将透明位图矢量化为全局 `2^18` 等经纬网格上的直角矩形。
+3. 每个 root 在单独 SQLite 事务内提交 geometry、checksum 和 z12 内容瓦片。
+4. 全部 root 完成后只保留 z12 源瓦片；其他层级按需生成，导出时物化 z0-z14。
+
+相邻层一次 exact 不用于推断更深层级。z12 的选择来自瑞云观及中国东南西北复杂区域的真实 z13/z14 交叉验证。
+
+## 开发
+
+```bash
+pnpm install
+pnpm dev
+pnpm typecheck
+pnpm test
+pnpm build
+```
+
+测试使用一个 Vitest 入口和两个 projects。纯 Node/TypeScript 测试以 `a.test.ts` 伴随 `a.ts` 放置，在快速的 Node environment 中运行；依赖 Nuxt auto-import、`useState` 或组件运行时的测试使用同目录 `a.nuxt.test.ts`，由 `@nuxt/test-utils` 的 Nuxt environment 运行。两类测试统一由 `pnpm test` 执行。
+
+常用环境变量：
+
+- `UOMTILES_DATA_DIR`：账户和 Web 工作区目录。`npx uomtiles` 默认使用 `~/.uomtiles`，仓库内 `pnpm dev` 默认使用 `./data`。
+- `UOMTILES_AUTH_FILE`：CLI 固定认证文件。
+- `UOMTILES_PORT`：本地 Web 首选端口，默认 `4173`。
+- `UOMTILES_PMTILES_COMMAND`：PMTiles 转换命令。
+
+## 品牌与许可
+
+产品图标使用 [Lucide `map-pinned`](https://icones.js.org/collection/lucide?s=map-pinned)，通过 Iconify/Icones 获取，依照 Lucide ISC License 使用。
+
+源代码版权与使用限制见 [LICENSE](LICENSE)。

package/dist/src/bbox.js

@@ -0,0 +1,55 @@
+export const EARTH_R = 20037508.342789244;
+export function tileToMercBBox(z, x, y) {
+    const ts = 2 * EARTH_R / Math.pow(2, z);
+    const minx = -EARTH_R + x * ts;
+    const maxy = EARTH_R - y * ts;
+    return { minx, miny: maxy - ts, maxx: minx + ts, maxy };
+}
+export function lonLatToTile(lon, lat, z) {
+    const n = Math.pow(2, z);
+    const x = Math.floor((lon + 180) / 360 * n);
+    const latRad = lat * Math.PI / 180;
+    const y = Math.floor((1 - Math.log(Math.tan(latRad) + 1 / Math.cos(latRad)) / Math.PI) / 2 * n);
+    return { x, y };
+}
+export function mercToLonLat(mx, my) {
+    return {
+        lon: mx / EARTH_R * 180,
+        lat: 180 / Math.PI * (2 * Math.atan(Math.exp(my / EARTH_R * Math.PI)) - Math.PI / 2),
+    };
+}
+export function tileBBoxLonLat(z, x, y) {
+    const b = tileToMercBBox(z, x, y);
+    const sw = mercToLonLat(b.minx, b.miny);
+    const ne = mercToLonLat(b.maxx, b.maxy);
+    return { lonMin: sw.lon, latMin: sw.lat, lonMax: ne.lon, latMax: ne.lat };
+}
+export function tileRangeForBBox(z, lonMin, latMin, lonMax, latMax) {
+    const a = lonLatToTile(lonMin, latMax, z);
+    const b = lonLatToTile(lonMax, latMin, z);
+    return {
+        xMin: Math.min(a.x, b.x),
+        xMax: Math.max(a.x, b.x),
+        yMin: Math.min(a.y, b.y),
+        yMax: Math.max(a.y, b.y),
+    };
+}
+export function xyzYToTmsY(z, y) {
+    return (1 << z) - 1 - y;
+}
+export function tmsYToXyzY(z, tmsY) {
+    return (1 << z) - 1 - tmsY;
+}
+export function bboxToZxy(bbox, width, height) {
+    if (width !== 256 || height !== 256)
+        return null;
+    const span = bbox.maxx - bbox.minx;
+    const zApprox = Math.log2(2 * EARTH_R / span);
+    const z = Math.round(zApprox);
+    if (Math.abs(zApprox - z) > 1e-3)
+        return null;
+    const ts = 2 * EARTH_R / Math.pow(2, z);
+    const x = Math.round((bbox.minx + EARTH_R) / ts);
+    const y = Math.round((EARTH_R - bbox.maxy) / ts);
+    return { z, x, y };
+}